@jxsuite/schema 0.23.1 → 0.24.0

package/defs/image-config.schema.ts

@@ -0,0 +1,20 @@
+export const imageConfigSchema = {
+  description: "Image optimization configuration for the project.",
+  type: "object",
+  properties: {
+    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" },
+      },
+    },
+    sizes: { type: "string" },
+    lazyLoad: { type: "boolean" },
+  },
+} as const;

package/defs/index.ts

@@ -0,0 +1,76 @@
+// Leaf schemas
+export { tagNameSchema } from "./tag-name.schema";
+export { stringOrRefSchema, boolOrRefSchema, numberOrRefSchema } from "./string-or-ref.schema";
+export { headEntrySchema } from "./head-entry.schema";
+export { cemParameterSchema, cemEventSchema } from "./cem.schema";
+export { imageConfigSchema } from "./image-config.schema";
+export { jsonSchemaTypeSchema } from "./json-schema-type.schema";
+
+// Ref schemas
+export {
+  internalRefSchema,
+  stateRefSchema,
+  externalRefSchema,
+  globalRefSchema,
+  parentRefSchema,
+  mapRefSchema,
+  anyRefSchema,
+  refObjectSchema,
+  externalComponentRefSchema,
+} from "./ref-object.schema";
+
+// Style & element
+export { styleObjectSchema } from "./style-object.schema";
+export { arrayNamespaceSchema, childrenValueSchema } from "./children-value.schema";
+export {
+  attributesObjectSchema,
+  propsObjectSchema,
+  elementPropertyValueSchema,
+  switchDefSchema,
+  switchNodeSchema,
+  elementDefSchema,
+} from "./element-def.schema";
+
+// State shapes
+export { typedStateDefSchema } from "./typed-state-def.schema";
+export { functionDefSchema } from "./function-def.schema";
+export { externalClassDefSchema, BUILT_IN_PROTOTYPES } from "./external-class-def.schema";
+export { pureTypeDefSchema } from "./pure-type-def.schema";
+
+// Expression system
+export {
+  expressionPointerSchema,
+  expressionLiteralSchema,
+  expressionOperandSchema,
+  expressionNodeSchema,
+  expressionEntrySchema,
+  unaryOperatorSchema,
+  binaryOperatorSchema,
+  assignmentOperatorSchema,
+  noArgMethodSchema,
+  oneArgMethodSchema,
+  spliceMethodSchema,
+  reduceMethodSchema,
+  mapFilterMethodSchema,
+} from "./expression-node.schema";
+
+// State/defs maps
+export {
+  stateEntrySchema,
+  stateMapSchema,
+  defsMapSchema,
+  typeDefEntrySchema,
+} from "./state-entry.schema";
+
+// Class definitions
+export {
+  classParameterDefSchema,
+  classFieldDefSchema,
+  classConstructorDefSchema,
+  classMethodDefSchema,
+  classDefSchema,
+} from "./class-def.schema";
+
+// Content & project
+export { contentTypeDefSchema } from "./content-type-def.schema";
+export { projectConfigSchema } from "./project-config.schema";

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

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

package/defs/project-config.schema.ts

