@revisium/schema-toolkit 0.20.2 → 0.21.1

package/dist/{chunk-U5YDA3LA.js → chunk-HFMZITNE.js}

@@ -1,7 +1,8 @@
-import { AbstractBasePath, EMPTY_PATH, FormulaError, ResolvedDependency, FormulaSerializer, createRefNode, createObjectNode, createArrayNode, createStringNode, createNumberNode, createBooleanNode, observable, makeObservable, makeAutoObservable, runInAction, PatchBuilder, SchemaSerializer, createSchemaTree, NULL_NODE, validateSchema, validateFormulas, reaction } from './chunk-3JZKQWQH.js';
-import { obj, ref } from './chunk-R4CFU33U.js';
+import { AbstractBasePath, EMPTY_PATH, FormulaError, ResolvedDependency, FormulaSerializer, createRefNode, createObjectNode, createArrayNode, createStringNode, createNumberNode, createBooleanNode, observable, makeObservable, makeAutoObservable, runInAction, PatchBuilder, SchemaSerializer, createSchemaTree, NULL_NODE, validateSchema, validateFormulas, reaction } from './chunk-AWFMSOHM.js';
+import { obj, ref } from './chunk-IZMBM36H.js';
 import { nanoid } from 'nanoid';
 import { parseFormula, parseExpression, evaluateWithContext } from '@revisium/formula';
