@jxsuite/schema 0.35.0 → 1.1.0

package/project-schema.json

@@ -1,49 +1,5 @@
 {
   "$defs": {
-    "ContentTypeDef": {
-      "description": "Content type definition. Defines the source directory, frontmatter schema, and element dependencies.",
-      "properties": {
-        "$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": "Import name of a format class declared in the project imports map (e.g. \"Markdown\", \"Csv\"). When omitted, the format is derived from the source file extension via the format registry. \"json\" is the only built-in.",
-          "type": "string"
-        },
-        "schema": {
-          "description": "JSON Schema for validating frontmatter of content type entries.",
-          "type": "object"
-        },
-        "source": {
-          "description": "Path to the content directory relative to the project root.",
-          "examples": [
-            "./content/blog/",
-            "./content/docs/"
-          ],
-          "type": "string"
-        }
-      },
-      "type": "object"
-    },
     "ImageConfig": {
       "description": "Image optimization configuration for the project.",
       "properties": {
@@ -106,8 +62,7 @@
   },
   "$id": "https://jxsuite.com/schema/project/v1",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "additionalProperties": false,
-  "description": "Schema for Jx project.json files. A project.json file is the root anchor file for a Jx project, declaring site metadata, default settings, global styles, content types, and build configuration.",
+  "description": "Schema for Jx project.json files. A project.json file is the root anchor file for a Jx project, declaring site metadata, default settings, global styles, extensions, and build configuration. Open by design: extension-contributed sections are opaque top-level keys; the generated per-project entry document (project.schema.json) closes the composition.",
   "properties": {
     "$defs": {
       "description": "Global type definitions available to all pages.",
@@ -186,6 +141,10 @@
       ],
       "type": "object"
     },
+    "$schema": {
+      "description": "Relative path to the generated per-project schema (conventionally ./project.schema.json, written by `jx schema`).",
+      "type": "string"
+    },
     "build": {
       "description": "Build configuration.",
       "properties": {
@@ -234,7 +193,7 @@
         },
         "format": {
           "default": "directory",
-          "description": "Output format.",
+          "description": "Reserved; currently unused. Accepted for forward compatibility with single-file output (desktop single-file mode) — the build emits per-route directories regardless.",
           "enum": [
             "directory",
             "single"
@@ -264,13 +223,6 @@
       },
       "type": "object"
     },
-    "contentTypes": {
-      "additionalProperties": {
-        "$ref": "#/$defs/ContentTypeDef"
-      },
-      "description": "Content type definitions. Each key is a content type name; the value defines the source directory, frontmatter schema, and element dependencies.",
-      "type": "object"
-    },
     "copy": {
       "additionalProperties": {
         "type": "string"
@@ -309,6 +261,18 @@
       },
       "type": "object"
     },
+    "extensions": {
+      "description": "Extension packages: bare package names (resolved project-first through the package exports map) or relative paths. Each must export jx-extension.json.",
+      "examples": [
+        [
+          "@jxsuite/parser"
+        ]
+      ],
+      "items": {
+        "type": "string"
+      },
+      "type": "array"
+    },
     "i18n": {
       "description": "Internationalization configuration.",
       "properties": {

package/schema.json

@@ -224,13 +224,35 @@
           "type": "string"
         },
         "body": {
-          "description": "Inline function body string. First implicit parameter is state.",
+          "description": "Inline function body: an opaque JS source string (first implicit parameter is state), or a structured statement array (spec §20) — explicit structured function declaration, analyzable by tooling and editable visually. The escalation ladder within the shape is structured statements → JS string.",
           "examples": [
             "state.count++",
             "state.items.push({ id: Date.now(), text: \"\", done: false })",
-            "return state.score >= 90 ? \"gold\" : \"silver\""
+            "return state.score >= 90 ? \"gold\" : \"silver\"",
+            [
+              {
+                "operator": "push",
+                "target": {
+                  "$ref": "#/state/cart"
+                },
+                "value": 1
+              },
+              {
+                "dispatchEvent": "cart-changed",
+                "detail": {
+                  "$ref": "#/state/cart"
+                }
+              }
+            ]
           ],
-          "type": "string"
+          "oneOf": [
+            {
+              "type": "string"
+            },
+            {
+              "$ref": "#/$defs/StatementList"
+            }
+          ]
         },
         "description": {
           "type": "string"
@@ -951,10 +973,10 @@
     },
     "ExpressionPointer": {
       "additionalProperties": false,
-      "description": "A JSON Pointer $ref operand within an expression node.",
+      "description": "A JSON Pointer $ref operand within an expression node. $args/<name> resolves a named formula's parameter (callable entries only).",
       "properties": {
         "$ref": {
-          "pattern": "^(\\$map/|\\$reduce/|event#/|#/|parent#/|window#/|document#/)",
+          "pattern": "^(\\$map/|\\$reduce/|\\$args/|event#/|#/|parent#/|window#/|document#/)",
           "type": "string"
         }
       },
@@ -985,9 +1007,27 @@
             "$ref": "#/$defs/ExpressionOperand"
           },
           "type": "array"
+        },
+        {
+          "description": "Plain-object literal (e.g. an Intl options bag). Objects carrying $ref or operator keys are pointers/nodes, never literals.",
+          "not": {
+            "anyOf": [
+              {
+                "required": [
+                  "$ref"
+                ]
+              },
+              {
+                "required": [
+                  "operator"
+                ]
+              }
+            ]
+          },
+          "type": "object"
         }
       ],
-      "description": "A non-reactive operand: scalar or array of operands."
+      "description": "A non-reactive operand: scalar, plain-object literal, or array of operands."
     },
     "ExpressionOperand": {
       "anyOf": [
@@ -1023,7 +1063,53 @@
         ">",
         ">=",
         "&&",
-        "||"
+        "||",
+        "??"
+      ]
+    },
+    "ConditionalOperator": {
+      "const": "?:"
+    },
+    "SwitchOperator": {
+      "const": "switch"
+    },
+    "CallOperator": {
+      "const": "call"
+    },
+    "PureMethod": {
+      "description": "A genuine pure String.prototype / Array.prototype / Number.prototype method (spec §19.4d). The ES2023 change-by-copy family (toSorted, toReversed, toSpliced, with) stands in where mutation would otherwise occur. Receiver in target; value carries the argument (bare scalar) or argument list (array).",
+      "enum": [
+        "includes",
+        "indexOf",
+        "lastIndexOf",
+        "join",
+        "slice",
+        "concat",
+        "at",
+        "flat",
+        "toSorted",
+        "toReversed",
+        "toSpliced",
+        "with",
+        "toUpperCase",
+        "toLowerCase",
+        "trim",
+        "trimStart",
+        "trimEnd",
+        "split",
+        "startsWith",
+        "endsWith",
+        "padStart",
+        "padEnd",
+        "replaceAll",
+        "repeat",
+        "charAt",
+        "normalize",
+        "toLocaleUpperCase",
+        "toLocaleLowerCase",
+        "toFixed",
+        "toPrecision",
+        "toLocaleString"
       ]
     },
     "AssignmentOperator": {
@@ -1206,7 +1292,14 @@
               "$ref": "#/$defs/ReduceMethod"
             },
             "target": {
-              "$ref": "#/$defs/ExpressionPointer"
+              "anyOf": [
+                {
+                  "$ref": "#/$defs/ExpressionPointer"
+                },
+                {
+                  "$ref": "#/$defs/ExpressionNode"
+                }
+              ]
             },
             "value": {
               "$ref": "#/$defs/ExpressionNode"
@@ -1217,7 +1310,7 @@
             "value",
             "initial"
           ],
-          "title": "reduce — pure fold; per-item expression in value, seed in initial"
+          "title": "reduce — pure fold over a pointer or derived array; seed in initial"
         },
         {
           "not": {
@@ -1230,7 +1323,14 @@
               "$ref": "#/$defs/MapFilterMethod"
             },
             "target": {
-              "$ref": "#/$defs/ExpressionPointer"
+              "anyOf": [
+                {
+                  "$ref": "#/$defs/ExpressionPointer"
+                },
+                {
+                  "$ref": "#/$defs/ExpressionNode"
+                }
+              ]
             },
             "value": {
               "$ref": "#/$defs/ExpressionNode"
@@ -1240,10 +1340,114 @@
             "operator",
             "value"
           ],
-          "title": "map / filter — pure; per-item expression in value, no initial"
+          "title": "map / filter — pure over a pointer or derived array; per-item expression in value"
+        },
+        {
+          "description": "The ECMAScript conditional (ternary) operator, pure: target is the test, value the consequent, initial the alternate (the reduce precedent for repurposing initial). Chain else-if by nesting another ?: node in initial.",
+          "properties": {
+            "operator": {
+              "$ref": "#/$defs/ConditionalOperator"
+            }
+          },
+          "required": [
+            "operator",
+            "value",
+            "initial"
+          ],
+          "title": "?: — pure conditional; test in target, consequent in value, alternate in initial"
+        },
+        {
+          "description": "Value-keyed multiway selection, pure: target is the discriminant (matched against case keys by its string form, like element-level $switch), cases maps matched values to result operands, default is the operand when no case matches (result is undefined without it). Condition-chain branching composes from nested ?: nodes instead.",
+          "not": {
+            "anyOf": [
+              {
+                "required": [
+                  "value"
+                ]
+              },
+              {
+                "required": [
+                  "initial"
+                ]
+              }
+            ]
+          },
+          "properties": {
+            "cases": {
+              "additionalProperties": {
+                "$ref": "#/$defs/ExpressionOperand"
+              },
+              "type": "object"
+            },
+            "default": {
+              "$ref": "#/$defs/ExpressionOperand"
+            },
+            "operator": {
+              "$ref": "#/$defs/SwitchOperator"
+            }
+          },
+          "required": [
+            "operator",
+            "cases"
+          ],
+          "title": "switch — pure value-keyed selection; discriminant in target, results in cases/default"
+        },
+        {
+          "description": "A pure standard-library method call: target is the receiver (any operand — never mutated; change-by-copy names replace the mutating originals), value the optional argument (bare scalar) or argument list (array). A missing receiver or method yields undefined, matching null-safe path reads.",
+          "not": {
+            "required": [
+              "initial"
+            ]
+          },
+          "properties": {
+            "operator": {
+              "$ref": "#/$defs/PureMethod"
+            }
+          },
+          "required": [
+            "operator"
+          ],
+          "title": "Pure method — genuine prototype methods; receiver in target, args in value"
+        },
+        {
+          "description": "Invoke a callable, pure in formula position: target is the callee pointer — a named formula entry (#/state/…) or a blessed pure global via window#/ (Math.*, JSON.*, Object.keys/values/entries, and the Intl helpers Intl/formatNumber, Intl/formatDate, Intl/formatRelativeTime) — and value is the positional argument list (the splice args-in-value precedent). Argument order follows the callee's declared parameters.",
+          "not": {
+            "required": [
+              "initial"
+            ]
+          },
+          "properties": {
+            "operator": {
+              "$ref": "#/$defs/CallOperator"
+            },
+            "target": {
+              "$ref": "#/$defs/ExpressionPointer"
+            },
+            "value": {
+              "items": {
+                "$ref": "#/$defs/ExpressionOperand"
+              },
+              "type": "array"
+            }
+          },
+          "required": [
+            "operator"
+          ],
+          "title": "call — invoke a named formula or blessed global; callee in target, args in value"
         }
       ],
       "properties": {
+        "cases": {
+          "additionalProperties": {
+            "$ref": "#/$defs/ExpressionOperand"
+          },
+          "description": "switch only: matched discriminant value (string form) → result operand.",
+          "type": "object"
+        },
+        "default": {
+          "$ref": "#/$defs/ExpressionOperand",
+          "description": "switch only: result operand when no case key matches."
+        },
         "initial": {
           "$ref": "#/$defs/ExpressionOperand"
         },
@@ -1265,7 +1469,7 @@
     },
     "ExpressionEntry": {
       "additionalProperties": false,
-      "description": "A declarative expression entry (Shape 5). Used as a state entry or inline event handler.",
+      "description": "A declarative expression entry (Shape 5). Used as a state entry or inline event handler. With parameters it is a named formula: a pure, reusable computation invoked via the call operator, its parameters resolved through $args/<name> refs in the body.",
       "properties": {
         "$description": {
           "type": "string"
@@ -1275,6 +1479,20 @@
         },
         "$title": {
           "type": "string"
+        },
+        "parameters": {
+          "description": "Named-formula parameters (CEM convention, as on Function entries): bare names or CEM parameter objects. Present ⇒ the entry is callable, not a computed value.",
+          "items": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "$ref": "#/$defs/CemParameter"
+              }
+            ]
+          },
+          "type": "array"
         }
       },
       "required": [
@@ -1282,6 +1500,99 @@
       ],
       "type": "object"
     },
