@jxsuite/schema 0.28.2 → 0.28.4

package/defs/cem.schema.ts

@@ -2,29 +2,29 @@ export const cemParameterSchema = {
   description:
     "A CEM-compatible parameter definition for a function. " +
     "Follows the Custom Elements Manifest Parameter shape.",
-  type: "object",
-  required: ["name"],
   properties: {
-    name: { description: "Parameter name.", type: "string" },
-    type: { description: "Parameter type (JSON Schema or CEM { text } format)." },
+    default: { description: "Default value for the parameter." },
     description: { description: "Parameter documentation.", type: "string" },
+    name: { description: "Parameter name.", type: "string" },
     optional: { description: "Whether the parameter is optional.", type: "boolean" },
-    default: { description: "Default value for the parameter." },
+    type: { description: "Parameter type (JSON Schema or CEM { text } format)." },
   },
+  required: ["name"],
+  type: "object",
 } as const;
 
 export const cemEventSchema = {
   description:
-    "A CEM-compatible event definition. " + "Describes a CustomEvent the function dispatches.",
-  type: "object",
-  required: ["name"],
+    "A CEM-compatible event definition. Describes a CustomEvent the function dispatches.",
   properties: {
-    name: { description: "Event name (e.g. 'task-toggled').", type: "string" },
-    type: { description: "Event type (e.g. { text: 'CustomEvent' })." },
-    description: { description: "Event documentation.", type: "string" },
     deprecated: {
       description: "Deprecation notice.",
       oneOf: [{ type: "boolean" }, { type: "string" }],
     },
+    description: { description: "Event documentation.", type: "string" },
+    name: { description: "Event name (e.g. 'task-toggled').", type: "string" },
+    type: { description: "Event type (e.g. { text: 'CustomEvent' })." },
   },
+  required: ["name"],
+  type: "object",
 } as const;

package/defs/children-value.schema.ts

@@ -1,27 +1,27 @@
 export const arrayNamespaceSchema = {
+  additionalProperties: false,
   description: "Dynamic mapped list. Re-renders when the items state entry changes.",
-  type: "object",
-  required: ["$prototype", "items", "map"],
   properties: {
-    $prototype: { type: "string", const: "Array" },
+    $prototype: { const: "Array", type: "string" },
+    filter: { $ref: "#/$defs/RefObject" },
     items: {
       oneOf: [{ $ref: "#/$defs/RefObject" }, { type: "array" }],
     },
     map: { $ref: "#/$defs/ElementDef" },
-    filter: { $ref: "#/$defs/RefObject" },
     sort: { $ref: "#/$defs/RefObject" },
   },
-  additionalProperties: false,
+  required: ["$prototype", "items", "map"],
+  type: "object",
 } as const;
 
 export const childrenValueSchema = {
   description: "Static array of child definitions, or an Array namespace for dynamic lists.",
   oneOf: [
     {
-      type: "array",
       items: {
         oneOf: [{ $ref: "#/$defs/ElementDef" }, { type: "string" }, { type: "number" }],
       },
+      type: "array",
     },
     { $ref: "#/$defs/ArrayNamespace" },
   ],

package/defs/class-def.schema.ts

@@ -1,277 +1,277 @@
 export const classParameterDefSchema = {
   description: "A typed parameter definition for a class.",
-  type: "object",
-  required: ["identifier"],
   properties: {
-    identifier: { type: "string" },
-    type: {},
+    default: {},
+    description: { type: "string" },
+    examples: { type: "array" },
     format: {
       description: 'When "json-schema", this parameter\'s value is itself a JSON Schema.',
       type: "string",
     },
-    description: { type: "string" },
-    default: {},
-    examples: { type: "array" },
+    identifier: { type: "string" },
+    type: {},
   },
+  required: ["identifier"],
+  type: "object",
 } as const;
 
 export const classFieldDefSchema = {
   description: "A class field definition with access control and scope.",
-  type: "object",
   properties: {
-    role: { type: "string", const: "field" },
-    access: { type: "string", enum: ["public", "private", "protected"] },
-    scope: { type: "string", enum: ["instance", "static"] },
-    identifier: { type: "string" },
-    type: {},
     $prototype: {
       description: 'Data source prototype for this field (e.g., "Request").',
       type: "string",
     },
-    initializer: {},
+    access: { enum: ["public", "private", "protected"], type: "string" },
     default: {},
     description: { type: "string" },
     examples: { type: "array" },
+    identifier: { type: "string" },
+    initializer: {},
+    role: { const: "field", type: "string" },
+    scope: { enum: ["instance", "static"], type: "string" },
+    type: {},
   },
+  type: "object",
 } as const;
 
 export const classConstructorDefSchema = {
   description: "Class constructor definition.",
-  type: "object",
   properties: {
-    role: { type: "string", const: "constructor" },
-    $prototype: { type: "string", const: "Function" },
+    $prototype: { const: "Function", type: "string" },
+    body: {
+      oneOf: [{ type: "string" }, { items: { type: "string" }, type: "array" }],
+    },
+    description: { type: "string" },
     parameters: {
-      type: "array",
       items: {
         oneOf: [
           {
-            type: "object",
-            required: ["$ref"],
-            properties: { $ref: { type: "string" } },
             additionalProperties: false,
+            properties: { $ref: { type: "string" } },
+            required: ["$ref"],
+            type: "object",
           },
           { $ref: "#/$defs/ClassParameterDef" },
         ],
       },
+      type: "array",
     },
+    role: { const: "constructor", type: "string" },
     superCall: {
-      type: "object",
       properties: {
-        arguments: { type: "array", items: { type: "string" } },
+        arguments: { items: { type: "string" }, type: "array" },
       },
+      type: "object",
     },
-    body: {
-      oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }],
-    },
-    description: { type: "string" },
   },
