@jxsuite/schema 0.28.4 → 0.29.0

package/defs/children-value.schema.ts

@@ -15,11 +15,19 @@ export const arrayNamespaceSchema = {
 } as const;
 
 export const childrenValueSchema = {
-  description: "Static array of child definitions, or an Array namespace for dynamic lists.",
+  description:
+    "Array of child definitions — elements, text, or Array namespaces (dynamic lists) mixed " +
+    "freely. A bare Array namespace (the whole children slot is one dynamic list) is also " +
+    "accepted for backward compatibility.",
   oneOf: [
     {
       items: {
-        oneOf: [{ $ref: "#/$defs/ElementDef" }, { type: "string" }, { type: "number" }],
+        oneOf: [
+          { $ref: "#/$defs/ElementDef" },
+          { $ref: "#/$defs/ArrayNamespace" },
+          { type: "string" },
+          { type: "number" },
+        ],
       },
       type: "array",
     },

package/package.json

@@ -39,7 +39,7 @@
     "upgrade": "bunx npm-check-updates -u && bun install"
   },
   "type": "module",
-  "version": "0.28.4",
+  "version": "0.29.0",
   "devDependencies": {
     "json-schema-to-ts": "^3.1.1"
   }

package/schema.json

@@ -4665,7 +4665,7 @@
       "type": "object"
     },
     "ChildrenValue": {
-      "description": "Static array of child definitions, or an Array namespace for dynamic lists.",
+      "description": "Array of child definitions — elements, text, or Array namespaces (dynamic lists) mixed freely. A bare Array namespace (the whole children slot is one dynamic list) is also accepted for backward compatibility.",
       "oneOf": [
         {
           "items": {
@@ -4673,6 +4673,9 @@
               {
                 "$ref": "#/$defs/ElementDef"
               },
+              {
+                "$ref": "#/$defs/ArrayNamespace"
+              },
               {
                 "type": "string"
               },

package/src/guards.ts

@@ -126,6 +126,18 @@ export function isMappedArray(value: unknown): value is JxMappedArray {
   return isJsonObject(value) && value.$prototype === "Array";
 }
 
+/**
+ * Whether a node's `children` holds at least one mapped array — either as the bare whole-children
+ * slot (legacy) or as a member of the children array. Used by renderers and the compiler to decide
+ * if a children list needs inline repeater expansion.
+ */
+export function childrenContainArray(children?: unknown): boolean {
+  if (isMappedArray(children)) {
+    return true;
+  }
+  return Array.isArray(children) && children.some((c) => isMappedArray(c));
+}
+
 /** A .class.json schema-defined class document — `{ $prototype: "Class" }`. */
 export function isClassDef(value: unknown): value is JxClassDef {
   return isJsonObject(value) && value.$prototype === "Class";

package/src/schema.ts

@@ -487,13 +487,29 @@ export async function generateSchemaString() {
   return JSON.stringify(await generateSchema(), null, 2);
 }
 
+// Minimal structural types for the optional `ajv` / `ajv-formats` peer deps
+// (not installed, and shipping no types, in this repo).
+interface AjvValidateFn {
+  (doc: unknown): boolean;
+  errors?: unknown[] | null;
+}
+interface AjvInstance {
+  compile: (schema: unknown) => AjvValidateFn;
+}
+type AjvCtor = new (opts: {
+  allErrors: boolean;
+  ownProperties: boolean;
+  strict: boolean;
+}) => AjvInstance;
+type AddFormatsFn = (ajv: AjvInstance) => void;
+
 export async function validateDocument(doc: Record<string, unknown>) {
-  let Ajv, addFormats;
+  let Ajv: AjvCtor, addFormats: AddFormatsFn;
   try {
     // @ts-expect-error — optional peer dependency
-    ({ default: Ajv } = await import("ajv"));
+    ({ default: Ajv } = (await import("ajv")) as { default: AjvCtor });
     // @ts-expect-error — optional peer dependency
-    ({ default: addFormats } = await import("ajv-formats"));
+    ({ default: addFormats } = (await import("ajv-formats")) as { default: AddFormatsFn });
   } catch {
     throw new Error("Schema validation requires ajv and ajv-formats: bun add ajv ajv-formats");
   }

package/types.ts

@@ -198,6 +198,13 @@ export interface JxElement {
   tagName?: string;
   textContent?: string | null | JxRef;
   innerHTML?: string;
+  /**
+   * Child nodes. A repeater (`{ $prototype: "Array", … }`) may appear as a member of the array —
+   * nestled among siblings or as the sole child — and is structurally a `JxElement` (its
+   * `items`/`map`/`filter`/`sort` are absorbed by the open index signature; narrow with
+   * `isMappedArray`). The bare `| JxMappedArray` form (whole children slot is one repeater) is
+   * retained for backward compatibility with legacy docs.
+   */
   children?: (JxElement | string)[] | JxMappedArray;
   style?: JxStyle;
   attributes?: Record<string, JxAttributeValue>;
@@ -471,6 +478,12 @@ export interface JxMutableNode {
   tagName?: string;
   textContent?: string | null | JxRef;
   innerHTML?: string;
+  /**
+   * Child nodes. The editor models a mapped-array (repeater) member as a `JxMutableNode` carrying
+   * `$prototype: "Array"` (plus `items`/`map`/`filter`/`sort` below), so members stay assignable
+   * here. The bare `| JxMappedArray` form (whole children slot is one repeater) is retained for
+   * backward compatibility.
+   */
   children?: (JxMutableNode | string)[] | JxMappedArray;
   style?: JxStyle;
   attributes?: Record<string, JxAttributeValue>;