+    "Statement": {
+      "description": "One statement of a structured function body. Either a bare expression node in statement position (a mutation like =/push, or a call — its result discarded unless captured by an assignment), an if/then/else branch (JSON Schema conditional keywords; if holds a pure expression, then/else hold statement lists), a $switch multiway branch (discriminant matched by string form against cases keys, like element-level $switch), or a dispatchEvent statement (WHATWG DOM: dispatches a CustomEvent from the handler's current target, with CustomEventInit members detail/bubbles/composed).",
+      "oneOf": [
+        {
+          "$ref": "#/$defs/ExpressionNode"
+        },
+        {
+          "additionalProperties": false,
+          "properties": {
+            "else": {
+              "items": {
+                "$ref": "#/$defs/Statement"
+              },
+              "type": "array"
+            },
+            "if": {
+              "$ref": "#/$defs/ExpressionOperand"
+            },
+            "then": {
+              "items": {
+                "$ref": "#/$defs/Statement"
+              },
+              "type": "array"
+            }
+          },
+          "required": [
+            "if",
+            "then"
+          ],
+          "title": "if / then / else — conditional branch (JSON Schema keyword triple)",
+          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "properties": {
+            "$switch": {
+              "$ref": "#/$defs/ExpressionOperand"
+            },
+            "cases": {
+              "additionalProperties": {
+                "items": {
+                  "$ref": "#/$defs/Statement"
+                },
+                "type": "array"
+              },
+              "type": "object"
+            },
+            "default": {
+              "items": {
+                "$ref": "#/$defs/Statement"
+              },
+              "type": "array"
+            }
+          },
+          "required": [
+            "$switch",
+            "cases"
+          ],
+          "title": "$switch / cases — multiway branch (element-level convention, ECMA switch semantics)",
+          "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "properties": {
+            "bubbles": {
+              "type": "boolean"
+            },
+            "composed": {
+              "type": "boolean"
+            },
+            "detail": {
+              "$ref": "#/$defs/ExpressionOperand"
+            },
+            "dispatchEvent": {
+              "description": "The CustomEvent type to dispatch (WHATWG DOM dispatchEvent).",
+              "type": "string"
+            }
+          },
+          "required": [
+            "dispatchEvent"
+          ],
+          "title": "dispatchEvent — emit a CustomEvent (WHATWG naming, CustomEventInit members)",
+          "type": "object"
+        }
+      ]
+    },
+    "StatementList": {
+      "description": "A structured function body: statements executed sequentially (one yielding a promise is awaited before the next, per ECMA async/await semantics).",
+      "items": {
+        "$ref": "#/$defs/Statement"
+      },
+      "type": "array"
+    },
     "ElementDef": {
       "additionalProperties": {
         "$ref": "#/$defs/ElementPropertyValue"
@@ -21651,50 +21962,6 @@
         }
       },
       "type": "object"
-    },
-    "ContentTypeDef": {
-      "description": "Content type definition. Defines the source directory, frontmatter schema, and element dependencies.",
-      "properties": {
-        "$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": "Import name of a format class declared in the project imports map (e.g. \"Markdown\", \"Csv\"). When omitted, the format is derived from the source file extension via the format registry. \"json\" is the only built-in.",
-          "type": "string"
-        },
-        "schema": {
-          "description": "JSON Schema for validating frontmatter of content type entries.",
-          "type": "object"
-        },
-        "source": {
-          "description": "Path to the content directory relative to the project root.",
-          "examples": [
-            "./content/blog/",
-            "./content/docs/"
-          ],
-          "type": "string"
-        }
-      },
-      "type": "object"
     }
   },
   "$id": "https://jxsuite.com/schema/v1",

package/schemas/document.paths.schema.json

@@ -0,0 +1,6 @@
+{
+  "$id": "https://jxsuite.com/schema/document/paths/v2",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "description": "Default $paths-value union for documents. Per-project entry documents override this resource with the union of extension-contributed paths shapes.",
+  "title": "Jx Document Paths Union"
+}