+import { EventEmitter } from 'eventemitter3';
 
 var ARRAY_NOTATION_REGEX = /^([^[]+)\[(?:\d+|\*)?\]$/;
 var FormulaPath = class {
@@ -343,15 +344,15 @@ var SchemaParser = class {
     }
     const schemaWithType = schema;
     switch (schemaWithType.type) {
-      case "object" /* Object */:
+      case "object":
         return this.parseObject(schemaWithType, name, parentRef);
-      case "array" /* Array */:
+      case "array":
         return this.parseArray(schemaWithType, name, parentRef);
-      case "string" /* String */:
+      case "string":
         return this.parseString(schemaWithType, name, parentRef);
-      case "number" /* Number */:
+      case "number":
         return this.parseNumber(schemaWithType, name, parentRef);
-      case "boolean" /* Boolean */:
+      case "boolean":
         return this.parseBoolean(schemaWithType, name, parentRef);
       default:
         throw new Error(`Unknown schema type: ${schemaWithType.type}`);
@@ -462,10 +463,10 @@ function isRefSchema(schema) {
   return "$ref" in schema;
 }
 function isObjectSchema(schema) {
-  return "type" in schema && schema.type === "object" /* Object */;
+  return "type" in schema && schema.type === "object";
 }
 function isArraySchema(schema) {
-  return "type" in schema && schema.type === "array" /* Array */;
+  return "type" in schema && schema.type === "array";
 }
 function hasDefaultValue(schema) {
   return "default" in schema && schema.default !== void 0;
@@ -475,11 +476,11 @@ function generatePrimitiveDefault(schema) {
     return void 0;
   }
   switch (schema.type) {
-    case "string" /* String */:
+    case "string":
       return DEFAULT_STRING;
-    case "number" /* Number */:
+    case "number":
       return DEFAULT_NUMBER;
-    case "boolean" /* Boolean */:
+    case "boolean":
       return DEFAULT_BOOLEAN;
     default:
       return void 0;
@@ -1598,8 +1599,6 @@ var FormulaEngine = class {
     this.disposers = [];
   }
 };
-
-// src/model/value-node/BaseValueNode.ts
 var nodeIdCounter = 0;
 function generateNodeId() {
   return `node-${++nodeIdCounter}`;
@@ -1612,11 +1611,21 @@ var BaseValueNode = class {
   schema;
   _parent = null;
   _name;
+  _emitter = new EventEmitter();
   constructor(id, name, schema) {
     this.id = id ?? generateNodeId();
     this._name = name;
     this.schema = schema;
   }
+  on(event, listener) {
+    this._emitter.on(event, listener);
+  }
+  off(event, listener) {
+    this._emitter.off(event, listener);
+  }
+  emit(changeEvent) {
+    this._emitter.emit("change", changeEvent);
+  }
   get parent() {
     return this._parent;
   }
@@ -1700,7 +1709,8 @@ var ArrayValueNode = class extends BaseValueNode {
       commit: "action",
       revert: "action",
       pushValue: "action",
-      insertValueAt: "action"
+      insertValueAt: "action",
+      setValue: "action"
     });
   }
   get value() {
@@ -1721,6 +1731,7 @@ var ArrayValueNode = class extends BaseValueNode {
   push(node) {
     node.parent = this;
     this._items.push(node);
+    this.emit({ type: "arrayPush", array: this, item: node });
   }
   insertAt(index, node) {
     if (index < 0 || index > this._items.length) {
@@ -1728,6 +1739,7 @@ var ArrayValueNode = class extends BaseValueNode {
     }
     node.parent = this;
     this._items.splice(index, 0, node);
+    this.emit({ type: "arrayInsert", array: this, index, item: node });
   }
   removeAt(index) {
     if (index < 0 || index >= this._items.length) {
@@ -1737,6 +1749,7 @@ var ArrayValueNode = class extends BaseValueNode {
     if (removed) {
       removed.parent = null;
     }
+    this.emit({ type: "arrayRemove", array: this, index, item: removed });
   }
   move(fromIndex, toIndex) {
     if (fromIndex < 0 || fromIndex >= this._items.length) {
@@ -1752,23 +1765,25 @@ var ArrayValueNode = class extends BaseValueNode {
     if (item) {
       this._items.splice(toIndex, 0, item);
     }
+    this.emit({ type: "arrayMove", array: this, fromIndex, toIndex });
   }
   replaceAt(index, node) {
     if (index < 0 || index >= this._items.length) {
       throw new Error(`Index out of bounds: ${index}`);
     }
     const oldNode = this._items[index];
-    if (oldNode) {
-      oldNode.parent = null;
-    }
+    oldNode.parent = null;
     node.parent = this;
     this._items[index] = node;
+    this.emit({ type: "arrayReplace", array: this, index, item: node, oldItem: oldNode });
   }
   clear() {
-    for (const item of this._items) {
+    const removed = [...this._items];
+    for (const item of removed) {
       item.parent = null;
     }
     this._items.length = 0;
+    this.emit({ type: "arrayClear", array: this, items: removed });
   }
   setNodeFactory(factory) {
     this._nodeFactory = factory;
@@ -1781,6 +1796,32 @@ var ArrayValueNode = class extends BaseValueNode {
     const node = this.createItemNode(index, value);
     this.insertAt(index, node);
   }
+  setValue(value, options) {
+    const commonLength = Math.min(this._items.length, value.length);
+    for (let i = 0; i < commonLength; i++) {
+      const item = this._items[i];
+      if (!item) {
+        continue;
+      }
+      const itemValue = value[i];
+      if (item.isObject()) {
+        item.setValue(itemValue, options);
+      } else if (item.isArray()) {
+        item.setValue(itemValue, options);
+      } else if (item.isPrimitive()) {
+        item.setValue(itemValue, options);
+      }
+    }
+    if (value.length > this._items.length) {
+      for (let i = this._items.length; i < value.length; i++) {
+        this.pushValue(value[i]);
+      }
+    } else if (value.length < this._items.length) {
+      for (let i = this._items.length - 1; i >= value.length; i--) {
+        this.removeAt(i);
+      }
+    }
+  }
   createItemNode(index, value) {
     if (!this._nodeFactory) {
       throw new Error("NodeFactory not set");
@@ -1909,6 +1950,9 @@ var BasePrimitiveValueNode = class extends BaseValueNode {
     return this._baseValue;
   }
   get isDirty() {
+    if (this.formula !== void 0) {
+      return false;
+    }
     return this._value !== this._baseValue;
   }
   get formula() {
@@ -1928,7 +1972,11 @@ var BasePrimitiveValueNode = class extends BaseValueNode {
     if (this.isReadOnly && !options?.internal) {
       throw new Error(`Cannot set value on read-only field: ${this.name}`);
     }
+    const oldValue = this._value;
     this._value = this.coerceValue(value);
+    if (!options?.internal) {
+      this.emit({ type: "setValue", node: this, value: this._value, oldValue });
+    }
   }
   setFormulaWarning(warning) {
     this._formulaWarning = warning;
@@ -2184,7 +2232,7 @@ var NumberValueNode = class extends BasePrimitiveValueNode {
   }
   computeErrors() {
     const errors = [];
-    if (!("type" in this.schema) || this.schema.type !== "number" /* Number */) {
+    if (!("type" in this.schema) || this.schema.type !== "number") {
       return errors;
     }
     const numberSchema = this.schema;
@@ -2248,6 +2296,7 @@ var ObjectValueNode = class extends BaseValueNode {
       warnings: "computed",
       addChild: "action",
       removeChild: "action",
+      setValue: "action",
       commit: "action",
       revert: "action"
     });
@@ -2278,12 +2327,29 @@ var ObjectValueNode = class extends BaseValueNode {
     }
     node.parent = this;
     this._children.set(node.name, node);
+    this.emit({ type: "addChild", parent: this, child: node });
   }
   removeChild(name) {
     const node = this._children.get(name);
     if (node) {
       node.parent = null;
       this._children.delete(name);
+      this.emit({ type: "removeChild", parent: this, childName: name, child: node });
+    }
+  }
+  setValue(value, options) {
+    for (const [key, child] of this._children) {
+      if (!(key in value)) {
+        continue;
+      }
+      const childValue = value[key];
+      if (child.isObject()) {
+        child.setValue(childValue, options);
+      } else if (child.isArray()) {
+        child.setValue(childValue, options);
+      } else if (child.isPrimitive()) {
+        child.setValue(childValue, options);
+      }
     }
   }
   get isDirty() {
@@ -2794,16 +2860,22 @@ var ValueTree = class {
     this._root = _root;
     this.index = new TreeIndex(_root);
     this.changeTracker = new ChangeTracker();
+    this._nodeChangeListener = (event) => this.handleNodeChange(event);
+    this.subscribe(this._root);
     makeAutoObservable(this, {
       _root: false,
       index: false,
       changeTracker: false,
-      _formulaEngine: false
+      _nodeChangeListener: false,
+      _formulaEngine: false,
+      _suppressEvents: false
     });
   }
   index;
   changeTracker;
+  _nodeChangeListener;
   _formulaEngine = null;
+  _suppressEvents = false;
   get root() {
     return this._root;
   }
@@ -2841,20 +2913,28 @@ var ValueTree = class {
     const node = this.get(path);
     return node?.getPlainValue();
   }
-  setValue(path, value) {
+  setValue(path, value, options) {
     const node = this.get(path);
     if (!node) {
       throw new Error(`Path not found: ${path}`);
     }
-    if (!node.isPrimitive()) {
-      throw new Error(`Cannot set value on non-primitive node: ${path}`);
+    const oldValue = node.getPlainValue();
+    this._suppressEvents = true;
+    try {
+      if (node.isPrimitive()) {
+        node.setValue(value, options);
+      } else if (node.isObject()) {
+        node.setValue(value, options);
+      } else if (node.isArray()) {
+        node.setValue(value, options);
+      }
+    } finally {
+      this._suppressEvents = false;
     }
-    const oldValue = node.value;
-    node.setValue(value);
     this.changeTracker.track({
       type: "setValue",
       path: this.index.pathOf(node),
-      value,
+      value: node.getPlainValue(),
       oldValue
     });
   }
@@ -2888,11 +2968,13 @@ var ValueTree = class {
     this.changeTracker.clear();
   }
   revert() {
+    this.unsubscribe(this._root);
     const root = this._root;
     if ("revert" in root && typeof root.revert === "function") {
       root.revert();
     }
     this.changeTracker.clear();
+    this.subscribe(this._root);
   }
   rebuildIndex() {
     this.index.rebuild();
@@ -2910,9 +2992,126 @@ var ValueTree = class {
     return this._formulaEngine;
   }
   dispose() {
+    this.unsubscribe(this._root);
     this._formulaEngine?.dispose();
     this._formulaEngine = null;
   }
+  handleNodeChange(event) {
+    if (this._suppressEvents) {
+      return;
+    }
+    switch (event.type) {
+      case "setValue": {
+        this.changeTracker.track({
+          type: "setValue",
+          path: this.index.pathOf(event.node),
+          value: event.value,
+          oldValue: event.oldValue
+        });
+        break;
+      }
+      case "addChild": {
+        this.adoptNode(event.child);
+        this.changeTracker.track({
+          type: "addProperty",
+          path: this.index.pathOf(event.parent).child(event.child.name),
+          value: event.child.getPlainValue()
+        });
+        break;
+      }
+      case "removeChild": {
+        this.unsubscribe(event.child);
+        this.changeTracker.track({
+          type: "removeProperty",
+          path: this.index.pathOf(event.parent).child(event.childName)
+        });
+        break;
+      }
+      case "arrayPush":
+      case "arrayInsert": {
+        this.adoptNode(event.item);
+        this.index.invalidatePathsUnder(event.array);
+        this.changeTracker.track(
+          this.toArrayItemChange(event)
+        );
+        break;
+      }
+      case "arrayReplace": {
+        this.unsubscribe(event.oldItem);
+        this.adoptNode(event.item);
+        this.index.invalidatePathsUnder(event.array);
+        this.changeTracker.track({
+          type: "arrayReplace",
+          path: this.index.pathOf(event.array),
+          index: event.index,
+          value: event.item.getPlainValue()
+        });
+        break;
+      }
+      case "arrayRemove": {
+        this.unsubscribe(event.item);
+        this.index.invalidatePathsUnder(event.array);
+        this.changeTracker.track(
+          this.toArrayStructureChange(event)
+        );
+        break;
+      }
+      case "arrayMove": {
+        this.index.invalidatePathsUnder(event.array);
+        this.changeTracker.track(
+          this.toArrayStructureChange(event)
+        );
+        break;
+      }
+      case "arrayClear": {
+        for (const item of event.items) {
+          this.unsubscribe(item);
+        }
+        this.changeTracker.track({
+          type: "arrayClear",
+          path: this.index.pathOf(event.array)
+        });
+        break;
+      }
+    }
+  }
+  toArrayItemChange(event) {
+    const path = this.index.pathOf(event.array);
+    const value = event.item.getPlainValue();
+    if (event.type === "arrayPush") {
+      return { type: "arrayPush", path, value };
+    }
+    return { type: "arrayInsert", path, index: event.index, value };
+  }
+  toArrayStructureChange(event) {
+    const path = this.index.pathOf(event.array);
+    if (event.type === "arrayRemove") {
+      return { type: "arrayRemove", path, index: event.index };
+    }
+    return { type: "arrayMove", path, fromIndex: event.fromIndex, toIndex: event.toIndex };
+  }
+  adoptNode(node) {
+    this.subscribe(node);
+    this.index.registerNode(node);
+  }
+  walkTree(node, visit) {
+    visit(node);
+    if (node.isObject()) {
+      for (const child of node.children) {
+        this.walkTree(child, visit);
+      }
+    } else if (node.isArray()) {
+      for (const item of node.value) {
+        this.walkTree(item, visit);
+      }
+    }
+  }
+  subscribe(node) {
+    this.walkTree(node, (n) => n.on("change", this._nodeChangeListener));
+  }
+  unsubscribe(node) {
+    this.walkTree(node, (n) => n.off("change", this._nodeChangeListener));
+  }
 };
 
 // src/model/table/row/RowModelImpl.ts
@@ -3443,7 +3642,7 @@ var ForeignKeyResolverImpl = class {
     return foreignKeys;
   }
   getForeignKeyFromSchema(schema) {
-    if ("type" in schema && schema.type === "string" /* String */) {
+    if ("type" in schema && schema.type === "string") {
       return schema.foreignKey;
     }
     return void 0;
@@ -3547,6 +3746,14 @@ function createDataModel(options) {
   return new DataModelImpl(options);
 }
 
-export { ArrayToItemsTypeTransformer, ArrayValueNode, BasePrimitiveValueNode, BaseValueNode, BooleanValueNode, DataModelImpl, DefaultTransformer, ForeignKeyNotFoundError, ForeignKeyResolverImpl, ForeignKeyResolverNotConfiguredError, ForeignKeyValueNodeImpl, FormulaChangeDetector, FormulaDependencyIndex, FormulaPath, NodeFactory, NodeFactory2, NodeFactoryRegistry, NumberValueNode, ObjectToArrayTransformer, ObjectValueNode, ParsedFormula, PrimitiveToArrayTransformer, RefTransformer, RowModelImpl, SchemaParser, StringValueNode, TableModelImpl, TypeTransformChain, ValueType, createDataModel, createDefaultRegistry, createForeignKeyResolver, createNodeFactory, createRowModel, createSchemaModel, createTableModel, createTypeTransformChain, extractFormulaDefinition, generateDefaultValue, generateNodeId, isForeignKeyValueNode, resetNodeIdCounter };
-//# sourceMappingURL=chunk-U5YDA3LA.js.map
-//# sourceMappingURL=chunk-U5YDA3LA.js.map
+// src/model/value-tree/typed.ts
+function typedNode(node) {
+  return node;
+}
+function createTypedTree(schema, data, options) {
+  const factory = createNodeFactory(options);
+  const root = factory.createTree(schema, data);
+  return new ValueTree(root);
+}
+
+export { ArrayToItemsTypeTransformer, ArrayValueNode, BasePrimitiveValueNode, BaseValueNode, BooleanValueNode, DataModelImpl, DefaultTransformer, ForeignKeyNotFoundError, ForeignKeyResolverImpl, ForeignKeyResolverNotConfiguredError, ForeignKeyValueNodeImpl, FormulaChangeDetector, FormulaDependencyIndex, FormulaPath, NodeFactory, NodeFactory2, NodeFactoryRegistry, NumberValueNode, ObjectToArrayTransformer, ObjectValueNode, ParsedFormula, PrimitiveToArrayTransformer, RefTransformer, RowModelImpl, SchemaParser, StringValueNode, TableModelImpl, TypeTransformChain, ValueTree, ValueType, createDataModel, createDefaultRegistry, createForeignKeyResolver, createNodeFactory, createRowModel, createSchemaModel, createTableModel, createTypeTransformChain, createTypedTree, extractFormulaDefinition, generateDefaultValue, generateNodeId, isForeignKeyValueNode, resetNodeIdCounter, typedNode };

package/dist/{chunk-EGC32GPY.cjs → chunk-ITYABUR5.cjs}

@@ -2,7 +2,7 @@
 
 // src/plugins/row-id.schema.ts
 var rowIdSchema = {
-  type: "string" /* String */,
+  type: "string",
   default: "",
   readOnly: true
 };
@@ -13,7 +13,7 @@ var ajvRowIdSchema = {
 
 // src/plugins/row-version-id.schema.ts
 var rowVersionIdSchema = {
-  type: "string" /* String */,
+  type: "string",
   default: "",
   readOnly: true
 };
@@ -24,7 +24,7 @@ var ajvRowVersionIdSchema = {
 
 // src/plugins/row-created-id.schema.ts
 var rowCreatedIdSchema = {
-  type: "string" /* String */,
+  type: "string",
   default: "",
   readOnly: true
 };
@@ -35,7 +35,7 @@ var ajvRowCreatedIdSchema = {
 
 // src/plugins/row-created-at.schema.ts
 var rowCreatedAtSchema = {
-  type: "string" /* String */,
+  type: "string",
   default: "",
   readOnly: true
 };
@@ -46,7 +46,7 @@ var ajvRowCreatedAtSchema = {
 
 // src/plugins/row-published-at.schema.ts
 var rowPublishedAtSchema = {
-  type: "string" /* String */,
+  type: "string",
   default: ""
 };
 var ajvRowPublishedAtSchema = {
@@ -56,7 +56,7 @@ var ajvRowPublishedAtSchema = {
 
 // src/plugins/row-updated-at.schema.ts
 var rowUpdatedAtSchema = {
-  type: "string" /* String */,
+  type: "string",
   default: "",
   readOnly: true
 };
@@ -67,7 +67,7 @@ var ajvRowUpdatedAtSchema = {
 
 // src/plugins/row-hash.schema.ts
 var rowHashSchema = {
-  type: "string" /* String */,
+  type: "string",
   default: "",
   readOnly: true
 };
@@ -78,7 +78,7 @@ var ajvRowHashSchema = {
 
 // src/plugins/row-schema-hash.schema.ts
 var rowSchemaHashSchema = {
-  type: "string" /* String */,
+  type: "string",
   default: "",
   readOnly: true
 };
@@ -89,39 +89,39 @@ var ajvRowSchemaHashSchema = {
 
 // src/plugins/file-schema.ts
 var fileSchema = {
-  type: "object" /* Object */,
+  type: "object",
   properties: {
-    status: { type: "string" /* String */, default: "", readOnly: true },
-    fileId: { type: "string" /* String */, default: "", readOnly: true },
-    url: { type: "string" /* String */, default: "", readOnly: true },
-    fileName: { type: "string" /* String */, default: "" },
+    status: { type: "string", default: "", readOnly: true },
+    fileId: { type: "string", default: "", readOnly: true },
+    url: { type: "string", default: "", readOnly: true },
+    fileName: { type: "string", default: "" },
     hash: {
-      type: "string" /* String */,
+      type: "string",
       default: "",
       readOnly: true
     },
     extension: {
-      type: "string" /* String */,
+      type: "string",
       default: "",
       readOnly: true
     },
     mimeType: {
-      type: "string" /* String */,
+      type: "string",
       default: "",
       readOnly: true
     },
     size: {
-      type: "number" /* Number */,
+      type: "number",
       default: 0,
       readOnly: true
     },
     width: {
-      type: "number" /* Number */,
+      type: "number",
       default: 0,
       readOnly: true
     },
     height: {
-      type: "number" /* Number */,
+      type: "number",
       default: 0,
       readOnly: true
     }
@@ -163,5 +163,3 @@ exports.rowPublishedAtSchema = rowPublishedAtSchema;
 exports.rowSchemaHashSchema = rowSchemaHashSchema;
 exports.rowUpdatedAtSchema = rowUpdatedAtSchema;
 exports.rowVersionIdSchema = rowVersionIdSchema;
-//# sourceMappingURL=chunk-EGC32GPY.cjs.map
-//# sourceMappingURL=chunk-EGC32GPY.cjs.map

package/dist/{chunk-R4CFU33U.js → chunk-IZMBM36H.js}

@@ -1,4 +1,4 @@
-// src/mocks/schema.mocks.ts
+// src/lib/schema-helpers.ts
 var getReplacePatch = ({
   path,
   value
@@ -36,7 +36,7 @@ var buildFormula = (expression) => ({
 var getStringSchema = (params = {}) => {
   const { formula, ...rest } = params;
   return {
-    type: "string" /* String */,
+    type: "string",
     ...rest,
     default: rest.default ?? "",
     ...formula && { "x-formula": buildFormula(formula) }
@@ -45,7 +45,7 @@ var getStringSchema = (params = {}) => {
 var getNumberSchema = (params = {}) => {
   const { formula, ...rest } = params;
   return {
-    type: "number" /* Number */,
+    type: "number",
     ...rest,
     default: rest.default ?? 0,
     ...formula && { "x-formula": buildFormula(formula) }
@@ -54,21 +54,21 @@ var getNumberSchema = (params = {}) => {
 var getBooleanSchema = (params = {}) => {
   const { formula, ...rest } = params;
   return {
-    type: "boolean" /* Boolean */,
+    type: "boolean",
     ...rest,
     default: rest.default ?? false,
     ...formula && { "x-formula": buildFormula(formula) }
   };
 };
 var getObjectSchema = (properties, options = {}) => ({
-  type: "object" /* Object */,
+  type: "object",
   additionalProperties: false,
   required: Object.keys(properties).sort((a, b) => a.localeCompare(b)),
   properties,
   ...options
 });
 var getArraySchema = (items, options = {}) => ({
-  type: "array" /* Array */,
+  type: "array",
   items,
   ...options
 });
@@ -79,10 +79,11 @@ var getRefSchema = ($ref, options = {}) => ({
 var str = (params = {}) => getStringSchema(params);
 var num = (params = {}) => getNumberSchema(params);
 var bool = (params = {}) => getBooleanSchema(params);
+var strFormula = (formula, params = {}) => getStringSchema({ ...params, formula, readOnly: true });
+var numFormula = (formula, params = {}) => getNumberSchema({ ...params, formula, readOnly: true });
+var boolFormula = (formula, params = {}) => getBooleanSchema({ ...params, formula, readOnly: true });
 var obj = (properties, options) => getObjectSchema(properties, options);
 var arr = (items, options) => getArraySchema(items, options);
 var ref = ($ref, options) => getRefSchema($ref, options);
 
-export { arr, bool, getAddPatch, getArraySchema, getBooleanSchema, getMovePatch, getNumberSchema, getObjectSchema, getRefSchema, getRemovePatch, getReplacePatch, getStringSchema, num, obj, ref, str };
-//# sourceMappingURL=chunk-R4CFU33U.js.map
-//# sourceMappingURL=chunk-R4CFU33U.js.map
+export { arr, bool, boolFormula, getAddPatch, getArraySchema, getBooleanSchema, getMovePatch, getNumberSchema, getObjectSchema, getRefSchema, getRemovePatch, getReplacePatch, getStringSchema, num, numFormula, obj, ref, str, strFormula };

package/dist/chunk-J4RVO37K.cjs

@@ -0,0 +1,2 @@
+'use strict';
+