jedison 1.4.1 → 1.4.2

package/dist/esm/jedison.js

@@ -1,8 +1,29 @@
 function clone(thing) {
-  if (typeof thing === "undefined") {
-    return void 0;
+  if (thing === null || typeof thing !== "object") {
+    return thing;
+  }
+  if (Array.isArray(thing)) {
+    const len = thing.length;
+    const arr = new Array(len);
+    for (let i = 0; i < len; i++) {
+      const item = thing[i];
+      arr[i] = item === null || typeof item !== "object" ? item : clone(item);
+    }
+    return arr;
+  }
+  const keys = Object.keys(thing);
+  const obj = {};
+  for (let i = 0, len = keys.length; i < len; i++) {
+    const key = keys[i];
+    const val = thing[key];
+    const cloned = val === null || typeof val !== "object" ? val : clone(val);
+    if (key === "__proto__") {
+      Object.defineProperty(obj, key, { value: cloned, writable: true, enumerable: true, configurable: true });
+    } else {
+      obj[key] = cloned;
+    }
   }
-  return JSON.parse(JSON.stringify(thing));
+  return obj;
 }
 function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -24,11 +45,29 @@ function sortObject(obj) {
 }
 function equal(a, b) {
   if (a === b) return true;
-  if (isObject(a) && isObject(b)) {
-    a = sortObject(a);
-    b = sortObject(b);
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") {
+    return false;
+  }
+  const aIsArray = Array.isArray(a);
+  const bIsArray = Array.isArray(b);
+  if (aIsArray !== bIsArray) return false;
+  if (aIsArray) {
+    const len = a.length;
+    if (len !== b.length) return false;
+    for (let i = 0; i < len; i++) {
+      if (!equal(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (let i = 0, len = keysA.length; i < len; i++) {
+    const key = keysA[i];
+    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+    if (!equal(a[key], b[key])) return false;
   }
-  return JSON.stringify(a) === JSON.stringify(b);
+  return true;
 }
 function different(a, b) {
   return !equal(a, b);
@@ -472,9 +511,7 @@ function allOf(context) {
   const allOf2 = getSchemaAllOf(context.schema);
   if (isSet(allOf2)) {
     allOf2.forEach((schema) => {
-      const subSchemaEditor = new Jedison({ refParser: context.validator.refParser, schema, data: context.value, rootName: context.key });
-      const subSchemaErrors = subSchemaEditor.getErrors();
-      subSchemaEditor.destroy();
+      const subSchemaErrors = context.validator.getErrors(context.value, schema, context.key, context.path);
       subSchemaErrors.forEach((error) => {
         error.path = context.path;
       });
@@ -510,14 +547,13 @@ function anyOf(context) {
   const anyOf2 = getSchemaAnyOf(context.schema);
   if (isSet(anyOf2)) {
     let valid = false;
-    anyOf2.forEach((schema) => {
-      const anyOfEditor = new Jedison({ refParser: context.validator.refParser, schema, data: context.value });
-      const anyOfErrors = anyOfEditor.getErrors();
-      anyOfEditor.destroy();
+    for (const schema of anyOf2) {
+      const anyOfErrors = context.validator.getErrors(context.value, schema, context.key, context.path);
       if (anyOfErrors.length === 0) {
         valid = true;
+        break;
       }
-    });
+    }
     if (!valid) {
       errors.push({
         type: "error",
@@ -639,13 +675,7 @@ function items(context) {
     } else if (isObject(items2)) {
       context.value.slice(prefixItemsSchemasCount).forEach((itemValue, i) => {
         const index2 = prefixItemsSchemasCount + i;
-        const tmpEditor = new Jedison({
-          refParser: context.validator.refParser,
-          schema: items2,
-          data: itemValue
-        });
-        const tmpErrors = tmpEditor.getErrors();
-        tmpEditor.destroy();
+        const tmpErrors = context.validator.getErrors(itemValue, items2, index2, context.path + "/" + index2);
         if (tmpErrors.length > 0) {
           errors.push({
             type: "error",
@@ -812,9 +842,7 @@ function not(context) {
   const errors = [];
   const not2 = getSchemaNot(context.schema);
   if (isSet(not2)) {
-    const notEditor = new Jedison({ refParser: context.validator.refParser, schema: not2, data: context.value });
-    const notErrors = notEditor.getErrors();
-    notEditor.destroy();
+    const notErrors = context.validator.getErrors(context.value, not2, context.key, context.path);
     const invalid = notErrors.length === 0;
     if (invalid) {
       errors.push({
@@ -835,9 +863,7 @@ function oneOf(context) {
   if (isSet(oneOf2)) {
     let counter = 0;
     oneOf2.forEach((schema) => {
-      const oneOfEditor = new Jedison({ refParser: context.validator.refParser, schema, data: context.value });
-      const oneOfErrors = oneOfEditor.getErrors();
-      oneOfEditor.destroy();
+      const oneOfErrors = context.validator.getErrors(context.value, schema, context.key, context.path);
       if (oneOfErrors.length === 0) {
         counter++;
       }
@@ -887,12 +913,7 @@ function patternProperties(context) {
         const regexp = new RegExp(pattern2);
         if (regexp.test(propertyName)) {
           const schema = patternProperties2[pattern2];
-          const editor = new Jedison({
-            refParser: context.validator.refParser,
-            schema,
-            data: context.value[propertyName]
-          });
-          const editorErrors = editor.getErrors().map((error) => {
+          const editorErrors = context.validator.getErrors(context.value[propertyName], schema, propertyName, context.path + "/" + propertyName).map((error) => {
             return {
               type: "error",
               path: context.path + "/" + propertyName,
@@ -901,7 +922,6 @@ function patternProperties(context) {
             };
           });
           errors = [...errors, ...editorErrors];
-          editor.destroy();
         }
       });
     });
@@ -1085,19 +1105,13 @@ function additionalProperties(context) {
             ]
           });
         } else if (isObject(additionalProperties2)) {
-          const editor = new Jedison({
-            refParser: context.validator.refParser,
-            schema: additionalProperties2,
-            data: context.value[property]
-          });
-          const additionalPropertyErrors = editor.getErrors().map((error) => ({
+          const additionalPropertyErrors = context.validator.getErrors(context.value[property], additionalProperties2, property, context.path + "/" + property).map((error) => ({
             type: "error",
             path: `${context.path}.${property}`,
             constraint: "additionalProperties",
             messages: error.messages
           }));
           errors.push(...additionalPropertyErrors);
-          editor.destroy();
         }
       }
     });
@@ -1159,13 +1173,11 @@ function contains(context) {
   const maxContains = getSchemaMaxContains(context.schema);
   if (isArray(context.value) && isSet(contains2)) {
     let counter = 0;
-    context.value.forEach((item) => {
-      const containsEditor = new Jedison({ refParser: context.validator.refParser, schema: contains2, data: item });
-      const containsErrors = containsEditor.getErrors();
+    context.value.forEach((item, index2) => {
+      const containsErrors = context.validator.getErrors(item, contains2, index2, context.path + "/" + index2);
       if (containsErrors.length === 0) {
         counter++;
       }
-      containsEditor.destroy();
     });
     const containsInvalid = counter === 0;
     if (isSet(minContains)) {
@@ -1248,9 +1260,7 @@ function dependentSchemas(context) {
     Object.keys(dependentSchemas2).forEach((key) => {
       if (isSet(context.value[key])) {
         const dependentSchema = dependentSchemas2[key];
-        const tmpEditor = new Jedison({ refParser: context.validator.refParser, schema: dependentSchema, data: context.value });
-        const tmpErrors = tmpEditor.getErrors();
-        tmpEditor.destroy();
+        const tmpErrors = context.validator.getErrors(context.value, dependentSchema, context.key, context.path);
         errors = [...errors, ...tmpErrors];
       }
     });
@@ -1258,43 +1268,26 @@ function dependentSchemas(context) {
   return errors;
 }
 function ifThenElse(context) {
-  const errors = [];
   const schemaIf = getSchemaIf(context.schema);
   const schemaThen = getSchemaThen(context.schema);
   const schemaElse = getSchemaElse(context.schema);
   if (isSet(schemaIf)) {
     if (notSet(schemaThen) && notSet(schemaElse)) {
-      return errors;
-    }
-    const ifEditor = new Jedison({ refParser: context.validator.refParser, schema: schemaIf, data: context.value });
-    const ifErrors = ifEditor.getErrors();
-    ifEditor.destroy();
-    let thenErrors = [];
-    let elseErrors = [];
-    if (isSet(schemaThen)) {
-      const thenEditor = new Jedison({ refParser: context.validator.refParser, schema: schemaThen, data: context.value });
-      thenErrors = thenEditor.getErrors();
-      thenEditor.destroy();
-    }
-    if (isSet(schemaElse)) {
-      const elseEditor = new Jedison({ refParser: context.validator.refParser, schema: schemaElse, data: context.value });
-      elseErrors = elseEditor.getErrors();
-      elseEditor.destroy();
+      return [];
     }
     if (schemaIf === true) {
-      return thenErrors;
+      return isSet(schemaThen) ? context.validator.getErrors(context.value, schemaThen, context.key, context.path) : [];
     }
     if (schemaIf === false) {
-      return elseErrors;
+      return isSet(schemaElse) ? context.validator.getErrors(context.value, schemaElse, context.key, context.path) : [];
     }
+    const ifErrors = context.validator.getErrors(context.value, schemaIf, context.key, context.path);
     if (ifErrors.length === 0) {
-      return thenErrors;
-    }
-    if (ifErrors.length > 0) {
-      return elseErrors;
+      return isSet(schemaThen) ? context.validator.getErrors(context.value, schemaThen, context.key, context.path) : [];
     }
+    return isSet(schemaElse) ? context.validator.getErrors(context.value, schemaElse, context.key, context.path) : [];
   }
-  return errors;
+  return [];
 }
 function prefixItems(context) {
   const errors = [];
@@ -1303,9 +1296,7 @@ function prefixItems(context) {
     prefixItems2.forEach((itemSchema, index2) => {
       const itemValue = context.value[index2];
       if (isSet(itemValue)) {
-        const tmpEditor = new Jedison({ refParser: context.validator.refParser, schema: itemSchema, data: itemValue });
-        const tmpErrors = tmpEditor.getErrors();
-        tmpEditor.destroy();
+        const tmpErrors = context.validator.getErrors(itemValue, itemSchema, index2, context.path + "/" + index2);
         if (tmpErrors.length > 0) {
           errors.push({
             type: "error",
@@ -1437,12 +1428,7 @@ function unevaluatedProperties(context) {
           });
         }
         if (!definedInPatternProperty && isObject(unevaluatedProperties2) && !hasOwn(properties2, property)) {
-          const editor = new Jedison({
-            refParser: context.validator.refParser,
-            schema: unevaluatedProperties2,
-            data: context.value[property]
-          });
-          const unevaluatedPropertiesErrors = editor.getErrors().map((error) => {
+          const unevaluatedPropertiesErrors = context.validator.getErrors(context.value[property], unevaluatedProperties2, property, context.path + "/" + property).map((error) => {
             return {
               type: "error",
               path: property,
@@ -1451,7 +1437,6 @@ function unevaluatedProperties(context) {
             };
           });
           errors = [...errors, ...unevaluatedPropertiesErrors];
-          editor.destroy();
         }
       });
     }
@@ -1497,12 +1482,7 @@ function propertyNames(context) {
   const schemaPropertyNames = getSchemaPropertyNames(context.schema);
   if (isObject(context.value) && isSet(schemaPropertyNames)) {
     Object.keys(context.value).forEach((propertyName) => {
-      const editor = new Jedison({
-        refParser: context.validator.refParser,
-        schema: schemaPropertyNames,
-        data: propertyName
-      });
-      const invalid = editor.getErrors().length > 0;
+      const invalid = context.validator.getErrors(propertyName, schemaPropertyNames, propertyName, context.path).length > 0;
       if (invalid) {
         errors.push({
           type: "error",
@@ -1572,24 +1552,26 @@ class Validator {
    */
   getErrors(value, schema, key, path) {
     let schemaErrors = [];
-    const schemaClone = clone(schema);
-    if (isBoolean(schemaClone) && schemaClone === true) {
+    if (isBoolean(schema) && schema === true) {
       return schemaErrors;
     }
-    if (isBoolean(schemaClone) && schemaClone === false) {
+    if (isBoolean(schema) && schema === false) {
       return [{
         type: "error",
         messages: ["invalid"],
         path
       }];
     }
+    if (this.refParser && isObject(schema) && hasOwn(schema, "$ref")) {
+      schema = this.refParser.expand(schema);
+    }
     const allConstraints = { ...this.draft, ...this.constraints };
     for (const [constraintName, constraint] of Object.entries(allConstraints)) {
-      if (hasOwn(schemaClone, constraintName)) {
+      if (hasOwn(schema, constraintName)) {
         const context = {
           validator: this,
           value,
-          schema: schemaClone,
+          schema,
           key,
           path,
           translator: this.translator
@@ -1628,7 +1610,7 @@ class Validator {
 }
 class EventEmitter {
   constructor() {
-    this.listeners = [];
+    this.listeners = /* @__PURE__ */ new Map();
   }
   /**
    * Adds a named event listener
@@ -1637,10 +1619,15 @@ class EventEmitter {
    * @param {function} callback - A callback functions that will be executed when this event is emitted
    */
   on(name, callback) {
-    this.listeners.push({ name, callback });
+    let callbacks = this.listeners.get(name);
+    if (!callbacks) {
+      callbacks = [];
+      this.listeners.set(name, callbacks);
+    }
+    callbacks.push(callback);
   }
   off(name) {
-    this.listeners = this.listeners.filter((listener) => listener.name !== name);
+    this.listeners.delete(name);
   }
   /**
    * Triggers the callback function of a named event listener
@@ -1649,14 +1636,16 @@ class EventEmitter {
    * @param {...*} args - Arguments to be passed to the callback function
    */
   emit(name, ...args) {
-    const listeners = this.listeners.filter((listener) => listener.name === name);
-    listeners.forEach((listener) => {
-      try {
-        listener.callback(...args);
-      } catch (error) {
-        console.error(`Error in listener callback for event "${name}":`, error);
+    const callbacks = this.listeners.get(name);
+    if (callbacks) {
+      for (const listener of callbacks) {
+        try {
+          listener(...args);
+        } catch (error) {
+          console.error(`Error in listener callback for event "${name}":`, error);
+        }
       }
-    });
+    }
   }
   /**
    * Deletes all properties of the class
@@ -1680,6 +1669,8 @@ class Instance extends EventEmitter {
     this.children = [];
     this.ui = null;
     this.isDirty = false;
+    this.cachedErrors = null;
+    this.cachedErrorsValue = void 0;
     this.watched = {};
     this.key = this.path.split(this.jedison.pathSeparator).pop();
     this.arrayTemplateData = config.arrayTemplateData || {};
@@ -1764,7 +1755,7 @@ class Instance extends EventEmitter {
     const enforceEnum = schemaEnforceEnum ?? this.jedison.options.enforceEnum;
     const finalEnforceEnum = isSet(schemaEnforceEnum) ? enforceEnum : enforceEnumDefault;
     const schemaEnum = getSchemaEnum(this.schema);
-    if (isSet(schemaEnum) && !schemaEnum.includes(this.getValue()) && isSet(schemaEnum[0]) && finalEnforceEnum) {
+    if (isSet(schemaEnum) && !schemaEnum.includes(this.getValueRaw()) && isSet(schemaEnum[0]) && finalEnforceEnum) {
       this.setValue(schemaEnum[0], false);
     }
     if (notSet(this.value)) {
@@ -1829,13 +1820,19 @@ class Instance extends EventEmitter {
   getValue() {
     return clone(this.value);
   }
+  /**
+   * Returns the value of the instance without cloning (internal read-only use)
+   */
+  getValueRaw() {
+    return this.value;
+  }
   /**
    * Returns the data that will replace placeholders in titles, descriptions (e.g. "{{ i1 }} {{ value.title }}")
    */
   getTemplateData(template) {
     const templateData = {
       ...this.arrayTemplateData,
-      value: this.getValue(),
+      value: this.getValueRaw(),
       settings: this.jedison.options.settings
     };
     if (typeof this.value === "string") {
@@ -1889,6 +1886,7 @@ class Instance extends EventEmitter {
     }
     this.value = newValue;
     this.isDirty = true;
+    this.cachedErrors = null;
     this.emit("set-value", newValue, initiator);
     this.emit("change", initiator);
     this.jedison.emit("instance-change", this, initiator);
@@ -1909,8 +1907,15 @@ class Instance extends EventEmitter {
     if (!this.isActive) {
       return [];
     }
-    const errors = this.jedison.validator.getErrors(this.getValue(), this.originalSchema, this.getKey(), this.path);
-    return removeDuplicatesFromArray(errors);
+    if (this.cachedErrorsValue === this.value && this.cachedErrors !== null) {
+      return this.cachedErrors;
+    }
+    const errors = removeDuplicatesFromArray(
+      this.jedison.validator.getErrors(this.getValueRaw(), this.originalSchema, this.getKey(), this.path)
+    );
+    this.cachedErrorsValue = this.value;
+    this.cachedErrors = errors;
+    return errors;
   }
   /**
    * Returns true if any leaf descendant is showing validation errors.
@@ -2379,7 +2384,7 @@ class InstanceIfThenElse extends Instance {
     this.on("set-value", (value, initiator) => {
       this.changeValue(value, initiator);
     });
-    const ifValue = this.instanceWithoutIf.getValue();
+    const ifValue = this.instanceWithoutIf.getValueRaw();
     this.changeValue(ifValue);
   }
   changeValue(value, initiator = "api") {
@@ -2415,7 +2420,7 @@ class InstanceIfThenElse extends Instance {
       }
       instance.setValue(instanceValue, false, initiator);
       instance.on("notifyParent", (initiator2) => {
-        const value2 = instance.getValue();
+        const value2 = instance.getValueRaw();
         this.changeValue(value2, initiator2);
         this.emit("notifyParent", initiator2);
         this.emit("change", initiator2);
@@ -2424,7 +2429,7 @@ class InstanceIfThenElse extends Instance {
     if (initiator === "api" && this.hasNullableFields(this.activeInstance)) {
       this.activeInstance.setValue(value, false, "secondary");
     }
-    this.value = this.activeInstance.getValue();
+    this.value = this.activeInstance.getValueRaw();
   }
   getWithoutIfValueFromValue(value) {
     let withoutIf = this.instanceWithoutIf.getValue();
@@ -2483,23 +2488,15 @@ class InstanceIfThenElse extends Instance {
    */
   getFittestIndex(value) {
     let fittestIndex = this.index;
+    const key = this.getKey();
     this.ifThenElseSchemas.forEach((schema, index2) => {
       if (schema.if === true) {
         fittestIndex = 0;
       } else if (schema.if === false) {
         fittestIndex = 1;
       } else {
-        const testSchema = clone(schema.if);
-        if (isSet(this.schema.type)) {
-          testSchema.type = this.schema.type;
-        }
-        const ifValidator = new Jedison({
-          schema: testSchema,
-          data: value,
-          refParser: this.jedison.refParser
-        });
-        const ifErrors = ifValidator.getErrors();
-        ifValidator.destroy();
+        const testSchema = isSet(this.schema.type) ? { ...schema.if, type: this.schema.type } : schema.if;
+        const ifErrors = this.jedison.validator.getErrors(value, testSchema, key, this.path);
         if (ifErrors.length === 0 && schema.then) {
           fittestIndex = index2;
         }
@@ -2610,7 +2607,7 @@ class InstanceMultiple extends Instance {
       instance.unregister();
       instance.off("notifyParent");
       instance.on("notifyParent", (initiator) => {
-        this.value = this.activeInstance.getValue();
+        this.value = this.activeInstance.getValueRaw();
         this.emit("notifyParent", initiator);
         this.emit("change", initiator);
       });
@@ -2626,10 +2623,10 @@ class InstanceMultiple extends Instance {
     if (isSet(value)) {
       this.activeInstance.setValue(value, false, initiator);
     }
-    this.setValue(this.activeInstance.getValue(), true, initiator);
+    this.setValue(this.activeInstance.getValueRaw(), true, initiator);
   }
   onSetValue() {
-    if (different(this.activeInstance.getValue(), this.value)) {
+    if (different(this.activeInstance.getValueRaw(), this.value)) {
       const fittestIndex = this.getFittestIndex(this.value);
       this.switchInstance(fittestIndex, this.value);
     }
@@ -2642,9 +2639,8 @@ class InstanceMultiple extends Instance {
     let championErrors;
     for (let index2 = 0; index2 < this.instances.length; index2++) {
       const instance = this.instances[index2];
-      const tmpEditor = new Jedison({ refParser: this.jedison.refParser, schema: instance.schema, data: value });
-      const instanceErrors = tmpEditor.getErrors();
-      tmpEditor.destroy();
+      const testValue = isSet(value) ? value : instance.getValueRaw();
+      const instanceErrors = this.jedison.validator.getErrors(testValue, instance.schema, this.getKey(), this.path);
       if (instanceErrors.length === 0) {
         fittestIndex = index2;
         break;
@@ -2672,6 +2668,8 @@ class InstanceObject extends Instance {
   prepare() {
     this.properties = {};
     this.requiredProperties = /* @__PURE__ */ new Set();
+    this.schemaPatternProperties = getSchemaPatternProperties(this.schema);
+    this.schemaAdditionalProperties = getSchemaAdditionalProperties(this.schema);
     const schemaProperties = getSchemaProperties(this.schema);
     const schemaRequired = getSchemaRequired(this.schema);
     if (isSet(schemaProperties)) {
@@ -2683,16 +2681,17 @@ class InstanceObject extends Instance {
         const optionsDeactivateNonRequired = this.jedison.options.deactivateNonRequired;
         const deactivateNonRequired = getSchemaXOption(this.schema, "deactivateNonRequired");
         const schemaDeactivateNonRequired = getSchemaXOption(schema, "deactivateNonRequired");
-        if (!this.isRequired(key) && isSet(optionsDeactivateNonRequired) && optionsDeactivateNonRequired === true) {
+        const isReq = this.isRequired(key);
+        if (!isReq && isSet(optionsDeactivateNonRequired) && optionsDeactivateNonRequired === true) {
           musstCreateChild = false;
         }
-        if (!this.isRequired(key) && isSet(deactivateNonRequired) && deactivateNonRequired === true) {
+        if (!isReq && isSet(deactivateNonRequired) && deactivateNonRequired === true) {
           musstCreateChild = false;
         }
-        if (!this.isRequired(key) && isSet(schemaDeactivateNonRequired) && schemaDeactivateNonRequired === true) {
+        if (!isReq && isSet(schemaDeactivateNonRequired) && schemaDeactivateNonRequired === true) {
           musstCreateChild = false;
         }
-        if (!this.isRequired(key) && isRecursive) {
+        if (!isReq && isRecursive) {
           musstCreateChild = false;
         }
         if (musstCreateChild) {
@@ -2719,11 +2718,12 @@ class InstanceObject extends Instance {
   removeNotListedPropertiesFromValue(value) {
     const schemaEnforceAdditionalProperties = getSchemaXOption(this.schema, "enforceAdditionalProperties");
     const enforceAdditionalProperties = isSet(schemaEnforceAdditionalProperties) ? schemaEnforceAdditionalProperties : this.jedison.options.enforceAdditionalProperties;
-    const schemaAdditionalProperties = getSchemaAdditionalProperties(this.schema);
-    const schemaPatternProperties = getSchemaPatternProperties(this.schema) || {};
+    const schemaAdditionalProperties = this.schemaAdditionalProperties;
+    const schemaPatternProperties = this.schemaPatternProperties || {};
     if (this.jedison.isEditor && enforceAdditionalProperties && isSet(schemaAdditionalProperties) && schemaAdditionalProperties === false) {
+      const compiledPatterns = Object.keys(schemaPatternProperties).map((p) => new RegExp(p));
       Object.keys(value).forEach((propertyName) => {
-        const matchesPattern = Object.keys(schemaPatternProperties).some((pattern2) => new RegExp(pattern2).test(propertyName));
+        const matchesPattern = compiledPatterns.some((re) => re.test(propertyName));
         if (!hasOwn(this.properties, propertyName) && !matchesPattern) {
           console.warn("deleting", propertyName);
           delete value[propertyName];
@@ -2803,18 +2803,18 @@ class InstanceObject extends Instance {
   }
   getPropertySchema(propertyName) {
     let schema;
-    const schemaAdditionalProperties = getSchemaAdditionalProperties(this.schema);
+    const schemaAdditionalProperties = this.schemaAdditionalProperties;
     const schemaProperties = getSchemaProperties(this.schema);
-    const schemaPatternProperties = getSchemaPatternProperties(this.schema);
+    const schemaPatternProperties = this.schemaPatternProperties;
     if (isSet(schemaProperties) && hasOwn(schemaProperties, propertyName)) {
       schema = schemaProperties[propertyName];
     } else if (isSet(schemaPatternProperties)) {
-      Object.keys(schemaPatternProperties).forEach((pattern2) => {
-        const regexp = new RegExp(pattern2);
-        if (regexp.test(propertyName)) {
+      for (const pattern2 of Object.keys(schemaPatternProperties)) {
+        if (new RegExp(pattern2).test(propertyName)) {
           schema = schemaPatternProperties[pattern2];
+          break;
         }
-      });
+      }
     }
     if (notSet(schema) && isSet(schemaAdditionalProperties)) {
       schema = schemaAdditionalProperties;
@@ -2831,11 +2831,11 @@ class InstanceObject extends Instance {
         const propertyName = child.getKey();
         if (propertyName === "__proto__") {
           Object.defineProperty(value, propertyName, {
-            value: child.getValue(),
+            value: child.getValueRaw(),
             enumerable: true
           });
         } else {
-          value[propertyName] = child.getValue();
+          value[propertyName] = child.getValueRaw();
         }
       }
     });
@@ -2876,15 +2876,19 @@ class InstanceObject extends Instance {
     if (!isObject(value)) {
       return;
     }
+    const childMap = /* @__PURE__ */ new Map();
+    for (const child of this.children) {
+      childMap.set(child.getKey(), child);
+    }
     Object.keys(value).forEach((propertyName) => {
-      const child = this.getChild(propertyName);
+      const child = childMap.get(propertyName);
       if (child) {
         child.activate();
-        const oldValue = child.getValue();
-        const newValue = value[child.getKey()];
+        const oldValue = child.getValueRaw();
+        const newValue = value[propertyName];
         if (different(oldValue, newValue)) {
           const finalValue = child.setValue(newValue, false, initiator);
-          value[child.getKey()] = finalValue;
+          value[propertyName] = finalValue;
         }
       } else {
         const schema = this.getPropertySchema(propertyName);
@@ -2895,7 +2899,7 @@ class InstanceObject extends Instance {
       const instance = this.children[i];
       const propertyName = instance.getKey();
       if (notSet(value[propertyName])) {
-        if (this.getChild(propertyName)) {
+        if (childMap.has(propertyName)) {
           instance.deactivate();
         } else {
           this.deleteChild(propertyName);
@@ -2908,6 +2912,8 @@ class InstanceObject extends Instance {
 }
 class InstanceArray extends Instance {
   prepare() {
+    this.schemaItems = getSchemaItems(this.schema);
+    this.schemaPrefixItems = getSchemaPrefixItems(this.schema);
     const schemaMinItems = getSchemaMinItems(this.schema);
     const schemaEnforceMinItems = getSchemaXOption(this.schema, "enforceMinItems");
     const enforceMinItems = isSet(schemaEnforceMinItems) ? schemaEnforceMinItems : this.jedison.options.enforceMinItems;
@@ -2927,8 +2933,8 @@ class InstanceArray extends Instance {
   createItemInstance(index2) {
     let schema;
     const itemsCount = this.children.length;
-    const schemaItems = getSchemaItems(this.schema);
-    const schemaPrefixItems = getSchemaPrefixItems(this.schema);
+    const schemaItems = this.schemaItems;
+    const schemaPrefixItems = this.schemaPrefixItems;
     schema = isSet(schemaItems) ? schemaItems : {};
     const hasPrefixItemsSchema = isSet(schemaPrefixItems) && isSet(schemaPrefixItems[itemsCount]);
     if (hasPrefixItemsSchema) {
@@ -2952,10 +2958,11 @@ class InstanceArray extends Instance {
     }
   }
   move(fromIndex, toIndex, initiator) {
-    const value = clone(this.getValue());
-    if (!isArray(value)) {
+    const raw = this.getValueRaw();
+    if (!isArray(raw)) {
       return;
     }
+    const value = clone(raw);
     const item = value[fromIndex];
     value.splice(fromIndex, 1);
     value.splice(toIndex, 0, item);
@@ -2965,11 +2972,9 @@ class InstanceArray extends Instance {
   }
   addItem(initiator) {
     const tempEditor = this.createItemInstance();
-    let value = clone(this.getValue());
-    if (!isArray(value)) {
-      value = [];
-    }
-    value.push(tempEditor.getValue());
+    const raw = this.getValueRaw();
+    const value = isArray(raw) ? clone(raw) : [];
+    value.push(tempEditor.getValueRaw());
     tempEditor.destroy();
     this.setValue(value, true, initiator);
     const instance = this.children[this.children.length - 1];
@@ -2977,10 +2982,11 @@ class InstanceArray extends Instance {
     this.jedison.emit("item-add", initiator, instance);
   }
   deleteItem(itemIndex, initiator) {
-    const currentValue = clone(this.getValue());
-    if (!isArray(currentValue)) {
+    const raw = this.getValueRaw();
+    if (!isArray(raw)) {
       return;
     }
+    const currentValue = clone(raw);
     const newValue = currentValue.filter((item, index2) => index2 !== itemIndex);
     this.setValue(newValue, true, initiator);
     this.emit("item-delete", initiator);
@@ -2989,7 +2995,7 @@ class InstanceArray extends Instance {
   onChildChange(initiator) {
     const value = [];
     this.children.forEach((child) => {
-      value.push(child.getValue());
+      value.push(child.getValueRaw());
     });
     this.value = value;
     this.jedison.emit("instance-change", this, initiator);
@@ -2997,18 +3003,28 @@ class InstanceArray extends Instance {
     this.emit("notifyParent", initiator);
   }
   refreshChildren() {
-    this.children = [];
-    const value = this.getValue();
+    const value = this.getValueRaw();
     if (!isArray(value)) {
+      this.children = [];
       return;
     }
     const correctedValues = [];
-    value.forEach((itemValue, index2) => {
-      const child = this.createItemInstance(index2);
-      this.children.push(child);
-      const finalValue = child.setValue(itemValue, false);
-      correctedValues.push(finalValue);
-    });
+    for (let index2 = 0; index2 < value.length; index2++) {
+      if (index2 < this.children.length) {
+        const child = this.children[index2];
+        const finalValue = child.setValue(value[index2], false);
+        correctedValues.push(finalValue);
+      } else {
+        const child = this.createItemInstance(index2);
+        this.children.push(child);
+        const finalValue = child.setValue(value[index2], false);
+        correctedValues.push(finalValue);
+      }
+    }
+    while (this.children.length > value.length) {
+      const child = this.children.pop();
+      child.destroy();
+    }
     this.value = correctedValues;
   }
 }
@@ -3726,6 +3742,7 @@ class EditorObject extends Editor {
       } = this.theme.getPropertiesGroup();
       this.control.propertiesActivators.appendChild(defaultGroupContainer);
       const propertiesGroups = {};
+      const currentValue = this.instance.getValue();
       properties2.forEach((property) => {
         const isRequired = this.instance.isRequired(property);
         const ariaLive = this.control.ariaLive;
@@ -3773,7 +3790,7 @@ class EditorObject extends Editor {
           defaultGroup.appendChild(checkboxControl.container);
         }
         checkbox.disabled = this.disabled || isRequired;
-        checkbox.checked = hasOwn(this.instance.getValue(), property);
+        checkbox.checked = hasOwn(currentValue, property);
       });
     }
   }
@@ -5659,12 +5676,11 @@ class Jedison extends EventEmitter {
       });
     }
     this.on("instance-change", (instance) => {
-      for (const [path, callbacks] of Object.entries(this.watched)) {
-        if (instance.path === path) {
-          callbacks.forEach((callback) => {
-            callback();
-          });
-        }
+      const callbacks = this.watched[instance.path];
+      if (callbacks) {
+        callbacks.forEach((callback) => {
+          callback();
+        });
       }
     });
     if (this.hiddenInput) {