@@ -0,0 +1,199 @@
+export const projectConfigSchema = {
+  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.",
+  type: "object",
+  properties: {
+    name: {
+      description: "Human-readable project name.",
+      type: "string",
+      default: "Jx Site",
+      examples: ["My Portfolio", "Jx Example Site"],
+    },
+    url: {
+      description: "Production URL of the deployed site.",
+      type: "string",
+      examples: ["https://example.com", "https://jxsuite.com"],
+    },
+    defaults: {
+      description: "Default settings applied to all pages unless overridden.",
+      type: "object",
+      properties: {
+        layout: {
+          description:
+            "Default layout file path applied to all pages. " +
+            "Set to null to render pages without a layout.",
+          oneOf: [{ type: "string" }, { type: "null" }],
+          default: null,
+          examples: ["./layouts/base.json"],
+        },
+        lang: {
+          description: "Default lang attribute for the <html> element.",
+          type: "string",
+          default: "en",
+        },
+        charset: {
+          description: "Default charset for the page.",
+          type: "string",
+          default: "utf-8",
+        },
+      },
+    },
+    $head: {
+      description:
+        "Global <head> entries applied to all pages. " +
+        "Array of element definitions for meta tags, link tags, script tags, etc.",
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          tagName: { type: "string" },
+          attributes: {
+            type: "object",
+            additionalProperties: { type: "string" },
+          },
+        },
+      },
+      examples: [
+        [
+          { tagName: "link", attributes: { rel: "icon", href: "/favicon.svg" } },
+          { tagName: "meta", attributes: { name: "generator", content: "Jx" } },
+        ],
+      ],
+    },
+    $elements: {
+      description:
+        "Global custom element dependencies available to all pages. " +
+        "Items are $ref objects or npm package specifier strings.",
+      type: "array",
+      items: {
+        oneOf: [
+          {
+            type: "object",
+            required: ["$ref"],
+            properties: { $ref: { type: "string" } },
+            additionalProperties: false,
+          },
+          { type: "string" },
+        ],
+      },
+    },
+    imports: {
+      description:
+        "Global import map: $prototype names to .class.json file paths. " +
+        "Makes external classes available by name in all pages.",
+      type: "object",
+      additionalProperties: { type: "string" },
+      examples: [
+        {
+          MarkdownFile: "@jxsuite/parser/MarkdownFile.class.json",
+          MarkdownCollection: "@jxsuite/parser/MarkdownCollection.class.json",
+        },
+      ],
+    },
+    $media: {
+      description:
+        "Named media breakpoints following CSS @custom-media convention. " +
+        "Available in all component style objects.",
+      type: "object",
+      additionalProperties: { type: "string" },
+      examples: [
+        {
+          "--sm": "(min-width: 640px)",
+          "--md": "(min-width: 768px)",
+          "--lg": "(min-width: 1024px)",
+        },
+      ],
+    },
+    style: {
+      description:
+        "Global CSS styles applied to the <body> element. " +
+        "Uses the same camelCase CSSOM convention as component styles.",
+      type: "object",
+      additionalProperties: {
+        oneOf: [{ type: "string" }, { type: "number" }, { type: "object" }],
+      },
+    },
+    state: {
+      description: "Site-wide reactive state available to all pages.",
+      type: "object",
+    },
+    $defs: {
+      description: "Global type definitions available to all pages.",
+      type: "object",
+    },
+    contentTypes: {
+      description:
+        "Content type definitions. Each key is a content type name; " +
+        "the value defines the source directory, frontmatter schema, and element dependencies.",
+      type: "object",
+      additionalProperties: { $ref: "#/$defs/ContentTypeDef" },
+    },
+    redirects: {
+      description: "Static redirect rules. Maps source paths to destination paths.",
+      type: "object",
+      additionalProperties: { type: "string" },
+      examples: [{ "/old-about": "/about" }],
+    },
+    copy: {
+      description:
+        "Declarative file copy map. Keys are source paths (relative to project root), values are destination paths (relative to outDir).",
+      type: "object",
+      additionalProperties: { type: "string" },
+    },
+    build: {
+      description: "Build configuration.",
+      type: "object",
+      properties: {
+        outDir: {
+          description: "Output directory for compiled site.",
+          type: "string",
+          default: "./dist",
+        },
+        format: {
+          description: "Output format.",
+          type: "string",
+          enum: ["directory", "single"],
+          default: "directory",
+        },
+        trailingSlash: {
+          description: "Trailing slash behavior for generated URLs.",
+          type: "string",
+          enum: ["always", "never", "ignore"],
+          default: "always",
+        },
+        adapter: {
+          description: "Platform adapter for deployment-specific output.",
+          type: "string",
+          enum: ["netlify", "vercel", "cloudflare"],
+        },
+      },
+    },
+    images: { $ref: "#/$defs/ImageConfig" },
+    i18n: {
+      description: "Internationalization configuration.",
+      type: "object",
+      properties: {
+        defaultLocale: {
+          description: "Default locale code.",
+          type: "string",
+          examples: ["en"],
+        },
+        locales: {
+          description: "Available locale codes.",
+          type: "array",
+          items: { type: "string" },
+          examples: [["en", "fr", "de"]],
+        },
+        routing: {
+          description: "Locale routing strategy.",
+          type: "string",
+          enum: ["prefix-except-default", "prefix-always"],
+        },
+      },
+    },
+  },
+  additionalProperties: false,
+} as const;

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

@@ -0,0 +1,26 @@
+export const pureTypeDefSchema = {
+  description:
+    "A reusable JSON Schema type definition for tooling only. " +
+    "No function, no runtime artifact. " +
+    "Referenced from state entries via $ref. " +
+    "Naming convention: PascalCase.",
+  type: "object",
+  required: ["type"],
+  properties: {
+    type: { $ref: "#/$defs/JsonSchemaType" },
+    description: { type: "string" },
+    enum: { type: "array" },
+    minimum: { type: "number" },
+    maximum: { type: "number" },
+    minLength: { type: "integer", minimum: 0 },
+    maxLength: { type: "integer", minimum: 0 },
+    pattern: { type: "string" },
+    items: {},
+    properties: { type: "object" },
+    required: { type: "array", items: { type: "string" } },
+    examples: { type: "array" },
+  },
+  not: {
+    anyOf: [{ required: ["default"] }, { required: ["$prototype"] }],
+  },
+} as const;

