@jxsuite/schema 0.28.2 → 0.28.4

package/defs/expression-node.schema.ts

@@ -1,35 +1,35 @@
 export const expressionPointerSchema = {
+  additionalProperties: false,
   description: "A JSON Pointer $ref operand within an expression node.",
-  type: "object",
   properties: {
     $ref: {
-      type: "string",
       pattern: "^(\\$map/|\\$reduce/|event#/|#/|parent#/|window#/|document#/)",
+      type: "string",
     },
   },
   required: ["$ref"],
-  additionalProperties: false,
+  type: "object",
 } as const;
 
 export const expressionLiteralSchema = {
-  description: "A non-reactive operand: scalar or array of operands.",
   anyOf: [
-    { type: "string", not: { pattern: "\\$\\{" } },
+    { not: { pattern: "\\$\\{" }, type: "string" },
     { type: "number" },
     { type: "boolean" },
     { type: "null" },
-    { type: "array", items: { $ref: "#/$defs/ExpressionOperand" } },
+    { items: { $ref: "#/$defs/ExpressionOperand" }, type: "array" },
   ],
+  description: "A non-reactive operand: scalar or array of operands.",
 } as const;
 
 export const expressionOperandSchema = {
-  description:
-    "Anything that may appear in target or value: a pointer, a literal, or a nested expression node.",
   anyOf: [
     { $ref: "#/$defs/ExpressionPointer" },
     { $ref: "#/$defs/ExpressionNode" },
     { $ref: "#/$defs/ExpressionLiteral" },
   ],
+  description:
+    "Anything that may appear in target or value: a pointer, a literal, or a nested expression node.",
 } as const;
 
 export const unaryOperatorSchema = { enum: ["!", "-"] } as const;
@@ -44,97 +44,97 @@ export const reduceMethodSchema = { const: "reduce" } as const;
 export const mapFilterMethodSchema = { enum: ["map", "filter"] } as const;
 
 export const expressionNodeSchema = {
-  description: "The core expression node. operator + target, with value gated by arity.",
-  type: "object",
-  required: ["operator", "target"],
   additionalProperties: false,
-  properties: {
-    operator: { type: "string" },
-    target: { $ref: "#/$defs/ExpressionOperand" },
-    value: { $ref: "#/$defs/ExpressionOperand" },
-    initial: { $ref: "#/$defs/ExpressionOperand" },
-  },
+  description: "The core expression node. operator + target, with value gated by arity.",
   oneOf: [
     {
-      title: "Unary — target only, no value",
+      not: { anyOf: [{ required: ["value"] }, { required: ["initial"] }] },
       properties: { operator: { $ref: "#/$defs/UnaryOperator" } },
       required: ["operator"],
-      not: { anyOf: [{ required: ["value"] }, { required: ["initial"] }] },
+      title: "Unary — target only, no value",
     },
     {
-      title: "Binary — left in target, right in value",
+      not: { required: ["initial"] },
       properties: { operator: { $ref: "#/$defs/BinaryOperator" } },
       required: ["operator", "value"],
-      not: { required: ["initial"] },
+      title: "Binary — left in target, right in value",
     },
     {
-      title: "Assignment — writable target, value required",
+      not: { required: ["initial"] },
       properties: {
         operator: { $ref: "#/$defs/AssignmentOperator" },
         target: { $ref: "#/$defs/ExpressionPointer" },
       },
       required: ["operator", "value"],
-      not: { required: ["initial"] },
+      title: "Assignment — writable target, value required",
     },
     {
-      title: "pop / shift — array receiver, no value",
+      not: { anyOf: [{ required: ["value"] }, { required: ["initial"] }] },
       properties: {
         operator: { $ref: "#/$defs/NoArgMethod" },
         target: { $ref: "#/$defs/ExpressionPointer" },
       },
       required: ["operator"],
-      not: { anyOf: [{ required: ["value"] }, { required: ["initial"] }] },
+      title: "pop / shift — array receiver, no value",
     },
     {
-      title: "push / unshift — array receiver, single value argument",
+      not: { required: ["initial"] },
       properties: {
         operator: { $ref: "#/$defs/OneArgMethod" },
         target: { $ref: "#/$defs/ExpressionPointer" },
       },
       required: ["operator", "value"],
-      not: { required: ["initial"] },
+      title: "push / unshift — array receiver, single value argument",
     },
     {
-      title: "splice — array receiver, [start, deleteCount, ...items]",
+      not: { required: ["initial"] },
       properties: {
         operator: { $ref: "#/$defs/SpliceMethod" },
         target: { $ref: "#/$defs/ExpressionPointer" },
-        value: { type: "array", items: { $ref: "#/$defs/ExpressionOperand" }, minItems: 1 },
+        value: { items: { $ref: "#/$defs/ExpressionOperand" }, minItems: 1, type: "array" },
       },
       required: ["operator", "value"],
-      not: { required: ["initial"] },
+      title: "splice — array receiver, [start, deleteCount, ...items]",
     },
     {
-      title: "reduce — pure fold; per-item expression in value, seed in initial",
       properties: {
         operator: { $ref: "#/$defs/ReduceMethod" },
         target: { $ref: "#/$defs/ExpressionPointer" },
         value: { $ref: "#/$defs/ExpressionNode" },
       },
       required: ["operator", "value", "initial"],
+      title: "reduce — pure fold; per-item expression in value, seed in initial",
     },
     {
-      title: "map / filter — pure; per-item expression in value, no initial",
+      not: { required: ["initial"] },
       properties: {
         operator: { $ref: "#/$defs/MapFilterMethod" },
         target: { $ref: "#/$defs/ExpressionPointer" },
         value: { $ref: "#/$defs/ExpressionNode" },
       },
       required: ["operator", "value"],
-      not: { required: ["initial"] },
+      title: "map / filter — pure; per-item expression in value, no initial",
     },
   ],
+  properties: {
+    initial: { $ref: "#/$defs/ExpressionOperand" },
+    operator: { type: "string" },
+    target: { $ref: "#/$defs/ExpressionOperand" },
+    value: { $ref: "#/$defs/ExpressionOperand" },
+  },
+  required: ["operator", "target"],
+  type: "object",
 } as const;
 
 export const expressionEntrySchema = {
+  additionalProperties: false,
   description:
     "A declarative expression entry (Shape 5). Used as a state entry or inline event handler.",
-  type: "object",
-  required: ["$expression"],
   properties: {
+    $description: { type: "string" },
     $expression: { $ref: "#/$defs/ExpressionNode" },
     $title: { type: "string" },
-    $description: { type: "string" },
   },
-  additionalProperties: false,
+  required: ["$expression"],
+  type: "object",
 } as const;