+  type: "object",
 } as const;
 
 export const classMethodDefSchema = {
   description:
     "A class method or accessor definition. Capability roles (parse, serialize, discover, load) " +
     "mark static methods that hosts (compiler, server, studio) invoke for format dispatch.",
-  type: "object",
   properties: {
-    role: {
-      type: "string",
-      enum: ["method", "accessor", "parse", "serialize", "discover", "load"],
+    $prototype: { const: "Function", type: "string" },
+    access: { enum: ["public", "private", "protected"], type: "string" },
+    body: {
+      oneOf: [{ type: "string" }, { items: { type: "string" }, type: "array" }],
     },
-    $prototype: { type: "string", const: "Function" },
-    access: { type: "string", enum: ["public", "private", "protected"] },
-    scope: { type: "string", enum: ["instance", "static"] },
-    identifier: { type: "string" },
-    timing: {
-      description:
-        "Execution environments allowed to call this capability directly. " +
-        "Hosts outside the list round-trip through the dev server.",
-      type: "array",
-      items: { type: "string", enum: ["compiler", "server", "client"] },
+    description: { type: "string" },
+    getter: {
+      properties: { body: { type: "string" } },
+      type: "object",
     },
+    identifier: { type: "string" },
     parameters: {
-      type: "array",
       items: {
         oneOf: [
           {
-            type: "object",
-            required: ["$ref"],
-            properties: { $ref: { type: "string" } },
             additionalProperties: false,
+            properties: { $ref: { type: "string" } },
+            required: ["$ref"],
+            type: "object",
           },
           { $ref: "#/$defs/ClassParameterDef" },
         ],
       },
+      type: "array",
     },
     returnType: {},
-    body: {
-      oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }],
-    },
-    getter: {
-      type: "object",
-      properties: { body: { type: "string" } },
+    role: {
+      enum: ["method", "accessor", "parse", "serialize", "discover", "load"],
+      type: "string",
     },
+    scope: { enum: ["instance", "static"], type: "string" },
     setter: {
-      type: "object",
       properties: {
-        parameters: { type: "array" },
         body: { type: "string" },
+        parameters: { type: "array" },
       },
+      type: "object",
+    },
+    timing: {
+      description:
+        "Execution environments allowed to call this capability directly. " +
+        "Hosts outside the list round-trip through the dev server.",
+      items: { enum: ["compiler", "server", "client"], type: "string" },
+      type: "array",
     },
-    description: { type: "string" },
   },
+  type: "object",
 } as const;
 
 export const formatDefSchema = {
   description:
     "Format participation marker. A class carrying this block is auto-discovered from the " +
     "project imports map and used for file-extension dispatch by the compiler, server, and studio.",
-  type: "object",
-  required: ["extensions"],
   properties: {
-    extensions: {
-      description: 'File extensions this format claims, with leading dot (e.g. [".md"]).',
-      type: "array",
-      items: { type: "string", pattern: "^\\." },
-      minItems: 1,
-    },
-    mediaType: {
-      description: "MIME type for the format (icons, labels, HTTP).",
-      type: "string",
-    },
     documentKinds: {
       description:
         '"page"/"component" allow the extension in pages/components discovery; ' +
         '"content" allows it as a content-type source.',
+      items: { enum: ["page", "component", "content"], type: "string" },
       type: "array",
-      items: { type: "string", enum: ["page", "component", "content"] },
     },
     exportTarget: {
       description: "When true, site builds emit a serialized sidecar per page in this format.",
       type: "boolean",
     },
+    extensions: {
+      description: 'File extensions this format claims, with leading dot (e.g. [".md"]).',
+      items: { pattern: "^\\.", type: "string" },
+      minItems: 1,
+      type: "array",
+    },
+    mediaType: {
+      description: "MIME type for the format (icons, labels, HTTP).",
+      type: "string",
+    },
     remote: {
       description: "When true, the load capability accepts http(s) URLs as sources.",
       type: "boolean",
     },
   },
+  required: ["extensions"],
+  type: "object",
 } as const;
 
 export const studioHintsSchema = {
   description:
     "Studio control-surface hints for a format class: editor modes, document-mode rules, " +
     "templates, and the element/nesting constraints that gate structural editing.",
-  type: "object",
   properties: {
-    icon: { type: "string" },
-    modes: {
-      description: "Editor modes the studio offers for documents of this format.",
-      type: "array",
-      items: { type: "string" },
-    },
     documentMode: {
-      type: "object",
       properties: {
-        default: { type: "string", enum: ["content", "component"] },
         componentWhen: {
           description:
             "Treat the document as a component when this top-level/frontmatter key matches the regex.",
-          type: "object",
           properties: {
             frontmatterKey: { type: "string" },
             matches: { type: "string" },
           },
+          type: "object",
         },
+        default: { enum: ["content", "component"], type: "string" },
       },
-    },
-    newFileTemplate: {
-      description: "Initial source text for newly created files of this format.",
-      type: "string",
+      type: "object",
     },
     elements: {
       description: "Element allowlist and nesting constraints for structural editing.",
-      type: "object",
       properties: {
-        block: { type: "array", items: { type: "string" } },
-        inline: { type: "array", items: { type: "string" } },
-        void: { type: "array", items: { type: "string" } },
-        textOnly: { type: "array", items: { type: "string" } },
+        block: { items: { type: "string" }, type: "array" },
+        inline: { items: { type: "string" }, type: "array" },
         nesting: {
-          description:
-            'Per-parent child rules keyed by tag (or "_root"): ' +
-            "{ block, inline, directive } booleans or { only: [tags] }.",
-          type: "object",
           additionalProperties: {
-            type: "object",
             properties: {
               block: { type: "boolean" },
-              inline: { type: "boolean" },
               directive: { type: "boolean" },
-              only: { type: "array", items: { type: "string" } },
+              inline: { type: "boolean" },
+              only: { items: { type: "string" }, type: "array" },
             },
+            type: "object",
           },
+          description:
+            'Per-parent child rules keyed by tag (or "_root"): ' +
+            "{ block, inline, directive } booleans or { only: [tags] }.",
+          type: "object",
         },
+        textOnly: { items: { type: "string" }, type: "array" },
+        void: { items: { type: "string" }, type: "array" },
       },
+      type: "object",
+    },
+    icon: { type: "string" },
+    modes: {
+      description: "Editor modes the studio offers for documents of this format.",
+      items: { type: "string" },
+      type: "array",
+    },
+    newFileTemplate: {
+      description: "Initial source text for newly created files of this format.",
+      type: "string",
     },
   },
+  type: "object",
 } as const;
 
 export const classDefSchema = {
+  additionalProperties: false,
   description:
     'A .class.json schema-defined class. $prototype must be "Class". ' +
     "Defines fields, constructor, methods, and type parameters via $defs. " +
     "Optionally points to a JS module via $implementation for hybrid execution.",
-  type: "object",
-  required: ["$prototype", "title"],
   properties: {
-    $schema: { type: "string" },
-    $id: { type: "string" },
-    $prototype: { type: "string", const: "Class" },
-    title: {
-      description: "PascalCase class name, used as the export name.",
-      type: "string",
-    },
-    description: { type: "string" },
-    format: { $ref: "#/$defs/FormatDef" },
-    $studio: { $ref: "#/$defs/StudioHints" },
-    extends: {
-      description: "Base class — string name or $ref to another .class.json.",
-      oneOf: [
-        { type: "string" },
-        { type: "object", required: ["$ref"], properties: { $ref: { type: "string" } } },
-      ],
-    },
-    $implementation: {
-      description: "Relative path to a JS module containing the actual class implementation.",
-      type: "string",
-    },
     $defs: {
       description: "Class members: parameters, returnTypes, fields, constructor, methods.",
-      type: "object",
       properties: {
-        parameters: {
-          description: "Reusable typed parameter schemas, keyed by name.",
-          type: "object",
-          additionalProperties: { $ref: "#/$defs/ClassParameterDef" },
-        },
-        returnTypes: {
-          description: "Output type schemas, keyed by name.",
-          type: "object",
-          additionalProperties: { type: "object" },
-        },
+        constructor: { $ref: "#/$defs/ClassConstructorDef" },
         fields: {
+          additionalProperties: { $ref: "#/$defs/ClassFieldDef" },
           description: "Class fields with role, access, scope, and type information.",
           type: "object",
-          additionalProperties: { $ref: "#/$defs/ClassFieldDef" },
         },
-        constructor: { $ref: "#/$defs/ClassConstructorDef" },
         methods: {
+          additionalProperties: { $ref: "#/$defs/ClassMethodDef" },
           description: "Class methods and accessors.",
           type: "object",
-          additionalProperties: { $ref: "#/$defs/ClassMethodDef" },
+        },
+        parameters: {
+          additionalProperties: { $ref: "#/$defs/ClassParameterDef" },
+          description: "Reusable typed parameter schemas, keyed by name.",
+          type: "object",
+        },
+        returnTypes: {
+          additionalProperties: { type: "object" },
+          description: "Output type schemas, keyed by name.",
+          type: "object",
         },
       },
+      type: "object",
+    },
+    $id: { type: "string" },
+    $implementation: {
+      description: "Relative path to a JS module containing the actual class implementation.",
+      type: "string",
+    },
+    $prototype: { const: "Class", type: "string" },
+    $schema: { type: "string" },
+    $studio: { $ref: "#/$defs/StudioHints" },
+    description: { type: "string" },
+    extends: {
+      description: "Base class — string name or $ref to another .class.json.",
+      oneOf: [
+        { type: "string" },
+        { properties: { $ref: { type: "string" } }, required: ["$ref"], type: "object" },
+      ],
+    },
+    format: { $ref: "#/$defs/FormatDef" },
+    title: {
+      description: "PascalCase class name, used as the export name.",
+      type: "string",
     },
   },
-  additionalProperties: false,
+  required: ["$prototype", "title"],
+  type: "object",
 } as const;

package/defs/content-type-def.schema.ts

@@ -1,12 +1,20 @@
 export const contentTypeDefSchema = {
   description:
     "Content type definition. Defines the source directory, frontmatter schema, and element dependencies.",
-  type: "object",
   properties: {
-    source: {
-      description: "Path to the content directory relative to the project root.",
-      type: "string",
-      examples: ["./content/blog/", "./content/docs/"],
+    $elements: {
+      description: "Custom elements available in markdown directives for this content type.",
+      items: {
+        oneOf: [
+          {
+            properties: { $ref: { type: "string" } },
+            required: ["$ref"],
+            type: "object",
+          },
+          { type: "string" },
+        ],
+      },
+      type: "array",
     },
     format: {
       description:
@@ -19,19 +27,11 @@ export const contentTypeDefSchema = {
       description: "JSON Schema for validating frontmatter of content type entries.",
       type: "object",
     },
-    $elements: {
-      description: "Custom elements available in markdown directives for this content type.",
-      type: "array",
-      items: {
-        oneOf: [
-          {
-            type: "object",
-            required: ["$ref"],
-            properties: { $ref: { type: "string" } },
-          },
-          { type: "string" },
-        ],
-      },
+    source: {
+      description: "Path to the content directory relative to the project root.",
+      examples: ["./content/blog/", "./content/docs/"],
+      type: "string",
     },
   },
+  type: "object",
 } as const;

package/defs/element-def.schema.ts

@@ -1,6 +1,4 @@
 export const attributesObjectSchema = {
-  description: "HTML attributes and ARIA attributes set via element.setAttribute().",
-  type: "object",
   additionalProperties: {
     oneOf: [
       { type: "string" },
@@ -9,11 +7,11 @@ export const attributesObjectSchema = {
       { $ref: "#/$defs/RefObject" },
     ],
   },
+  description: "HTML attributes and ARIA attributes set via element.setAttribute().",
+  type: "object",
 } as const;
 
 export const propsObjectSchema = {
-  description: "Explicit prop passing at a component boundary.",
-  type: "object",
   additionalProperties: {
     oneOf: [
       { type: "string" },
@@ -24,6 +22,8 @@ export const propsObjectSchema = {
       { $ref: "#/$defs/RefObject" },
     ],
   },
+  description: "Explicit prop passing at a component boundary.",
+  type: "object",
 } as const;
 
 export const elementPropertyValueSchema = {
@@ -37,62 +37,62 @@ export const elementPropertyValueSchema = {
 } as const;
 
 export const switchDefSchema = {
+  additionalProperties: false,
   description: "Reactive $ref that drives which case to render.",
-  type: "object",
-  required: ["$ref"],
   properties: { $ref: { $ref: "#/$defs/InternalRef" } },
-  additionalProperties: false,
+  required: ["$ref"],
+  type: "object",
 } as const;
 
 export const switchNodeSchema = {
-  type: "object",
-  required: ["$switch", "cases"],
   properties: {
-    tagName: { $ref: "#/$defs/TagName" },
     $switch: { $ref: "#/$defs/SwitchDef" },
     cases: {
-      type: "object",
       additionalProperties: {
         oneOf: [{ $ref: "#/$defs/ElementDef" }, { $ref: "#/$defs/ExternalComponentRef" }],
       },
+      type: "object",
     },
+    tagName: { $ref: "#/$defs/TagName" },
   },
+  required: ["$switch", "cases"],
+  type: "object",
 } as const;
 
 export const elementDefSchema = {
+  additionalProperties: { $ref: "#/$defs/ElementPropertyValue" },
   description: "A Jx element definition. Maps directly to a DOM element.",
-  type: "object",
-  required: ["tagName"],
   properties: {
-    tagName: { $ref: "#/$defs/TagName" },
-    id: { type: "string" },
+    "$map/index": { $ref: "#/$defs/RefObject" },
+    "$map/item": { $ref: "#/$defs/RefObject" },
+    $props: { $ref: "#/$defs/PropsObject" },
+    $ref: { $ref: "#/$defs/ExternalRef" },
+    $switch: { $ref: "#/$defs/SwitchDef" },
+    alt: { $ref: "#/$defs/StringOrRef" },
+    attributes: { $ref: "#/$defs/AttributesObject" },
+    checked: { $ref: "#/$defs/BoolOrRef" },
+    children: { $ref: "#/$defs/ChildrenValue" },
     className: { $ref: "#/$defs/StringOrRef" },
-    textContent: { $ref: "#/$defs/StringOrRef" },
+    dir: { enum: ["ltr", "rtl", "auto"], type: "string" },
+    disabled: { $ref: "#/$defs/BoolOrRef" },
+    hidden: { $ref: "#/$defs/BoolOrRef" },
+    href: { $ref: "#/$defs/StringOrRef" },
+    id: { type: "string" },
     innerHTML: { $ref: "#/$defs/StringOrRef" },
     innerText: { $ref: "#/$defs/StringOrRef" },
-    hidden: { $ref: "#/$defs/BoolOrRef" },
-    tabIndex: { $ref: "#/$defs/NumberOrRef" },
-    title: { $ref: "#/$defs/StringOrRef" },
     lang: { $ref: "#/$defs/StringOrRef" },
-    dir: { type: "string", enum: ["ltr", "rtl", "auto"] },
-    value: { $ref: "#/$defs/StringOrRef" },
-    checked: { $ref: "#/$defs/BoolOrRef" },
-    disabled: { $ref: "#/$defs/BoolOrRef" },
-    selected: { $ref: "#/$defs/BoolOrRef" },
-    src: { $ref: "#/$defs/StringOrRef" },
-    href: { $ref: "#/$defs/StringOrRef" },
-    alt: { $ref: "#/$defs/StringOrRef" },
-    type: { $ref: "#/$defs/StringOrRef" },
     name: { $ref: "#/$defs/StringOrRef" },
     placeholder: { $ref: "#/$defs/StringOrRef" },
-    children: { $ref: "#/$defs/ChildrenValue" },
+    selected: { $ref: "#/$defs/BoolOrRef" },
+    src: { $ref: "#/$defs/StringOrRef" },
     style: { $ref: "#/$defs/StyleObject" },
-    attributes: { $ref: "#/$defs/AttributesObject" },
-    $switch: { $ref: "#/$defs/SwitchDef" },
-    $ref: { $ref: "#/$defs/ExternalRef" },
-    $props: { $ref: "#/$defs/PropsObject" },
-    "$map/item": { $ref: "#/$defs/RefObject" },
-    "$map/index": { $ref: "#/$defs/RefObject" },
+    tabIndex: { $ref: "#/$defs/NumberOrRef" },
+    tagName: { $ref: "#/$defs/TagName" },
+    textContent: { $ref: "#/$defs/StringOrRef" },
+    title: { $ref: "#/$defs/StringOrRef" },
+    type: { $ref: "#/$defs/StringOrRef" },
+    value: { $ref: "#/$defs/StringOrRef" },
   },
-  additionalProperties: { $ref: "#/$defs/ElementPropertyValue" },
+  required: ["tagName"],
+  type: "object",
 } as const;