package/defs/ref-object.schema.ts

@@ -0,0 +1,70 @@
+export const internalRefSchema = {
+  description: "Reference to a $defs type definition in the current component.",
+  type: "string",
+  pattern: "^#/\\$defs/",
+  examples: ["#/$defs/Count", "#/$defs/TodoItem", "#/$defs/Status"],
+} as const;
+
+export const stateRefSchema = {
+  description: "Reference to a state entry (runtime variable) in the current component.",
+  type: "string",
+  pattern: "^#/state/",
+  examples: ["#/state/count", "#/state/addTask", "#/state/items"],
+} as const;
+
+export const externalRefSchema = {
+  description: "Reference to an external Jx component file.",
+  type: "string",
+  pattern: "^(\\./|\\.\\./).*\\.json$|^https?://",
+  examples: ["./card.json", "https://cdn.example.com/button.json"],
+} as const;
+
+export const globalRefSchema = {
+  description: "Reference to a window or document global.",
+  type: "string",
+  pattern: "^(window|document)#/",
+  examples: ["window#/currentUser", "document#/appConfig"],
+} as const;
+
+export const parentRefSchema = {
+  description: "Reference to a named state entry passed via $props from a parent component.",
+  type: "string",
+  pattern: "^parent#/",
+  examples: ["parent#/sharedState", "parent#/theme"],
+} as const;
+
+export const mapRefSchema = {
+  description: "Reference to the current Array map iteration context.",
+  type: "string",
+  pattern: "^\\$map/(item|index)(/.*)?$",
+  examples: ["$map/item", "$map/index", "$map/item/text", "$map/item/done"],
+} as const;
+
+export const anyRefSchema = {
+  type: "string",
+  oneOf: [
+    { $ref: "#/$defs/InternalRef" },
+    { $ref: "#/$defs/StateRef" },
+    { $ref: "#/$defs/ExternalRef" },
+    { $ref: "#/$defs/GlobalRef" },
+    { $ref: "#/$defs/ParentRef" },
+    { $ref: "#/$defs/MapRef" },
+  ],
+} as const;
+
+export const refObjectSchema = {
+  description: "A $ref binding. Resolves to a state entry (reactive) or plain value (static).",
+  type: "object",
+  required: ["$ref"],
+  properties: { $ref: { $ref: "#/$defs/AnyRef" } },
+  additionalProperties: false,
+} as const;
+
+export const externalComponentRefSchema = {
+  type: "object",
+  required: ["$ref"],
+  properties: {
+    $ref: { $ref: "#/$defs/ExternalRef" },
+    $props: { $ref: "#/$defs/PropsObject" },
+  },
+} as const;

package/defs/state-entry.schema.ts

@@ -0,0 +1,54 @@
+export const stateEntrySchema = {
+  description:
+    "A single state entry. Shape is determined by value type: " +
+    "scalar/array → naked reactive property, string with ${} → computed, " +
+    'object with $prototype: "Function" → function, ' +
+    "object with $prototype: <other> → data source, " +
+    "object with type and default → typed reactive property, " +
+    "plain object → naked object reactive property.",
+  oneOf: [
+    { type: "number" },
+    { type: "boolean" },
+    { type: "null" },
+    { type: "string" },
+    { type: "array" },
+    { $ref: "#/$defs/TypedStateDef" },
+    { $ref: "#/$defs/FunctionDef" },
+    { $ref: "#/$defs/ExternalClassDef" },
+    { $ref: "#/$defs/ExpressionEntry" },
+    {
+      type: "object",
+      not: {
+        anyOf: [
+          { required: ["$prototype"] },
+          { required: ["default"] },
+          { required: ["type"] },
+          { required: ["$expression"] },
+        ],
+      },
+    },
+  ],
+} as const;
+
+export const stateMapSchema = {
+  description:
+    "Map of runtime variables. Keys are camelCase (public) or #-prefixed (private). " +
+    "All entries are reactive by default.",
+  type: "object",
+  additionalProperties: { $ref: "#/$defs/StateEntry" },
+} as const;
+
+export const defsMapSchema = {
+  description:
+    "Map of reusable JSON Schema type definitions. " +
+    "Keys are PascalCase type names. No runtime artifacts are produced.",
+  type: "object",
+  additionalProperties: { $ref: "#/$defs/TypeDefEntry" },
+} as const;
+
+export const typeDefEntrySchema = {
+  description:
+    "A $defs type definition entry. Must be a pure JSON Schema type " +
+    "definition or a class definition (.class.json format).",
+  oneOf: [{ $ref: "#/$defs/PureTypeDef" }, { $ref: "#/$defs/ClassDef" }],
+} as const;