package/defs/external-class-def.schema.ts

@@ -19,13 +19,13 @@ export const externalClassDefSchema = {
     'An external class / data source. $prototype is a constructor name (not "Function"). ' +
     "When $prototype is not in the built-in registry, $src is required. " +
     "All state entries are reactive by default.",
-  type: "object",
-  required: ["$prototype"],
   properties: {
+    $export: {
+      description: "Named export in $src module. Defaults to the $prototype value.",
+      type: "string",
+    },
     $prototype: {
       description: "Constructor name — built-in Web API class or external class name.",
-      type: "string",
-      not: { const: "Function" },
       examples: [
         "Request",
         "URLSearchParams",
@@ -42,66 +42,66 @@ export const externalClassDefSchema = {
         "MarkdownCollection",
         "MyParser",
       ],
+      not: { const: "Function" },
+      type: "string",
     },
     $src: {
       description: "External module specifier. Required when $prototype is not a built-in.",
-      type: "string",
       examples: ["@jxsuite/md", "./lib/my-parser.js", "npm:@myorg/data"],
-    },
-    $export: {
-      description: "Named export in $src module. Defaults to the $prototype value.",
       type: "string",
     },
-    timing: { type: "string", enum: ["compiler", "server", "client"] },
-    manual: { type: "boolean" },
-    debounce: { type: "integer", minimum: 0 },
-    url: { $ref: "#/$defs/StringOrRef" },
-    method: {
-      type: "string",
-      enum: ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"],
-    },
-    headers: { type: "object", additionalProperties: { type: "string" } },
+    autoIncrement: { type: "boolean" },
     body: {},
-    responseType: {
-      type: "string",
-      enum: ["json", "text", "blob", "arraybuffer", "document", ""],
-    },
-    key: { type: "string" },
-    name: { type: "string" },
-    maxAge: { type: "integer" },
-    expires: { type: "string" },
-    path: { type: "string" },
-    domain: { type: "string" },
-    secure: { type: "boolean" },
-    sameSite: { type: "string", enum: ["strict", "lax", "none"] },
     database: { type: "string" },
-    store: { type: "string" },
-    version: { type: "integer", minimum: 1 },
-    keyPath: { type: "string" },
-    autoIncrement: { type: "boolean" },
+    debounce: { minimum: 0, type: "integer" },
+    default: {},
+    description: { type: "string" },
+    domain: { type: "string" },
+    expires: { type: "string" },
+    filter: { $ref: "#/$defs/RefObject" },
+    headers: { additionalProperties: { type: "string" }, type: "object" },
     indexes: {
-      type: "array",
       items: {
-        type: "object",
-        required: ["name", "keyPath"],
         properties: {
-          name: { type: "string" },
           keyPath: {
-            oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }],
+            oneOf: [{ type: "string" }, { items: { type: "string" }, type: "array" }],
           },
+          name: { type: "string" },
           unique: { type: "boolean" },
         },
+        required: ["name", "keyPath"],
+        type: "object",
       },
+      type: "array",
     },
-    default: {},
-    description: { type: "string" },
     items: {},
+    key: { type: "string" },
+    keyPath: { type: "string" },
+    manual: { type: "boolean" },
     map: { $ref: "#/$defs/ElementDef" },
-    filter: { $ref: "#/$defs/RefObject" },
+    maxAge: { type: "integer" },
+    method: {
+      enum: ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"],
+      type: "string",
+    },
+    name: { type: "string" },
+    path: { type: "string" },
+    responseType: {
+      enum: ["json", "text", "blob", "arraybuffer", "document", ""],
+      type: "string",
+    },
+    sameSite: { enum: ["strict", "lax", "none"], type: "string" },
+    secure: { type: "boolean" },
     sort: { $ref: "#/$defs/RefObject" },
     src: {
       description: "Configuration property passed to external class constructor.",
       type: "string",
     },
+    store: { type: "string" },
+    timing: { enum: ["compiler", "server", "client"], type: "string" },
+    url: { $ref: "#/$defs/StringOrRef" },
+    version: { minimum: 1, type: "integer" },
   },
