@schema-ts/core 0.1.3 → 0.1.4

package/dist/index.js

@@ -1332,7 +1332,7 @@ function validateSchema(schema, value, instancePath = "", schemaPath = "#", fast
 }
 
 // src/effective.ts
-function resolveEffectiveSchema(validator, schema, value, keywordLocation, instanceLocation) {
+function resolveEffectiveSchema(validator, schema, value, keywordLocation, instanceLocation, isRequired = true) {
   let effective = schema;
   if (effective.if) {
     const output = validator.validate(
@@ -1436,6 +1436,13 @@ function resolveEffectiveSchema(validator, schema, value, keywordLocation, insta
   } else {
     type = detectSchemaType(value);
   }
+  if (!isRequired && value === void 0) {
+    return {
+      effectiveSchema: effective,
+      type,
+      error: void 0
+    };
+  }
   const validationOutput = validator.validate(
     effective,
     value,
@@ -1778,16 +1785,17 @@ function getSubSchema(schema, key) {
 }
 
 // src/default.ts
-function getDefaultValue(schema, value, strategy = "explicit") {
+function getDefaultValue(schema, options = {}) {
+  const { value, strategy = "explicit" } = options;
   if (value === void 0) {
     if (schema.const !== void 0) return schema.const;
     if (schema.default !== void 0) return schema.default;
-    if (strategy === "explicit") return void 0;
   }
   const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
   if (type === "object" || !type && schema.properties) {
     let obj;
     if (value === void 0) {
+      if (strategy === "explicit") return void 0;
       obj = {};
     } else if (typeof value === "object" && value !== null) {
       obj = value;
@@ -1797,9 +1805,9 @@ function getDefaultValue(schema, value, strategy = "explicit") {
     if (schema.properties) {
       for (const [key, subschema] of Object.entries(schema.properties)) {
         if (obj[key] !== void 0) {
-          obj[key] = getDefaultValue(subschema, obj[key], strategy);
+          obj[key] = getDefaultValue(subschema, { value: obj[key], strategy });
         } else if (schema.required?.includes(key)) {
-          obj[key] = getDefaultValue(subschema, void 0, strategy);
+          obj[key] = getDefaultValue(subschema, { strategy });
         }
       }
     }
@@ -1808,6 +1816,7 @@ function getDefaultValue(schema, value, strategy = "explicit") {
   if (type === "array") {
     let arr;
     if (value === void 0) {
+      if (strategy === "explicit") return void 0;
       arr = [];
     } else if (Array.isArray(value)) {
       arr = value;
@@ -1817,16 +1826,19 @@ function getDefaultValue(schema, value, strategy = "explicit") {
     if (schema.prefixItems) {
       schema.prefixItems.forEach((subschema, index) => {
         if (index < arr.length) {
-          arr[index] = getDefaultValue(subschema, arr[index], strategy);
+          arr[index] = getDefaultValue(subschema, {
+            value: arr[index],
+            strategy
+          });
         } else if (value === void 0) {
-          arr.push(getDefaultValue(subschema, void 0, strategy));
+          arr.push(getDefaultValue(subschema, { strategy }));
         }
       });
     }
     if (value !== void 0 && schema.items) {
       const startIndex = schema.prefixItems ? schema.prefixItems.length : 0;
       for (let i = startIndex; i < arr.length; i++) {
-        arr[i] = getDefaultValue(schema.items, arr[i], strategy);
+        arr[i] = getDefaultValue(schema.items, { value: arr[i], strategy });
       }
     }
     return arr;
@@ -1834,6 +1846,9 @@ function getDefaultValue(schema, value, strategy = "explicit") {
   if (value !== void 0) {
     return value;
   }
+  if (strategy === "explicit") {
+    return void 0;
+  }
   switch (type) {
     case "string":
       return "";
@@ -2057,7 +2072,11 @@ var SchemaRuntime = class {
   constructor(validator, schema, value, options = {}) {
     this.validator = validator;
     this.value = value;
-    this.options = { autoFillDefaults: "explicit", ...options };
+    this.options = {
+      autoFillDefaults: "explicit",
+      removeEmptyContainers: "auto",
+      ...options
+    };
     const normalized = normalizeSchema(schema);
     this.rootSchema = dereferenceSchemaDeep(normalized, normalized);
     this.root = this.createEmptyNode("", "#");
@@ -2111,12 +2130,15 @@ var SchemaRuntime = class {
     return {
       type: "null",
       schema: {},
+      // Placeholder, will be set in buildNode
       version: -1,
+      // -1 indicates initial construction (not yet built)
       instanceLocation,
       keywordLocation,
       originalSchema: {},
       canRemove: false,
       canAdd: false,
+      isRequired: false,
       children: []
     };
   }
@@ -2254,9 +2276,29 @@ var SchemaRuntime = class {
     }
     return setJsonPointer(this.value, normalizedPath, value);
   }
+  /**
+   * Internal method to remove a value at a path.
+   * Shared logic for removeValue and setValue(undefined).
+   * @param path - The normalized path to remove
+   * @param canRemove - Whether the removal is allowed (pre-checked by caller)
+   * @returns true if successful, false if removal failed
+   */
+  removeValueInternal(path) {
+    const success = removeJsonPointer(this.value, path);
+    if (!success) {
+      return false;
+    }
+    const lastSlash = path.lastIndexOf("/");
+    const parentPath = lastSlash <= 0 ? ROOT_PATH : path.substring(0, lastSlash);
+    const reconcilePath = this.cleanupEmptyContainers(parentPath);
+    this.reconcile(reconcilePath);
+    this.notify({ type: "value", path: reconcilePath });
+    return true;
+  }
   /**
    * Remove a node at the specified path.
    * This deletes the value from the data structure (array splice or object delete).
+   * After removal, may also remove empty parent containers based on removeEmptyContainers option.
    * @param path - The path to remove
    * @returns true if successful, false if the path cannot be removed
    */
@@ -2269,15 +2311,54 @@ var SchemaRuntime = class {
     if (!node || !node.canRemove) {
       return false;
     }
-    const success = removeJsonPointer(this.value, normalizedPath);
+    return this.removeValueInternal(normalizedPath);
+  }
+  /**
+   * Clean up empty parent containers after element removal.
+   * Recursively removes empty arrays/objects based on removeEmptyContainers option.
+   * @param path - The path to check for empty container
+   * @returns The topmost parent path for reconciliation
+   */
+  cleanupEmptyContainers(path) {
+    const strategy = this.options.removeEmptyContainers;
+    if (strategy === "never" || path === ROOT_PATH) {
+      return path;
+    }
+    const node = this.findNode(path);
+    if (!node) {
+      return path;
+    }
+    const value = this.getValue(path);
+    const isEmpty = Array.isArray(value) && value.length === 0 || value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
+    if (!isEmpty) {
+      return path;
+    }
+    const shouldRemove = strategy === "always" || strategy === "auto" && !node.isRequired;
+    if (!shouldRemove) {
+      return path;
+    }
+    const success = removeJsonPointer(this.value, path);
     if (!success) {
-      return false;
+      return path;
     }
-    const lastSlash = normalizedPath.lastIndexOf("/");
-    const parentPath = lastSlash <= 0 ? ROOT_PATH : normalizedPath.substring(0, lastSlash);
-    this.reconcile(parentPath);
-    this.notify({ type: "value", path: parentPath });
-    return true;
+    const lastSlash = path.lastIndexOf("/");
+    const parentPath = lastSlash <= 0 ? ROOT_PATH : path.substring(0, lastSlash);
+    return this.cleanupEmptyContainers(parentPath);
+  }
+  /**
+   * Get default value for a schema, respecting autoFillDefaults option.
+   * Falls back to 'always' strategy if configured strategy returns undefined.
+   */
+  getDefaultValueForAdd(schema) {
+    const strategy = this.options.autoFillDefaults;
+    let defaultValue;
+    if (strategy && strategy !== "never") {
+      defaultValue = getDefaultValue(schema, { strategy });
+    }
+    if (defaultValue === void 0) {
+      defaultValue = getDefaultValue(schema, { strategy: "always" });
+    }
+    return defaultValue;
   }
   /**
    * Add a new child to an array or object at the specified parent path.
@@ -2320,7 +2401,7 @@ var SchemaRuntime = class {
       if (!keywordLocationToken) {
         return false;
       }
-      const defaultValue = initialValue !== void 0 ? initialValue : getDefaultValue(subschema);
+      const defaultValue = initialValue !== void 0 ? initialValue : this.getDefaultValueForAdd(subschema);
       const itemPath = jsonPointerJoin(normalizedPath, String(newIndex));
       const success = setJsonPointer(this.value, itemPath, defaultValue);
       if (!success) return false;
@@ -2338,7 +2419,7 @@ var SchemaRuntime = class {
       if (!keywordLocationToken) {
         return false;
       }
-      const defaultValue = initialValue !== void 0 ? initialValue : getDefaultValue(subschema);
+      const defaultValue = initialValue !== void 0 ? initialValue : this.getDefaultValueForAdd(subschema);
       const propertyPath = jsonPointerJoin(normalizedPath, key);
       const success = setJsonPointer(this.value, propertyPath, defaultValue);
       if (!success) return false;
@@ -2353,16 +2434,26 @@ var SchemaRuntime = class {
    * Creates intermediate containers (objects/arrays) as needed.
    * Triggers reconciliation and notifies subscribers.
    *
+   * When value is undefined and the field is not required, the field will be
+   * removed from the parent container (similar to removeValue behavior).
+   *
    * @param path - The JSON Pointer path (e.g., "/user/name", "" for root)
-   * @param value - The new value to set
+   * @param value - The new value to set. If undefined and field is optional, removes the field.
    * @returns true if successful, false if the path cannot be set
    *
    * @example
    * runtime.setValue("/name", "Bob"); // set name to "Bob"
    * runtime.setValue("", { name: "Alice" }); // replace entire root value
+   * runtime.setValue("/optional", undefined); // remove optional field
    */
   setValue(path, value) {
     const normalizedPath = normalizeRootPath(path);
+    if (value === void 0 && normalizedPath !== ROOT_PATH) {
+      const node = this.findNode(normalizedPath);
+      if (node && !node.isRequired) {
+        return this.removeValueInternal(normalizedPath);
+      }
+    }
     const success = this.setValueAtPath(normalizedPath, value);
     if (!success) return false;
     this.reconcile(normalizedPath);
@@ -2428,29 +2519,56 @@ var SchemaRuntime = class {
    * This handles cases like if-then-else where new properties with defaults
    * may appear when conditions change.
    *
+   * Container initialization rules:
+   * - Root node is always considered required and will be initialized if it has defaults or required properties
+   * - Nested containers are initialized only if they are in parent's required array
+   *
    * @param instanceLocation - The path to the node
    * @param newSchema - The new effective schema
    * @param type - The schema type
+   * @param isRequired - Whether this node is required by its parent
    */
-  applySchemaDefaults(instanceLocation, newSchema, type) {
-    if (this.options.autoFillDefaults === "never") {
+  applySchemaDefaults(instanceLocation, newSchema, type, isRequired = true) {
+    const strategy = this.options.autoFillDefaults;
+    if (strategy === "never") {
       return;
     }
-    const value = this.getValue(instanceLocation);
+    let value = this.getValue(instanceLocation);
+    const isRoot = instanceLocation === ROOT_PATH;
     if (type === "object" && newSchema.properties) {
+      const requiredSet = new Set(newSchema.required || []);
+      const hasAnyDefaults = Object.entries(newSchema.properties).some(
+        ([key, subschema]) => {
+          const defaultValue = getDefaultValue(subschema, { strategy });
+          if (defaultValue !== void 0) return true;
+          const isChildRequired = requiredSet.has(key);
+          if (isChildRequired && (subschema.type === "object" || subschema.type === "array")) {
+            return true;
+          }
+          return false;
+        }
+      );
+      const shouldInitialize = (value === void 0 || value === null) && hasAnyDefaults && (isRoot || isRequired);
+      if (shouldInitialize) {
+        value = {};
+        this.setValueAtPath(normalizeRootPath(instanceLocation), value);
+      }
       const obj = value && typeof value === "object" ? value : null;
       if (!obj) return;
       for (const [key, subschema] of Object.entries(newSchema.properties)) {
         const hasValue = obj[key] !== void 0;
+        const isChildRequired = requiredSet.has(key);
         if (!hasValue) {
-          const defaultValue = getDefaultValue(
-            subschema,
-            void 0,
-            this.options.autoFillDefaults
-          );
+          const defaultValue = getDefaultValue(subschema, { strategy });
           if (defaultValue !== void 0) {
             const propertyPath = jsonPointerJoin(instanceLocation, key);
             setJsonPointer(this.value, propertyPath, defaultValue);
+          } else if (isChildRequired && subschema.type === "object") {
+            const propertyPath = jsonPointerJoin(instanceLocation, key);
+            setJsonPointer(this.value, propertyPath, {});
+          } else if (isChildRequired && subschema.type === "array") {
+            const propertyPath = jsonPointerJoin(instanceLocation, key);
+            setJsonPointer(this.value, propertyPath, []);
           }
         }
       }
@@ -2462,11 +2580,7 @@ var SchemaRuntime = class {
       for (let i = 0; i < newSchema.prefixItems.length; i++) {
         if (arr[i] === void 0) {
           const itemSchema = newSchema.prefixItems[i];
-          const defaultValue = getDefaultValue(
-            itemSchema,
-            void 0,
-            this.options.autoFillDefaults
-          );
+          const defaultValue = getDefaultValue(itemSchema, { strategy });
           if (defaultValue !== void 0) {
             const itemPath = jsonPointerJoin(instanceLocation, String(i));
             setJsonPointer(this.value, itemPath, defaultValue);
@@ -2490,7 +2604,7 @@ var SchemaRuntime = class {
       }
     }
     const newChildren = [];
-    const processChild = (childKey, childSchema, childkeywordLocation, canRemove = false) => {
+    const processChild = (childKey, childSchema, childkeywordLocation, canRemove = false, isRequired = false) => {
       const childinstanceLocation = jsonPointerJoin(instanceLocation, childKey);
       let childNode = oldChildrenMap.get(childinstanceLocation);
       if (childNode) {
@@ -2503,7 +2617,8 @@ var SchemaRuntime = class {
         );
       }
       childNode.canRemove = canRemove;
-      this.buildNode(childNode, childSchema, options);
+      childNode.isRequired = isRequired;
+      this.buildNode(childNode, childSchema, { ...options, isRequired });
       newChildren.push(childNode);
     };
     switch (type) {
@@ -2516,11 +2631,13 @@ var SchemaRuntime = class {
             effectiveSchema.properties
           )) {
             processedKeys.add(key);
+            const isChildRequired = effectiveSchema.required?.includes(key) ?? false;
             processChild(
               key,
               subschema,
               `${keywordLocation}/properties/${key}`,
-              false
+              false,
+              isChildRequired
             );
           }
         }
@@ -2535,7 +2652,9 @@ var SchemaRuntime = class {
                   key,
                   subschema,
                   `${keywordLocation}/patternProperties/${jsonPointerEscape(pattern)}`,
-                  true
+                  true,
+                  false
+                  // patternProperties are never required
                 );
               }
             }
@@ -2549,7 +2668,9 @@ var SchemaRuntime = class {
                 key,
                 subschema,
                 `${keywordLocation}/additionalProperties`,
-                true
+                true,
+                false
+                // additionalProperties are never required
               );
             }
           }
@@ -2567,7 +2688,9 @@ var SchemaRuntime = class {
                 String(i),
                 effectiveSchema.prefixItems[i],
                 `${keywordLocation}/prefixItems/${i}`,
-                false
+                false,
+                true
+                // array items are always considered required
               );
             }
           }
@@ -2577,7 +2700,9 @@ var SchemaRuntime = class {
                 String(i),
                 effectiveSchema.items,
                 `${keywordLocation}/items`,
+                true,
                 true
+                // array items are always considered required
               );
             }
           }
@@ -2594,6 +2719,7 @@ var SchemaRuntime = class {
    * Build/update a FieldNode in place.
    * Updates the node's schema, type, error, and children based on the current value.
    * @param schema - Optional. If provided, updates node.originalSchema. Otherwise uses existing.
+   * @param isRequired - Whether this node is required by its parent schema.
    */
   buildNode(node, schema, options = {}) {
     const { keywordLocation, instanceLocation } = node;
@@ -2611,17 +2737,25 @@ var SchemaRuntime = class {
       if (schemaChanged) {
         this.updateNodeDependencies(node, schema);
       }
+      const isRequired = options.isRequired ?? true;
       const { type, effectiveSchema, error } = resolveEffectiveSchema(
         this.validator,
         node.originalSchema,
         value,
         keywordLocation,
-        instanceLocation
+        instanceLocation,
+        isRequired
       );
-      const effectiveSchemaChanged = !deepEqual(effectiveSchema, node.schema) || type !== node.type;
-      const errorChanged = !deepEqual(error, node.error);
+      const isInitialBuild = node.version === -1;
+      const effectiveSchemaChanged = isInitialBuild || !deepEqual(effectiveSchema, node.schema) || type !== node.type;
+      const errorChanged = isInitialBuild || !deepEqual(error, node.error);
       if (effectiveSchemaChanged) {
-        this.applySchemaDefaults(instanceLocation, effectiveSchema, type);
+        this.applySchemaDefaults(
+          instanceLocation,
+          effectiveSchema,
+          type,
+          isRequired
+        );
       }
       node.schema = effectiveSchema;
       node.type = type;