package/defs/string-or-ref.schema.ts

@@ -0,0 +1,11 @@
+export const stringOrRefSchema = {
+  oneOf: [{ type: "string" }, { $ref: "#/$defs/RefObject" }],
+} as const;
+
+export const boolOrRefSchema = {
+  oneOf: [{ type: "boolean" }, { $ref: "#/$defs/RefObject" }],
+} as const;
+
+export const numberOrRefSchema = {
+  oneOf: [{ type: "number" }, { $ref: "#/$defs/RefObject" }],
+} as const;

package/defs/style-object.schema.ts

@@ -0,0 +1,19 @@
+export const styleObjectSchema = {
+  description:
+    "CSS style definition. camelCase property names follow CSSOM convention. " +
+    "Keys starting with :, ., &, or [ are treated as nested CSS selectors. " +
+    "Keys matching $media breakpoint names are treated as responsive rules.",
+  type: "object",
+  properties: {},
+  additionalProperties: {
+    oneOf: [
+      { type: "string" },
+      { type: "number" },
+      {
+        description: "Nested CSS selector or media breakpoint rules.",
+        type: "object",
+        additionalProperties: { oneOf: [{ type: "string" }, { type: "number" }] },
+      },
+    ],
+  },
+} as const;

package/defs/tag-name.schema.ts

@@ -0,0 +1,6 @@
+export const tagNameSchema = {
+  description:
+    "HTML element tag name or custom element name (must contain a hyphen per Web Components spec).",
+  type: "string",
+  minLength: 1,
+} as const;

package/defs/typed-state-def.schema.ts

@@ -0,0 +1,31 @@
+export const typedStateDefSchema = {
+  description:
+    "A typed reactive state variable with explicit type and default value. " +
+    "The type property is a JSON Schema or $ref to a $defs type definition. " +
+    "The default property is the initial runtime value.",
+  type: "object",
+  required: ["default"],
+  properties: {
+    default: { description: "Initial state value." },
+    type: {
+      description: "JSON Schema type definition, $ref to a $defs type, or JSON Schema type string.",
+      oneOf: [{ type: "string" }, { type: "object" }],
+    },
+    description: { type: "string" },
+    attribute: {
+      description: "Linked HTML attribute name for CEM extraction.",
+      type: "string",
+    },
+    reflects: {
+      description: "Whether property changes reflect back to the HTML attribute.",
+      type: "boolean",
+    },
+    deprecated: {
+      description: "Deprecation notice for CEM extraction.",
+      oneOf: [{ type: "boolean" }, { type: "string" }],
+    },
+    examples: { type: "array" },
+    $ref: { description: "Reference to a shared type definition.", type: "string" },
+  },
+  not: { required: ["$prototype"] },
+} as const;

package/package.json

@@ -6,12 +6,16 @@
   },
   "description": "JSON Schema 2020-12 meta-schema generator for Jx documents",
   "exports": {
-    ".": "./src/schema.js",
+    ".": "./src/schema.ts",
+    "./types": "./types.ts",
+    "./defs": "./defs/index.ts",
     "./schema.json": "./schema.json",
     "./project-schema.json": "./project-schema.json"
   },
   "files": [
     "src/",
+    "defs/",
+    "types.ts",
     "*.json",
     "!package.json"
   ],
@@ -26,11 +30,14 @@
     "url": "git+https://github.com/jxsuite/jx.git"
   },
   "scripts": {
-    "schema": "bun run src/schema.js",
-    "test": "bun test",
-    "test:coverage": "bun test --coverage",
+    "schema": "bun run src/schema.ts",
+    "test": "bun test --isolate",
+    "test:coverage": "bun test --isolate --coverage",
     "upgrade": "bunx npm-check-updates -u && bun install"
   },
   "type": "module",
-  "version": "0.23.1"
+  "version": "0.24.0",
+  "devDependencies": {
+    "json-schema-to-ts": "^3.1.1"
+  }
 }