+  required: ["$prototype"],
+  type: "object",
 } as const;

package/defs/function-def.schema.ts

@@ -1,59 +1,59 @@
 export const functionDefSchema = {
+  additionalProperties: false,
   description:
     'A function declaration. $prototype must be "Function". ' +
     "body (inline) and $src (external) are mutually exclusive. " +
     "First parameter is always state (the reactive scope).",
-  type: "object",
-  required: ["$prototype"],
   properties: {
-    $prototype: { type: "string", const: "Function" },
+    $export: {
+      description: "Named export in $src module. Defaults to the state key name.",
+      type: "string",
+    },
+    $prototype: { const: "Function", type: "string" },
+    $src: {
+      description: "External module specifier. Mutually exclusive with body.",
+      examples: ["./counter.js", "npm:@myorg/validators"],
+      type: "string",
+    },
     body: {
       description: "Inline function body string. First implicit parameter is state.",
-      type: "string",
       examples: [
         "state.count++",
         'state.items.push({ id: Date.now(), text: "", done: false })',
         'return state.score >= 90 ? "gold" : "silver"',
       ],
+      type: "string",
+    },
+    description: { type: "string" },
+    emits: {
+      description:
+        "Array of CEM-compatible Event objects this function dispatches. " +
+        "Used for CEM extraction and studio event discovery.",
+      items: { $ref: "#/$defs/CemEvent" },
+      type: "array",
+    },
+    name: {
+      description: "Explicit function name. Defaults to the state key name.",
+      type: "string",
     },
     parameters: {
       description:
         "Function parameters (after the implicit state parameter). " +
         "Accepts CEM-compatible parameter objects or bare string names for backward compatibility.",
-      type: "array",
-      items: {
-        oneOf: [{ type: "string" }, { $ref: "#/$defs/CemParameter" }],
-      },
       examples: [
         ["event"],
         [{ name: "event", type: { text: "Event" } }],
-        [{ name: "id", type: { text: "number" }, description: "Item identifier" }],
+        [{ description: "Item identifier", name: "id", type: { text: "number" } }],
       ],
-    },
-    name: {
-      description: "Explicit function name. Defaults to the state key name.",
-      type: "string",
-    },
-    $src: {
-      description: "External module specifier. Mutually exclusive with body.",
-      type: "string",
-      examples: ["./counter.js", "npm:@myorg/validators"],
-    },
-    $export: {
-      description: "Named export in $src module. Defaults to the state key name.",
-      type: "string",
+      items: {
+        oneOf: [{ type: "string" }, { $ref: "#/$defs/CemParameter" }],
+      },
+      type: "array",
     },
     type: {
       description: "Return type for tooling (JSON Schema or CEM { text } format).",
     },
-    emits: {
-      description:
-        "Array of CEM-compatible Event objects this function dispatches. " +
-        "Used for CEM extraction and studio event discovery.",
-      type: "array",
-      items: { $ref: "#/$defs/CemEvent" },
-    },
-    description: { type: "string" },
   },
-  additionalProperties: false,
+  required: ["$prototype"],
+  type: "object",
 } as const;

