johanels/penpot
1
0
Fork 0
mirror of https://github.com/penpot/penpot.git synced 2025-12-12 06:24:17 +01:00
Code Issues Actions 9 Packages Projects Releases Wiki Activity

✨ Add general improvement to openapi and js-like doc output

Browse Source
This commit is contained in:
Andrey Antukh
2025-08-19 14:09:07 +02:00
parent 2b83d0d0e9
commit b472a8ab19
15 changed files with 550 additions and 466 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
backend/dev/user.clj
View File

@@ -18,6 +18,7 @@
[app.common.schema :as sm]
[app.common.schema.desc-js-like :as smdj]
[app.common.schema.desc-native :as smdn]
[app.common.schema.openapi :as oapi]
[app.common.schema.generators :as sg]
[app.common.spec :as us]
[app.common.json :as json]

5
backend/src/app/rpc/commands/fonts.clj
View File

@@ -37,14 +37,13 @@
(def ^:private
schema:get-font-variants
[:schema {:title "get-font-variants"}
[:and
[:map
[:map {:title "get-font-variants"}
[:team-id {:optional true} ::sm/uuid]
[:file-id {:optional true} ::sm/uuid]
[:project-id {:optional true} ::sm/uuid]
[:share-id {:optional true} ::sm/uuid]]
[::sm/contains-any #{:team-id :file-id :project-id}]]])
[::sm/contains-any #{:team-id :file-id :project-id}]])
(sv/defmethod ::get-font-variants
{::doc/added "1.18"

3
backend/src/app/rpc/doc.clj
View File

@@ -166,9 +166,6 @@
:servers [{:url (str/ffmt "%/api/rpc" (cf/get :public-uri))
;; :description "penpot backend"
}]
:security
{:api_key []}
:paths paths
:components {:schemas @definitions}}))

29
common/src/app/common/files/changes.cljc
View File

@@ -83,24 +83,25 @@
[:multi {:decode/json #(update % :grid-type keyword)
:gen/gen gen
:title "SetDefaultGridChange"
:dispatch :grid-type
::smd/simplified true}
[:square
[:map
[:map {:title "SetDefautSquareGridAttrs"}
[:type [:= :set-default-grid]]
[:page-id ::sm/uuid]
[:grid-type [:= :square]]
[:params [:maybe ctg/schema:square-params]]]]
[:column
[:map
[:map {:title "SetDefaultColumnGridAttrs"}
[:type [:= :set-default-grid]]
[:page-id ::sm/uuid]
[:grid-type [:= :column]]
[:params [:maybe ctg/schema:column-params]]]]
[:row
[:map
[:map {:title "SetDefaultRowGridAttrs"}
[:type [:= :set-default-grid]]
[:page-id ::sm/uuid]
[:grid-type [:= :row]]
@@ -117,7 +118,7 @@
(if (some? (:params change))
(update change :params assoc :id (:id change))
change))))]
[:schema {:gen/gen gen} schema]))
(sm/update-properties schema assoc :gen/gen gen)))
(def schema:set-flow-change
(let [schema [:map {:title "SetFlowChange"}
@@ -132,7 +133,7 @@
(update change :params assoc :id (:id change))
change))))]
[:schema {:gen/gen gen} schema]))
(sm/update-properties schema assoc :gen/gen gen)))
(def schema:set-plugin-data-change
(let [types #{:file :page :shape :color :typography :component}
@@ -169,18 +170,16 @@
:else
(dissoc change :page-id)))))]
[:and {:gen/gen gen} schema check1]))
[:and (sm/update-properties schema assoc :gen/gen gen) check1]))
(def schema:change
[:schema
[:multi {:dispatch :type
:title "Change"
:decode/json #(update % :type keyword)
::smd/simplified true}
[:set-comment-thread-position
[:map
[:map {:title "SetCommentThreadPositionChange"}
[:comment-thread-id ::sm/uuid]
[:page-id ::sm/uuid]
[:frame-id [:maybe ::sm/uuid]]
@@ -298,10 +297,6 @@
[:type [:= :del-color]]
[:id ::sm/uuid]]]
;; DEPRECATED: remove before 2.3
[:add-recent-color
[:map {:title "AddRecentColorChange"}]]
[:add-media
[:map {:title "AddMediaChange"}
[:type [:= :add-media]]
@@ -434,7 +429,7 @@
[:set-base-font-size
[:map {:title "ModBaseFontSize"}
[:type [:= :set-base-font-size]]
[:base-font-size :string]]]]])
[:base-font-size :string]]]])
(def schema:changes
[:sequential {:gen/max 5 :gen/min 1} schema:change])
@@ -936,12 +931,6 @@
[data {:keys [id]}]
(ctl/delete-color data id))
;; DEPRECATED: remove before 2.3
(defmethod process-change :add-recent-color
[data _]
data)
;; -- Media
(defmethod process-change :add-media

52
common/src/app/common/schema.cljc
View File

@@ -131,34 +131,10 @@
(->> (entries schema)
(into #{} xf:map-key)))
;; (defn key-transformer
;; [& {:as opts}]
;; (mt/key-transformer opts))
;; (defn- transform-map-keys
;; [f o]
;; (cond
;; (record? o)
;; (reduce-kv (fn [res k v]
;; (let [k' (f k)]
;; (if (= k k')
;; res
;; (-> res
;; (assoc k' v)
;; (dissoc k)))))
;; o
;; o)
;; (map? o)
;; (persistent!
;; (reduce-kv (fn [res k v]
;; (assoc! res (f k) v))
;; (transient {})
;; o))
;; :else
;; o))
(defn update-properties
[s f & args]
(let [s (schema s)]
(apply m/-update-properties s f args)))
(defn -transform-map-keys
([f]
@@ -679,8 +655,7 @@
identity)]
{:pred #(contains? options %)
:type-properties
{:title "one-of"
:description "One of the Set"
{:title "enum"
:gen/gen (sg/elements options)
:decode/string decode
:decode/json decode
@@ -723,15 +698,14 @@
{:pred pred
:type-properties
{:title "int"
:description "int"
{:title "integer"
:description "integer"
:error/message "expected to be int/long"
:error/code "errors.invalid-integer"
:gen/gen gen
:decode/string parse-long
:decode/json parse-long
::oapi/type "integer"
::oapi/format "int64"}}))})
::oapi/type "integer"}}))})
(defn parse-double
[v]
@@ -793,8 +767,8 @@
{:pred pred
:type-properties
{:title "int"
:description "int"
{:title "number"
:description "number"
:error/message "expected to be number"
:error/code "errors.invalid-number"
:gen/gen gen
@@ -844,10 +818,7 @@
#(some (fn [prop]
(contains? % prop))
choices))]
{:pred pred
:type-properties
{:title "contains any"
:description "contains predicate"}}))})
{:pred pred}))})
;; (register!
;; {:type ::inst
@@ -968,6 +939,7 @@
:type-properties
{:title "string"
:description "not whitespace string"
::oapi/type "string"
:gen/gen (sg/word-string)
:error/fn
(fn [{:keys [value schema]}]

192
common/src/app/common/schema/desc_js_like.cljc
View File

@@ -91,11 +91,15 @@
(defmethod visit :int [_ schema _ _] (str "integer" (-titled schema) (-min-max-suffix-number schema)))
(defmethod visit :double [_ schema _ _] (str "double" (-titled schema) (-min-max-suffix-number schema)))
(defmethod visit :select-keys [_ schema _ options] (describe* (m/deref schema) options))
(defmethod visit :and [_ s children _] (str (str/join " && " children) (-titled s)))
(defmethod visit :and [_ s children _]
(str (str/join " && " (filter some? children)) (-titled s)))
(defmethod visit :enum [_ s children _options] (str "enum" (-titled s) " of " (str/join ", " children)))
(defmethod visit :maybe [_ _ children _] (str (first children) " nullable"))
(defmethod visit :tuple [_ _ children _] (str "(" (str/join ", " children) ")"))
(defmethod visit :re [_ s _ options] (str "regex pattern " (-titled s) "matching " (pr-str (first (m/children s options)))))
(defmethod visit :re [_ _ children _]
(let [pattern (first children)]
(str "string & regex pattern /" (str pattern) "/")))
(defmethod visit :any [_ s _ _] (str "anything" (-titled s)))
(defmethod visit :some [_ _ _ _] "anything but null")
(defmethod visit :nil [_ _ _ _] "null")
@@ -108,10 +112,11 @@
(defmethod visit :uuid [_ _ _ _] "uuid")
(defmethod visit :boolean [_ _ _ _] "boolean")
(defmethod visit :keyword [_ _ _ _] "string")
(defmethod visit :fn [_ _ _ _] "FN")
(defmethod visit :fn [_ _ _ _]
nil)
(defmethod visit :vector [_ _ children _]
(str "[" (last children) "]"))
(str "[" (str/trim (last children)) "]"))
(defn -tagged [children] (map (fn [[tag _ c]] (str c " (tag: " tag ")")) children))
@@ -137,8 +142,15 @@
(some? suffix)
(str suffix))))
(defmethod visit :map-of [_ _ children _]
(str "map[" (first children) "," (second children) "]"))
(defmethod visit :map-of
[_ schema children _]
(let [props (m/properties schema)
title (some->> (:title props) str/camel str/capital)]
(str (if title
(str "type " title ": ")
"")
"map[" (first children) "," (second children) "]")))
(defmethod visit :union [_ _ children _]
(str/join " | " children))
@@ -156,61 +168,104 @@
(or (:title props)
"*")))
(defmethod visit :map
[_ schema children {:keys [::level ::max-level] :as options}]
(let [props (m/properties schema)
closed? (:closed props)
title (some->> (:title props) str/camel str/capital)]
(if (>= level max-level)
(or (some-> title str)
"<untitled>")
(let [optional (into #{} (comp (filter (m/-comp :optional second))
(defn- format-map
[schema children]
(let [props (m/properties schema)
closed? (get props :closed)
title (some->> (:title props) str/camel str/capital)
optional (into #{} (comp (filter (m/-comp :optional second))
(map first))
children)
entries (->> children
(map (fn [[k _ s]]
(str (pad " " level) (str/camel k)
;; NOTE: maybe we can detect multiple lines
;; and then just insert a break line
(str " " (str/camel k)
(when (contains? optional k) "?")
": " s)))
": " (str/trim s))))
(str/join ",\n"))
header (cond-> (str "type " title)
closed? (str "!")
(some? title) (str " "))]
(str (pad header level) "{\n" entries "\n" (pad "}\n" level))))))
(str header "{\n" entries "\n}")))
(defmethod visit :multi
[_ s children {:keys [::level ::max-level] :as options}]
(defmethod visit :map
[_ schema children {:keys [::level] :as options}]
(let [props (m/properties schema)
extracted? (get props ::extracted false)]
(cond
(or (= level 0) extracted?)
(format-map schema children)
:else
(let [schema (mu/update-properties schema assoc ::extracted true)
title (or (some->> (:title props) str/camel str/capital) "<untitled>")]
(swap! *definitions* conj (format-map schema children))
title))))
(defn format-multi
[s children]
(let [props (m/properties s)
title (some-> (:title props) str/camel str/capital)]
(if (>= level max-level)
title
(let [dispatcher (or (-> s m/properties :dispatch-description)
title (or (some-> (:title props) str/camel str/capital) "<untitled>")
dispatcher (or (-> s m/properties :dispatch-description)
(-> s m/properties :dispatch))
prefix (apply str (take (inc level) (repeat " ")))
entries (->> children
(map (fn [[_ _ shape]]
(str prefix shape)))
(map (fn [[_ _ entry]]
(pad entry 1)))
(str/join ",\n"))
header (cond-> "multi"
(some? title) (str " " title)
:always (str " [dispatch=" (d/name dispatcher) "]"))]
header (str "type " title " [dispatch=" (d/name dispatcher) "]")]
(str header " {\n" entries "\n}")))
(str header " {\n" entries "\n" (pad "}" level))))))
(defmethod visit :multi
[_ schema children {:keys [::level] :as options}]
(let [props (m/properties schema)
title (or (some-> (:title props) str/camel str/capital) "<untitled>")
extracted? (get props ::extracted false)]
(cond
(or (zero? level) extracted?)
(format-multi schema children)
:else
(let [schema (mu/update-properties schema assoc ::extracted true)]
(swap! *definitions* conj (format-multi schema children))
title))))
(defn- format-merge
[schema children]
(let [props (m/properties schema)
entries (->> children
(map (fn [shape]
(pad shape 1)))
(str/join ",\n"))
title (some-> (:title props) str/camel str/capital)
header (str "merge type " title)]
(str header " {\n" entries "\n}")))
(defmethod visit :merge
[_ schema children _]
(let [entries (str/join ",\n" children)
props (m/properties schema)
title (or (some-> (:title props) str/camel str/capital)
"<untitled>")]
(str "merge type " title " { \n" entries "\n}\n")))
[_ schema children {:keys [::level] :as options}]
(let [props (m/properties schema)
title (some-> (:title props) str/camel str/capital)
extracted? (get props ::extracted false)]
(cond
(or (zero? level) extracted?)
(format-merge schema children)
:else
(let [schema (mu/update-properties schema assoc ::extracted true)]
(swap! *definitions* conj
(format-merge schema children))
title))))
(defmethod visit ::sm/one-of
[_ _ children _]
@@ -219,45 +274,37 @@
(map d/name)
(str/join "|")) ")")))
(defmethod visit :schema [_ schema children options]
(visit ::m/schema schema children options))
(defmethod visit ::m/schema
[_ schema _ {:keys [::level ::limit ::max-level] :as options}]
(let [schema' (m/deref schema)
props (merge
(m/properties schema)
(m/properties schema'))
ref (m/-ref schema)
title (:title props)]
(defmethod visit :schema
[_ schema children options]
(let [props (m/properties schema)
title (some-> (:title props) str/camel str/capital)
extracted? (get props ::extracted false)]
(cond
(::inline props)
(do
(if (>= limit max-level)
title
(describe* schema' options)))
(not title)
(visit ::m/schema schema children options)
(and ref title)
(do
(when (<= limit max-level)
(swap! *definitions* conj (describe* schema' (assoc options ::base-limit limit))))
title)
(>= limit max-level)
(or title
(some-> ref d/name str/camel str/capital)
"<untitled>")
extracted?
(let [title (or title "<untitled>")]
(str "type " title ": "
(visit ::m/schema schema children options)))
:else
(describe* schema' (assoc options ::base-level level ::base-limit limit)))))
(let [schema (mu/update-properties schema assoc ::extracted true)
title (or title "<untitled>")]
(swap! *definitions* conj
(str "type " title ": "
(visit ::m/schema schema children (update options ::level inc))))
title))))
(defmethod visit ::m/schema
[_ schema _ {:keys [::level] :as options}]
(let [schema' (m/deref schema)]
(describe* schema' (assoc options ::base-level level))))
(defn describe* [s options]
(letfn [(walk-fn [schema path children {:keys [::base-level ::base-limit] :or {base-level 0 base-limit 0} :as options}]
(let [options (assoc options
::limit (+ base-limit (count path))
::level (+ base-level (count path)))]
(letfn [(walk-fn [schema path children {:keys [::base-level] :or {base-level 0} :as options}]
(let [options (assoc options ::level (+ base-level (count path)))]
(visit (m/type schema) schema children options)))]
(m/walk s walk-fn options)))
@@ -275,8 +322,7 @@
(mu/update-properties assoc ::root true))
options (into {::m/walk-entry-vals true
::level 0
::max-level 300}
::level 0}
options)]
(binding [*definitions* defs]

117
common/src/app/common/schema/openapi.cljc
View File

@@ -6,6 +6,8 @@
(ns app.common.schema.openapi
(:require
[app.common.data :as d]
[app.common.schema :as-alias sm]
[clojure.set :as set]
[cuerdas.core :as str]
[malli.core :as m]))
@@ -15,16 +17,44 @@
(declare transform*)
(defmulti visit (fn [name _schema _children _options] name) :default ::default)
(defmethod visit ::default [_ _ _ _] {})
(defmethod visit ::default [_ schema _ _]
(let [props (m/type-properties schema)]
(d/without-nils
{:type (get props ::type)
:format (get props ::format)
:title (get props :title)
:description (get props :description)})))
(defmethod visit :> [_ _ [value] _] {:type "number" :exclusiveMinimum value})
(defmethod visit :>= [_ _ [value] _] {:type "number" :minimum value})
(defmethod visit :< [_ _ [value] _] {:type "number" :exclusiveMaximum value})
(defmethod visit :<= [_ _ [value] _] {:type "number" :maximum value})
(defmethod visit := [_ _ [value] _] {:const value})
(defmethod visit := [_ schema children _]
(let [props (m/properties schema)
type (get props :type :string)]
(d/without-nils
{:type (or (get props ::type)
(d/name type))
:enum (if (= :string type)
(mapv d/name children)
(vec children))})))
(defmethod visit :not= [_ _ _ _] {})
(defmethod visit :fn [_ _ _ _]
nil)
(defmethod visit ::sm/contains-any [_ _ _ _]
nil)
(defmethod visit :not [_ _ children _] {:not (last children)})
(defmethod visit :and [_ _ children _] {:allOf children})
(defmethod visit :and [_ _ children _]
{:allOf (keep not-empty children)})
(defmethod visit :or [_ _ children _] {:anyOf children})
(defmethod visit :orn [_ _ children _] {:anyOf (map last children)})
@@ -71,14 +101,28 @@
:minProperties
:maxProperties))
(defmethod visit :vector [_ schema children _]
(let [child (-> schema m/children first)
props (m/properties (m/deref child))]
(defmethod visit :any [_ _ _ _]
{:description "Any Value"})
(defmethod visit ::sm/set [_ schema children _]
(minmax-properties
{:type "array", :items (first children) :title (:title props)}
{:type "array", :items (first children), :uniqueItems true}
schema
:minItems
:maxItems)))
:maxItems))
(defmethod visit ::sm/vec [_ schema children _]
(minmax-properties
{:type "array", :items (first children)}
schema
:minItems
:maxItems))
(defmethod visit :vector [_ schema children options]
(visit ::sm/vec schema children options))
(defmethod visit :set [_ schema children options]
(visit ::sm/set schema children options))
(defmethod visit :sequential [_ schema children _]
(minmax-properties
@@ -87,36 +131,64 @@
:minItems
:maxItems))
(defmethod visit :set [_ schema children _]
(minmax-properties
{:type "array", :items (first children), :uniqueItems true}
schema
:minItems
:maxItems))
(defmethod visit :enum [_ _ children options]
(merge (some-> (m/-infer children) (transform* options)) {:enum children}))
(defmethod visit :maybe [_ _ children _]
(let [children (first children)]
(assoc children :nullable true)))
(defmethod visit :tuple [_ _ children _]
{:type "array", :items children, :additionalItems false})
(defmethod visit :enum [_ _ children options] (merge (some-> (m/-infer children) (transform* options)) {:enum children}))
(defmethod visit :maybe [_ _ children _] {:oneOf (conj children {:type "null"})})
(defmethod visit :tuple [_ _ children _] {:type "array", :items children, :additionalItems false})
(defmethod visit :re [_ schema _ options]
{:type "string", :pattern (str (first (m/children schema options)))})
(defmethod visit :nil [_ _ _ _] {:type "null"})
(defmethod visit :string [_ schema _ _]
(merge {:type "string"} (-> schema m/properties (select-keys [:min :max]) (set/rename-keys {:min :minLength, :max :maxLength}))))
(defmethod visit ::sm/one-of [_ _ children _]
(let [options (->> (first children)
(mapv d/name))]
{:type "string"
:enum options}))
(defmethod visit :int [_ schema _ _]
(merge {:type "integer"} (-> schema m/properties (select-keys [:min :max]) (set/rename-keys {:min :minimum, :max :maximum}))))
(minmax-properties
{:type "integer"}
schema
:minimum
:maximum))
(defmethod visit :double [_ schema _ _]
(merge {:type "number"}
(-> schema m/properties (select-keys [:min :max]) (set/rename-keys {:min :minimum, :max :maximum}))))
(minmax-properties
{:type "number"
:format "double"}
schema
:minimum
:maximum))
(defmethod visit ::sm/int
[_ schema children options]
(visit :int schema children options))
(defmethod visit ::sm/double
[_ schema children options]
(visit :double schema children options))
(defmethod visit :boolean [_ _ _ _] {:type "boolean"})
(defmethod visit ::sm/boolean [_ _ _ _] {:type "boolean"})
(defmethod visit :keyword [_ _ _ _] {:type "string"})
(defmethod visit :qualified-keyword [_ _ _ _] {:type "string"})
(defmethod visit :symbol [_ _ _ _] {:type "string"})
(defmethod visit :qualified-symbol [_ _ _ _] {:type "string"})
(defmethod visit :uuid [_ _ _ _] {:type "string" :format "uuid"})
(defmethod visit ::sm/uuid [_ _ _ _] {:type "string" :format "uuid"})
(defmethod visit :schema [_ schema children options]
(visit ::m/schema schema children options))
@@ -124,11 +196,14 @@
(defmethod visit ::m/schema [_ schema _ options]
(let [result (transform* (m/deref schema) options)
defpath (::definitions-path options "#/definitions/")]
(if (::embed options)
result
(if-let [ref (m/-ref schema)]
(let [rkey (str/concat (str/camel (namespace ref)) "$" (name ref))]
(some-> *definitions* (swap! assoc rkey result))
{"$ref" (str/concat defpath rkey)})
result)))
result))))
(defmethod visit :merge [_ schema _ options] (transform* (m/deref schema) options))
(defmethod visit :union [_ schema _ options] (transform* (m/deref schema) options))

19
common/src/app/common/types/color.cljc
View File

@@ -60,16 +60,17 @@
{:type ::hex-color
:pred hex-color-string?
:type-properties
{:title "hex-color"
{:title "HexColor"
:description "HEX Color String"
:error/message "expected a valid HEX color"
:error/code "errors.invalid-hex-color"
:gen/gen hex-color-generator
::oapi/type "integer"
::oapi/format "int64"}}))
::oapi/type "string"
::oapi/format "rgb"}}))
(def schema:plain-color
[:map [:color schema:hex-color]])
[:map {:title "PlainColorAttrs"}
[:color schema:hex-color]])
(def schema:image
[:map {:title "ImageColor" :closed true}
@@ -85,7 +86,8 @@
(sm/keys schema:image))
(def schema:image-color
[:map [:image schema:image]])
[:map {:title "ImageColorAttrs"}
[:image schema:image]])
(def gradient-types
#{:linear :radial})
@@ -110,10 +112,11 @@
(sm/keys schema:gradient))
(def schema:gradient-color
[:map [:gradient schema:gradient]])
[:map {:title "GradientColorAttrs"}
[:gradient schema:gradient]])
(def schema:color-attrs
[:map {:title "ColorAttrs" :closed true}
[:map {:title "GenericColorAttrs" :closed true}
[:opacity {:optional true} [::sm/number {:min 0 :max 1}]]
[:ref-id {:optional true} ::sm/uuid]
[:ref-file {:optional true} ::sm/uuid]])
@@ -132,7 +135,7 @@
(into required-color-attrs (sm/keys schema:color-attrs)))
(def schema:library-color-attrs
[:map {:title "ColorAttrs" :closed true}
[:map {:title "LibraryColorAttrs" :closed true}
[:id ::sm/uuid]
[:name ::sm/text]
[:path {:optional true} :string]

12
common/src/app/common/types/grid.cljc
View File

@@ -14,12 +14,12 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(def schema:grid-color
[:map {:title "PageGridColor"}
[:map {:title "GridColor"}
[:color clr/schema:hex-color]
[:opacity ::sm/safe-number]])
(def schema:column-params
[:map
[:map {:title "ColumnGridParams"}
[:color schema:grid-color]
[:type {:optional true} [::sm/one-of #{:stretch :left :center :right}]]
[:size {:optional true} [:maybe ::sm/safe-number]]
@@ -28,7 +28,7 @@
[:gutter {:optional true} [:maybe ::sm/safe-number]]])
(def schema:square-params
[:map
[:map {:title "SquareGridParams"}
[:size {:optional true} [:maybe ::sm/safe-number]]
[:color schema:grid-color]])
@@ -37,19 +37,19 @@
:dispatch :type
:decode/json #(update % :type keyword)}
[:column
[:map
[:map {:title "ColumnGridAttrs"}
[:type [:= :column]]
[:display :boolean]
[:params schema:column-params]]]
[:row
[:map
[:map {:title "RowGridAttrs"}
[:type [:= :row]]
[:display :boolean]
[:params schema:column-params]]]
[:square
[:map
[:map {:title "SquareGridAttrs"}
[:type [:= :square]]
[:display :boolean]
[:params schema:square-params]]]])

4
common/src/app/common/types/path/impl.cljc
View File

@@ -18,6 +18,7 @@
[app.common.data.macros :as dm]
[app.common.schema :as sm]
[app.common.schema.generators :as sg]
[app.common.schema.openapi :as oapi]
[app.common.svg.path :as svg.path]
[app.common.transit :as t]
[app.common.types.path :as-alias path]
@@ -537,7 +538,8 @@
(sg/fmap from-plain))]
{:pred path-data?
:type-properties
{:gen/gen generator
{::oapi/type "string"
:gen/gen generator
:encode/json identity
:decode/json (fn [s]
(cond

2
common/src/app/common/types/plugins.cljc
View File

@@ -24,7 +24,7 @@
(def schema:plugin-data
(sm/register!
^{::sm/type ::plugin-data}
[:map-of {:gen/max 5}
[:map-of {:gen/max 5 :title "PluginsData"}
schema:keyword
[:map-of {:gen/max 5}
schema:string

2
common/src/app/common/types/shape.cljc
View File

@@ -184,7 +184,7 @@
[:height ::sm/safe-number]])
(def schema:shape-generic-attrs
[:map {:title "ShapeAttrs"}
[:map {:title "ShapeGenericAttrs"}
[:page-id {:optional true} ::sm/uuid]
[:component-id {:optional true} ::sm/uuid]
[:component-file {:optional true} ::sm/uuid]

25
common/src/app/common/types/shape/interactions.cljc
View File

@@ -109,8 +109,8 @@
(def check-animation!
(sm/check-fn schema:animation))
(def schema:interaction-attrs
[:map {:title "InteractionAttrs"}
(def schema:generic-interaction-attrs
[:map {:title "GenericInteractionAttrs"}
[:action-type {:optional true} [::sm/one-of action-types]]
[:event-type {:optional true} [::sm/one-of event-types]]
[:destination {:optional true} [:maybe ::sm/uuid]]
@@ -124,7 +124,7 @@
[:url {:optional true} :string]])
(def schema:navigate-interaction
[:map
[:map {:title "NavigateInteraction"}
[:action-type [:= :navigate]]
[:event-type [::sm/one-of event-types]]
[:destination {:optional true} [:maybe ::sm/uuid]]
@@ -132,7 +132,7 @@
[:animation {:optional true} schema:animation]])
(def schema:open-overlay-interaction
[:map
[:map {:title "OpenOverlayInteraction"}
[:action-type [:= :open-overlay]]
[:event-type [::sm/one-of event-types]]
[:overlay-position ::gpt/point]
@@ -144,7 +144,7 @@
[:position-relative-to {:optional true} [:maybe ::sm/uuid]]])
(def schema:toggle-overlay-interaction
[:map
[:map {:title "ToggleOverlayInteraction"}
[:action-type [:= :toggle-overlay]]
[:event-type [::sm/one-of event-types]]
[:overlay-position ::gpt/point]
@@ -156,7 +156,7 @@
[:position-relative-to {:optional true} [:maybe ::sm/uuid]]])
(def schema:close-overlay-interaction
[:map
[:map {:title "CloseOverlayInteraction"}
[:action-type [:= :close-overlay]]
[:event-type [::sm/one-of event-types]]
[:destination {:optional true} [:maybe ::sm/uuid]]
@@ -164,32 +164,33 @@
[:position-relative-to {:optional true} [:maybe ::sm/uuid]]])
(def schema:prev-scren-interaction
[:map
[:map {:title "PrevScreenInteraction"}
[:action-type [:= :prev-screen]]
[:event-type [::sm/one-of event-types]]])
(def schema:open-url-interaction
[:map
[:map {:title "OpenUrlInteraction"}
[:action-type [:= :open-url]]
[:event-type [::sm/one-of event-types]]
[:url :string]])
(def schema:interaction
[:and {:title "Interaction"
[:schema {:title "Interaction"
:gen/gen (sg/one-of (sg/generator schema:navigate-interaction)
(sg/generator schema:open-overlay-interaction)
(sg/generator schema:close-overlay-interaction)
(sg/generator schema:toggle-overlay-interaction)
(sg/generator schema:prev-scren-interaction)
(sg/generator schema:open-url-interaction))}
schema:interaction-attrs
[:multi {:dispatch :action-type}
[:and
schema:generic-interaction-attrs
[:multi {:dispatch :action-type :title "InteractionAttrs"}
[:navigate schema:navigate-interaction]
[:open-overlay schema:open-overlay-interaction]
[:toggle-overlay schema:toggle-overlay-interaction]
[:close-overlay schema:close-overlay-interaction]
[:prev-screen schema:prev-scren-interaction]
[:open-url schema:open-url-interaction]]])
[:open-url schema:open-url-interaction]]]])
(sm/register! ::interaction schema:interaction)

6
common/src/app/common/types/shape/shadow.cljc
View File

@@ -7,7 +7,6 @@
(ns app.common.types.shape.shadow
(:require
[app.common.schema :as sm]
[app.common.schema.generators :as sg]
[app.common.types.color :as ctc]))
(def styles #{:drop-shadow :inner-shadow})
@@ -15,10 +14,7 @@
(def schema:shadow
[:map {:title "Shadow"}
[:id [:maybe ::sm/uuid]]
[:style
[:and {:gen/gen (sg/elements styles)}
:keyword
[::sm/one-of styles]]]
[:style [::sm/one-of styles]]
[:offset-x ::sm/safe-number]
[:offset-y ::sm/safe-number]
[:blur ::sm/safe-number]

43
common/src/app/common/types/token.cljc
View File

@@ -8,6 +8,7 @@
(:require
[app.common.data :as d]
[app.common.schema :as sm]
[app.common.schema.generators :as sg]
[clojure.data :as data]
[clojure.set :as set]
[cuerdas.core :as str]
@@ -56,7 +57,8 @@
(into #{} (keys token-type->dtcg-token-type)))
(def token-name-ref
[:and :string [:re #"^(?!\$)([a-zA-Z0-9-$_]+\.?)*(?<!\.)$"]])
[:re {:title "TokenNameRef" :gen/gen sg/text}
#"^(?!\$)([a-zA-Z0-9-$_]+\.?)*(?<!\.)$"])
(def ^:private schema:color
[:map
@@ -66,7 +68,7 @@
(def color-keys (schema-keys schema:color))
(def ^:private schema:border-radius
[:map
[:map {:title "BorderRadiusTokenAttrs"}
[:r1 {:optional true} token-name-ref]
[:r2 {:optional true} token-name-ref]
[:r3 {:optional true} token-name-ref]
@@ -81,7 +83,7 @@
(def stroke-width-keys (schema-keys schema:stroke-width))
(def ^:private schema:sizing
[:map
[:map {:title "SizingTokenAttrs"}
[:width {:optional true} token-name-ref]
[:height {:optional true} token-name-ref]
[:layout-item-min-w {:optional true} token-name-ref]
@@ -92,44 +94,46 @@
(def sizing-keys (schema-keys schema:sizing))
(def ^:private schema:opacity
[:map
[:map {:title "OpacityTokenAttrs"}
[:opacity {:optional true} token-name-ref]])
(def opacity-keys (schema-keys schema:opacity))
(def ^:private schema:spacing-gap
[:map
[:map {:title "SpacingGapTokenAttrs"}
[:row-gap {:optional true} token-name-ref]
[:column-gap {:optional true} token-name-ref]])
(def ^:private schema:spacing-padding
[:map
[:map {:title "SpacingPaddingTokenAttrs"}
[:p1 {:optional true} token-name-ref]
[:p2 {:optional true} token-name-ref]
[:p3 {:optional true} token-name-ref]
[:p4 {:optional true} token-name-ref]])
(def ^:private schema:spacing-margin
[:map
[:map {:title "SpacingMarginTokenAttrs"}
[:m1 {:optional true} token-name-ref]
[:m2 {:optional true} token-name-ref]
[:m3 {:optional true} token-name-ref]
[:m4 {:optional true} token-name-ref]])
(def ^:private schema:spacing
(reduce mu/union [schema:spacing-gap
(-> (reduce mu/union [schema:spacing-gap
schema:spacing-padding
schema:spacing-margin]))
schema:spacing-margin])
(mu/update-properties assoc :title "SpacingTokenAttrs")))
(def spacing-margin-keys (schema-keys schema:spacing-margin))
(def spacing-keys (schema-keys schema:spacing))
(def ^:private schema:dimensions
(reduce mu/union [schema:sizing
(-> (reduce mu/union [schema:sizing
schema:spacing
schema:stroke-width
schema:border-radius]))
schema:border-radius])
(mu/update-properties assoc :title "DimensionsTokenAttrs")))
(def dimensions-keys (schema-keys schema:dimensions))
@@ -140,22 +144,20 @@
(def axis-keys (schema-keys schema:axis))
(def ^:private schema:rotation
[:map
[:map {:title "RotationTokenAttrs"}
[:rotation {:optional true} token-name-ref]])
(def rotation-keys (schema-keys schema:rotation))
(def ^:private schema:font-size
[:map
[:map {:title "FontSizeTokenAttrs"}
[:font-size {:optional true} token-name-ref]])
(def font-size-keys (schema-keys schema:font-size))
(def ^:private schema:letter-spacing
[:map
[:map {:title "LetterSpacingTokenAttrs"}
[:letter-spacing {:optional true} token-name-ref]])
(def letter-spacing-keys (schema-keys schema:letter-spacing))
@@ -197,8 +199,9 @@
(def ff-typography-keys (set/difference typography-keys font-size-keys))
(def ^:private schema:number
(reduce mu/union [[:map [:line-height {:optional true} token-name-ref]]
schema:rotation]))
(-> (reduce mu/union [[:map [:line-height {:optional true} token-name-ref]]
schema:rotation])
(mu/update-properties assoc :title "NumberTokenAttrs")))
(def number-keys (schema-keys schema:number))
@@ -215,10 +218,10 @@
number-keys))
(def ^:private schema:tokens
[:map {:title "Applied Tokens"}])
[:map {:title "GenericTokenAttrs"}])
(def schema:applied-tokens
[:merge
[:merge {:title "AppliedTokens"}
schema:tokens
schema:border-radius
schema:sizing