@schema-ts/core 0.1.2 → 0.1.3

package/dist/index.cjs

@@ -1400,7 +1400,6 @@ function resolveEffectiveSchema(validator, schema, value, keywordLocation, insta
           instanceLocation
         );
         effective = mergeSchema(effective, res.effectiveSchema);
-        break;
       }
     }
     const { anyOf: _, ...rest } = effective;
@@ -1472,6 +1471,19 @@ function mergeSchemaArrays(a, b) {
   if (b === void 0) return a;
   return [...a, ...b];
 }
+function mergeSchemaMap(base, override) {
+  if (base === void 0) return override;
+  if (override === void 0) return base;
+  const merged = { ...base };
+  for (const [key, schema] of Object.entries(override)) {
+    if (merged[key]) {
+      merged[key] = mergeSchema(merged[key], schema);
+    } else {
+      merged[key] = schema;
+    }
+  }
+  return merged;
+}
 function mergeSchema(base, override) {
   if (!override) return base;
   const merged = {
@@ -1498,17 +1510,16 @@ function mergeSchema(base, override) {
       ...override.dependentRequired
     };
   }
-  if (base.properties || override.properties) {
-    merged.properties = {
-      ...base.properties,
-      ...override.properties
-    };
+  const mergedProperties = mergeSchemaMap(base.properties, override.properties);
+  if (mergedProperties !== void 0) {
+    merged.properties = mergedProperties;
   }
-  if (base.patternProperties || override.patternProperties) {
-    merged.patternProperties = {
-      ...base.patternProperties,
-      ...override.patternProperties
-    };
+  const mergedPatternProperties = mergeSchemaMap(
+    base.patternProperties,
+    override.patternProperties
+  );
+  if (mergedPatternProperties !== void 0) {
+    merged.patternProperties = mergedPatternProperties;
   }
   if (base.items && override.items) {
     merged.items = mergeSchema(base.items, override.items);
@@ -1543,11 +1554,12 @@ function mergeSchema(base, override) {
       merged[keyword] = mergedArray;
     }
   }
-  if (base.dependentSchemas || override.dependentSchemas) {
-    merged.dependentSchemas = {
-      ...base.dependentSchemas,
-      ...override.dependentSchemas
-    };
+  const mergedDependentSchemas = mergeSchemaMap(
+    base.dependentSchemas,
+    override.dependentSchemas
+  );
+  if (mergedDependentSchemas !== void 0) {
+    merged.dependentSchemas = mergedDependentSchemas;
   }
   return merged;
 }
@@ -1768,10 +1780,11 @@ function getSubSchema(schema, key) {
 }
 
 // src/default.ts
-function getDefaultValue(schema, value) {
+function getDefaultValue(schema, value, strategy = "explicit") {
   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) {
@@ -1786,9 +1799,9 @@ function getDefaultValue(schema, value) {
     if (schema.properties) {
       for (const [key, subschema] of Object.entries(schema.properties)) {
         if (obj[key] !== void 0) {
-          obj[key] = getDefaultValue(subschema, obj[key]);
+          obj[key] = getDefaultValue(subschema, obj[key], strategy);
         } else if (schema.required?.includes(key)) {
-          obj[key] = getDefaultValue(subschema);
+          obj[key] = getDefaultValue(subschema, void 0, strategy);
         }
       }
     }
@@ -1806,16 +1819,16 @@ function getDefaultValue(schema, value) {
     if (schema.prefixItems) {
       schema.prefixItems.forEach((subschema, index) => {
         if (index < arr.length) {
-          arr[index] = getDefaultValue(subschema, arr[index]);
+          arr[index] = getDefaultValue(subschema, arr[index], strategy);
         } else if (value === void 0) {
-          arr.push(getDefaultValue(subschema));
+          arr.push(getDefaultValue(subschema, void 0, 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]);
+        arr[i] = getDefaultValue(schema.items, arr[i], strategy);
       }
     }
     return arr;
@@ -2029,21 +2042,24 @@ var SchemaRuntime = class {
   value;
   version = 0;
   rootSchema = {};
+  options;
   /**
    * Create a new SchemaRuntime instance.
    *
    * @param validator - The validator instance for schema validation
    * @param schema - The JSON Schema definition (will be normalized and dereferenced)
    * @param value - The initial data value to manage
+   * @param options - Runtime configuration options
    *
    * @example
    * const validator = new Validator();
    * const schema = { type: "object", properties: { name: { type: "string" } } };
    * const runtime = new SchemaRuntime(validator, schema, { name: "Alice" });
    */
-  constructor(validator, schema, value) {
+  constructor(validator, schema, value, options = {}) {
     this.validator = validator;
     this.value = value;
+    this.options = { autoFillDefaults: "explicit", ...options };
     const normalized = normalizeSchema(schema);
     this.rootSchema = dereferenceSchemaDeep(normalized, normalized);
     this.root = this.createEmptyNode("", "#");
@@ -2225,6 +2241,21 @@ var SchemaRuntime = class {
     if (normalizedPath === ROOT_PATH) return this.value;
     return getJsonPointer(this.value, normalizedPath);
   }
+  /**
+   * Internal helper to set a value at a normalized path.
+   * Handles both root and non-root paths.
+   *
+   * @param normalizedPath - The normalized JSON Pointer path
+   * @param value - The value to set
+   * @returns true if successful, false if the path cannot be set
+   */
+  setValueAtPath(normalizedPath, value) {
+    if (normalizedPath === ROOT_PATH) {
+      this.value = value;
+      return true;
+    }
+    return setJsonPointer(this.value, normalizedPath, value);
+  }
   /**
    * Remove a node at the specified path.
    * This deletes the value from the data structure (array splice or object delete).
@@ -2265,8 +2296,23 @@ var SchemaRuntime = class {
     if (!parentNode || !parentNode.canAdd) {
       return false;
     }
-    const parentValue = this.getValue(normalizedPath);
+    let parentValue = this.getValue(normalizedPath);
     const parentSchema = parentNode.schema;
+    if (parentNode.type === "array") {
+      if (Array.isArray(parentValue)) ; else if (parentValue === void 0 || parentValue === null) {
+        parentValue = [];
+        this.setValueAtPath(normalizedPath, parentValue);
+      } else {
+        return false;
+      }
+    } else if (parentNode.type === "object") {
+      if (parentValue && typeof parentValue === "object") ; else if (parentValue === void 0 || parentValue === null) {
+        parentValue = {};
+        this.setValueAtPath(normalizedPath, parentValue);
+      } else {
+        return false;
+      }
+    }
     if (parentNode.type === "array" && Array.isArray(parentValue)) {
       const newIndex = parentValue.length;
       const { schema: subschema, keywordLocationToken } = getSubSchema(
@@ -2283,7 +2329,7 @@ var SchemaRuntime = class {
       this.reconcile(normalizedPath);
       this.notify({ type: "value", path: normalizedPath });
       return true;
-    } else if (parentNode.type === "object" && parentValue && typeof parentValue === "object") {
+    } else if (parentNode.type === "object" && typeof parentValue === "object") {
       if (!key) {
         return false;
       }
@@ -2319,12 +2365,8 @@ var SchemaRuntime = class {
    */
   setValue(path, value) {
     const normalizedPath = normalizeRootPath(path);
-    if (normalizedPath === ROOT_PATH) {
-      this.value = value;
-    } else {
-      const success = setJsonPointer(this.value, normalizedPath, value);
-      if (!success) return false;
-    }
+    const success = this.setValueAtPath(normalizedPath, value);
+    if (!success) return false;
     this.reconcile(normalizedPath);
     this.notify({ type: "value", path: normalizedPath });
     return true;
@@ -2393,6 +2435,9 @@ var SchemaRuntime = class {
    * @param type - The schema type
    */
   applySchemaDefaults(instanceLocation, newSchema, type) {
+    if (this.options.autoFillDefaults === "never") {
+      return;
+    }
     const value = this.getValue(instanceLocation);
     if (type === "object" && newSchema.properties) {
       const obj = value && typeof value === "object" ? value : null;
@@ -2400,7 +2445,11 @@ var SchemaRuntime = class {
       for (const [key, subschema] of Object.entries(newSchema.properties)) {
         const hasValue = obj[key] !== void 0;
         if (!hasValue) {
-          const defaultValue = getDefaultValue(subschema);
+          const defaultValue = getDefaultValue(
+            subschema,
+            void 0,
+            this.options.autoFillDefaults
+          );
           if (defaultValue !== void 0) {
             const propertyPath = jsonPointerJoin(instanceLocation, key);
             setJsonPointer(this.value, propertyPath, defaultValue);
@@ -2414,7 +2463,12 @@ var SchemaRuntime = class {
       if (!arr) return;
       for (let i = 0; i < newSchema.prefixItems.length; i++) {
         if (arr[i] === void 0) {
-          const defaultValue = getDefaultValue(newSchema.prefixItems[i]);
+          const itemSchema = newSchema.prefixItems[i];
+          const defaultValue = getDefaultValue(
+            itemSchema,
+            void 0,
+            this.options.autoFillDefaults
+          );
           if (defaultValue !== void 0) {
             const itemPath = jsonPointerJoin(instanceLocation, String(i));
             setJsonPointer(this.value, itemPath, defaultValue);