package/defs/head-entry.schema.ts

@@ -1,17 +1,17 @@
 export const headEntrySchema = {
+  additionalProperties: true,
   description: "A page-level <head> entry. Defines meta tags, link tags, script tags, etc.",
-  type: "object",
-  required: ["tagName"],
   properties: {
-    tagName: { type: "string" },
     attributes: {
-      type: "object",
       additionalProperties: {
         oneOf: [{ type: "string" }, { type: "boolean" }],
       },
+      type: "object",
     },
+    children: { items: { $ref: "#/$defs/HeadEntry" }, type: "array" },
+    tagName: { type: "string" },
     textContent: { type: "string" },
-    children: { type: "array", items: { $ref: "#/$defs/HeadEntry" } },
   },
-  additionalProperties: true,
+  required: ["tagName"],
+  type: "object",
 } as const;

package/defs/image-config.schema.ts

@@ -1,36 +1,36 @@
 export const imageConfigSchema = {
   description: "Image optimization configuration for the project.",
-  type: "object",
   properties: {
+    formats: { items: { type: "string" }, type: "array" },
+    lazyLoad: { type: "boolean" },
     optimize: { type: "boolean" },
-    widths: { type: "array", items: { type: "number" } },
-    formats: { type: "array", items: { type: "string" } },
     quality: {
-      type: "object",
       properties: {
-        webp: { type: "number" },
         avif: { type: "number" },
         jpeg: { type: "number" },
         png: { type: "number" },
+        webp: { type: "number" },
       },
-    },
-    sizes: { type: "string" },
-    lazyLoad: { type: "boolean" },
-    service: {
-      description:
-        'How images are optimized: "build" runs Sharp at build time; "cloudflare" emits ' +
-        "/cdn-cgi/image transform URLs served by Cloudflare Image Transformations (requires " +
-        "the feature to be enabled on the serving zone).",
-      type: "string",
-      enum: ["build", "cloudflare"],
+      type: "object",
     },
     remoteDomains: {
       description:
         "Hostnames whose remote (https) images are optimized through /cdn-cgi/image transform " +
         'URLs (cloudflare service only), e.g. ["drive.usercontent.google.com"]. Remote sources ' +
         "from other hosts are left untouched.",
-      type: "array",
       items: { type: "string" },
+      type: "array",
+    },
+    service: {
+      description:
+        'How images are optimized: "build" runs Sharp at build time; "cloudflare" emits ' +
+        "/cdn-cgi/image transform URLs served by Cloudflare Image Transformations (requires " +
+        "the feature to be enabled on the serving zone).",
+      enum: ["build", "cloudflare"],
+      type: "string",
     },
+    sizes: { type: "string" },
+    widths: { items: { type: "number" }, type: "array" },
   },
+  type: "object",
 } as const;

package/defs/json-schema-type.schema.ts

@@ -1,4 +1,4 @@
 export const jsonSchemaTypeSchema = {
-  type: "string",
   enum: ["string", "number", "integer", "boolean", "array", "object", "null"],
+  type: "string",
 } as const;