@axi-engine/fields 0.2.3 → 0.3.1

package/dist/index.js

@@ -26,13 +26,15 @@ __export(index_exports, {
   ClampMinPolicySerializerHandler: () => ClampMinPolicySerializerHandler,
   ClampPolicy: () => ClampPolicy,
   ClampPolicySerializerHandler: () => ClampPolicySerializerHandler,
-  DefaultBooleanField: () => DefaultBooleanField,
-  DefaultField: () => DefaultField,
-  DefaultFields: () => DefaultFields,
-  DefaultFieldsFactory: () => DefaultFieldsFactory,
-  DefaultNumericField: () => DefaultNumericField,
-  DefaultStringField: () => DefaultStringField,
-  DefaultTreeNodeFactory: () => DefaultTreeNodeFactory,
+  CoreBooleanField: () => CoreBooleanField,
+  CoreField: () => CoreField,
+  CoreFieldTree: () => CoreFieldTree,
+  CoreFields: () => CoreFields,
+  CoreFieldsFactory: () => CoreFieldsFactory,
+  CoreNumericField: () => CoreNumericField,
+  CoreStringField: () => CoreStringField,
+  CoreTreeNodeFactory: () => CoreTreeNodeFactory,
+  DataStore: () => DataStore,
   FieldRegistry: () => FieldRegistry,
   FieldSerializer: () => FieldSerializer,
   FieldTree: () => FieldTree,
@@ -44,6 +46,11 @@ __export(index_exports, {
   clampMaxPolicy: () => clampMaxPolicy,
   clampMinPolicy: () => clampMinPolicy,
   clampPolicy: () => clampPolicy,
+  createCoreFieldRegistry: () => createCoreFieldRegistry,
+  createCoreFieldSystem: () => createCoreFieldSystem,
+  createCorePolicySerializer: () => createCorePolicySerializer,
+  createCoreTreeNodeFactory: () => createCoreTreeNodeFactory,
+  createCoreTreeSerializer: () => createCoreTreeSerializer,
   createTypedMethodsMixin: () => createTypedMethodsMixin
 });
 module.exports = __toCommonJS(index_exports);
@@ -192,13 +199,13 @@ function createTypedMethodsMixin(typeName, baseMethodName) {
   };
 }
 
-// src/field-definitions/default-field.ts
+// src/field-definitions/core-field.ts
 var import_utils = require("@axi-engine/utils");
 var import_dequal = require("dequal");
-var DefaultField = class _DefaultField {
+var CoreField = class _CoreField {
   /** A type keyword of the field */
   static typeName = "default";
-  typeName = _DefaultField.typeName;
+  typeName = _CoreField.typeName;
   /** A unique identifier for the field. */
   _name;
   _value;
@@ -259,10 +266,10 @@ var DefaultField = class _DefaultField {
   }
 };
 
-// src/field-definitions/default-boolean-field.ts
-var DefaultBooleanField = class _DefaultBooleanField extends DefaultField {
+// src/field-definitions/core-boolean-field.ts
+var CoreBooleanField = class _CoreBooleanField extends CoreField {
   static typeName = "boolean";
-  typeName = _DefaultBooleanField.typeName;
+  typeName = _CoreBooleanField.typeName;
   constructor(name, initialVal, options) {
     super(name, initialVal, options);
   }
@@ -272,10 +279,10 @@ var DefaultBooleanField = class _DefaultBooleanField extends DefaultField {
   }
 };
 
-// src/field-definitions/default-string-field.ts
-var DefaultStringField = class _DefaultStringField extends DefaultField {
+// src/field-definitions/core-string-field.ts
+var CoreStringField = class _CoreStringField extends CoreField {
   static typeName = "string";
-  typeName = _DefaultStringField.typeName;
+  typeName = _CoreStringField.typeName;
   constructor(name, initialVal, options) {
     super(name, initialVal, options);
   }
@@ -299,11 +306,11 @@ var DefaultStringField = class _DefaultStringField extends DefaultField {
   }
 };
 
-// src/field-definitions/default-numeric-field.ts
+// src/field-definitions/core-numeric-field.ts
 var import_utils2 = require("@axi-engine/utils");
-var DefaultNumericField = class _DefaultNumericField extends DefaultField {
+var CoreNumericField = class _CoreNumericField extends CoreField {
   static typeName = "numeric";
-  typeName = _DefaultNumericField.typeName;
+  typeName = _CoreNumericField.typeName;
   get min() {
     const policy = this.policies.get(ClampPolicy.id) ?? this.policies.get(ClampMinPolicy.id);
     return policy?.min;
@@ -483,9 +490,9 @@ var Fields = class _Fields {
   }
   /**
    * Retrieves a field by its name.
-   * @template T - The expected `Field` type to be returned.
+   * @template TField - The expected `Field` type to be returned.
    * @param {string} name - The name of the field to retrieve.
-   * @returns {T} The `Field` instance.
+   * @returns {TField} The `Field` instance.
    * @throws If the field does not exist.
    */
   get(name) {
@@ -525,34 +532,6 @@ var Fields = class _Fields {
   }
 };
 
-// src/mixins/with-boolean-fields.mixin.ts
-var WithBooleanFields = createTypedMethodsMixin(DefaultBooleanField.typeName, "Boolean");
-
-// src/mixins/with-string-fields.mixin.ts
-var WithStringFields = createTypedMethodsMixin(DefaultBooleanField.typeName, "String");
-
-// src/mixins/with-numeric-fields.mixin.ts
-var WithNumericFields = createTypedMethodsMixin(DefaultBooleanField.typeName, "Numeric");
-
-// src/mixins/with-default-generic-fields.mixin.ts
-function WithDefaultGenericFields(Base) {
-  return class FieldsWithDefaultGeneric extends Base {
-    createGeneric(name, initialValue, options) {
-      return this.create(DefaultField.typeName, name, initialValue, options);
-    }
-    upsetGeneric(name, value, options) {
-      return this.upset(DefaultField.typeName, name, value, options);
-    }
-    getGeneric(name) {
-      return this.get(name);
-    }
-  };
-}
-
-// src/default-fields.ts
-var DefaultFields = class extends WithBooleanFields(WithStringFields(WithNumericFields(WithDefaultGenericFields(Fields)))) {
-};
-
 // src/field-tree.ts
 var import_utils5 = require("@axi-engine/utils");
 var FieldTree = class _FieldTree {
@@ -593,7 +572,7 @@ var FieldTree = class _FieldTree {
   }
   /**
    * Creates an instance of FieldTree.
-   * @param {TreeNodeFactory} factory - A factory responsible for creating new nodes within the tree.
+   * @param {FieldTreeFactory} factory - A factory responsible for creating new nodes within the tree.
    */
   constructor(factory) {
     this._factory = factory;
@@ -732,6 +711,16 @@ var FieldTree = class _FieldTree {
     const traversedPath = this.traversePath(path, true);
     return traversedPath.branch.has(traversedPath.leafName) ? traversedPath.branch.getFields(traversedPath.leafName) : traversedPath.branch.createFields(traversedPath.leafName);
   }
+  /**
+   * Finds the parent node for a given path.
+   * @param path The path to the target node.
+   * @returns The parent node (either a FieldTree or Fields).
+   * @throws An error if the path is invalid or any intermediate node is not a FieldTree.
+   */
+  findParentNode(path) {
+    const info = this.traversePath(path);
+    return info.branch;
+  }
   /**
    * Removes all child nodes from this tree branch.
    * This method ensures that `destroy()` is called on each child node, allowing for
@@ -783,21 +772,59 @@ var FieldTree = class _FieldTree {
   }
 };
 
-// src/field-tree-node-factory.ts
-var DefaultFieldsFactory = class {
+// src/mixins/with-boolean-fields.mixin.ts
+var WithBooleanFields = createTypedMethodsMixin(CoreBooleanField.typeName, "Boolean");
+
+// src/mixins/with-string-fields.mixin.ts
+var WithStringFields = createTypedMethodsMixin(CoreBooleanField.typeName, "String");
+
+// src/mixins/with-numeric-fields.mixin.ts
+var WithNumericFields = createTypedMethodsMixin(CoreBooleanField.typeName, "Numeric");
+
+// src/mixins/with-default-generic-fields.mixin.ts
+function WithDefaultGenericFields(Base) {
+  return class FieldsWithDefaultGeneric extends Base {
+    createGeneric(name, initialValue, options) {
+      return this.create(CoreField.typeName, name, initialValue, options);
+    }
+    upsetGeneric(name, value, options) {
+      return this.upset(CoreField.typeName, name, value, options);
+    }
+    getGeneric(name) {
+      return this.get(name);
+    }
+  };
+}
+
+// src/core-fields.ts
+var CoreFields = class extends WithBooleanFields(WithStringFields(WithNumericFields(WithDefaultGenericFields(Fields)))) {
+};
+
+// src/core-fields-factory.ts
+var CoreFieldsFactory = class {
+  _fieldRegistry;
+  get fieldRegistry() {
+    return this._fieldRegistry;
+  }
   constructor(fieldRegistry) {
-    this.fieldRegistry = fieldRegistry;
+    this._fieldRegistry = fieldRegistry;
   }
   fields() {
-    return new DefaultFields(this.fieldRegistry);
+    return new CoreFields(this._fieldRegistry);
   }
 };
-var DefaultTreeNodeFactory = class extends DefaultFieldsFactory {
+
+// src/core-field-tree.ts
+var CoreFieldTree = class extends FieldTree {
+};
+
+// src/core-field-tree-factory.ts
+var CoreTreeNodeFactory = class extends CoreFieldsFactory {
   constructor(fieldRegistry) {
     super(fieldRegistry);
   }
   tree() {
-    return new FieldTree(this);
+    return new CoreFieldTree(this);
   }
 };
 
@@ -1018,6 +1045,196 @@ var FieldTreeSerializer = class {
     return tree;
   }
 };
+
+// src/data-store-field-resolver.ts
+var import_utils9 = require("@axi-engine/utils");
+var NumericFieldResolver = class {
+  typeName = CoreNumericField.typeName;
+  supports(value) {
+    return (0, import_utils9.isNumber)(value);
+  }
+};
+var BooleanFieldResolver = class {
+  typeName = CoreBooleanField.typeName;
+  supports(value) {
+    return (0, import_utils9.isBoolean)(value);
+  }
+};
+var StringFieldResolver = class {
+  typeName = CoreStringField.typeName;
+  supports(value) {
+    return (0, import_utils9.isString)(value);
+  }
+};
+
+// src/data-store.ts
+var import_utils10 = require("@axi-engine/utils");
+var DataStore = class {
+  constructor(tree) {
+    this.tree = tree;
+    this.registerResolver(new NumericFieldResolver());
+    this.registerResolver(new BooleanFieldResolver());
+    this.registerResolver(new StringFieldResolver());
+  }
+  resolvers = [];
+  rootFieldsName = "__root_fields";
+  _rootFields;
+  get rootFields() {
+    if (!this._rootFields) {
+      this._rootFields = this.tree.getOrCreateFields(this.rootFieldsName);
+    }
+    return this._rootFields;
+  }
+  registerResolver(resolver) {
+    this.resolvers.unshift(resolver);
+  }
+  clearResolvers() {
+    this.resolvers.length = 0;
+  }
+  getValue(path) {
+    return this.getField(path).value;
+  }
+  setValue(path, val) {
+    const field = this.getField(path);
+    field.value = val;
+    return field.value;
+  }
+  createValue(path, val, options) {
+    const dest = this.getDestinationFields(path);
+    if (options?.fieldType) {
+      return dest.fields.create(options.fieldType, dest.leafName, val, options).value;
+    }
+    for (let resolver of this.resolvers) {
+      if (resolver.supports(val)) {
+        return dest.fields.create(resolver.typeName, dest.leafName, val, options).value;
+      }
+    }
+    return dest.fields.createGeneric(dest.leafName, val, options).value;
+  }
+  upsetValue(path, val, options) {
+    const dest = this.getDestinationFields(path);
+    if (options?.fieldType) {
+      return dest.fields.upset(options.fieldType, dest.leafName, val, options).value;
+    }
+    for (let resolver of this.resolvers) {
+      if (resolver.supports(val)) {
+        return dest.fields.upset(resolver.typeName, dest.leafName, val, options).value;
+      }
+    }
+    return dest.fields.upsetGeneric(dest.leafName, val, options).value;
+  }
+  createBoolean(path, initialValue, options) {
+    const dest = this.getDestinationFields(path);
+    return dest.fields.createBoolean(dest.leafName, initialValue, options);
+  }
+  createNumeric(path, initialValue, options) {
+    const dest = this.getDestinationFields(path);
+    return dest.fields.createNumeric(dest.leafName, initialValue, options);
+  }
+  createString(path, initialValue, options) {
+    const dest = this.getDestinationFields(path);
+    return dest.fields.createString(dest.leafName, initialValue, options);
+  }
+  createGeneric(path, initialValue, options) {
+    const dest = this.getDestinationFields(path);
+    return dest.fields.createGeneric(dest.leafName, initialValue, options);
+  }
+  getBoolean(path) {
+    return this.getField(path);
+  }
+  getNumeric(path) {
+    return this.getField(path);
+  }
+  getString(path) {
+    return this.getField(path);
+  }
+  getGeneric(path) {
+    return this.getField(path);
+  }
+  getField(path) {
+    const pathArr = (0, import_utils10.ensurePathArray)(path);
+    (0, import_utils10.throwIfEmpty)(pathArr, `Wrong path or path is empty: ${(0, import_utils10.ensurePathString)(path)}, should contain at least one path segment`);
+    if (this.isPathToRootFields(pathArr)) {
+      return this.rootFields.get(pathArr[0]);
+    }
+    const fieldName = pathArr.pop();
+    const fields = this.tree.getFields(pathArr);
+    return fields.get(fieldName);
+  }
+  createFields(path) {
+    return this.tree.createFields(path, true);
+  }
+  createTree(path) {
+    return this.tree.createFieldTree(path, true);
+  }
+  getFields(path) {
+    return this.tree.getFields(path);
+  }
+  getTree(path) {
+    return this.tree.getFieldTree(path);
+  }
+  remove(path) {
+    const pathArr = (0, import_utils10.ensurePathArray)(path);
+    (0, import_utils10.throwIfEmpty)(pathArr, `Wrong path or path is empty: ${(0, import_utils10.ensurePathString)(path)}, should contain at least one path segment`);
+    if (this.isPathToRootFields(pathArr)) {
+      this.rootFields.remove(pathArr);
+      return;
+    }
+    const node = this.tree.findParentNode(pathArr);
+    const leafName = pathArr[pathArr.length - 1];
+    if (node instanceof CoreFields) {
+      node.remove(leafName);
+    } else if (node instanceof CoreFieldTree) {
+      node.removeNode(leafName);
+    }
+  }
+  isPathToRootFields(path) {
+    return (0, import_utils10.ensurePathArray)(path).length === 1;
+  }
+  getDestinationFields(path) {
+    const pathArr = (0, import_utils10.ensurePathArray)(path);
+    if (this.isPathToRootFields(pathArr)) {
+      return { fields: this.rootFields, leafName: pathArr[0] };
+    }
+    const leafName = pathArr.pop();
+    return { fields: this.tree.getOrCreateFields(path), leafName };
+  }
+};
+
+// src/setup.ts
+function createCoreFieldRegistry() {
+  const fieldRegistry = new FieldRegistry();
+  fieldRegistry.register(CoreField.typeName, CoreField);
+  fieldRegistry.register(CoreNumericField.typeName, CoreNumericField);
+  fieldRegistry.register(CoreStringField.typeName, CoreStringField);
+  fieldRegistry.register(CoreBooleanField.typeName, CoreBooleanField);
+  return fieldRegistry;
+}
+function createCorePolicySerializer() {
+  const policySerializer = new PolicySerializer();
+  policySerializer.register(ClampPolicy.id, new ClampPolicySerializerHandler());
+  policySerializer.register(ClampMinPolicy.id, new ClampMinPolicySerializerHandler());
+  policySerializer.register(ClampMaxPolicy.id, new ClampMaxPolicySerializerHandler());
+  return policySerializer;
+}
+function createCoreTreeNodeFactory(fieldRegistry) {
+  return new CoreTreeNodeFactory(fieldRegistry);
+}
+function createCoreTreeSerializer(fieldTreeNodeFactory, policySerializer) {
+  return new FieldTreeSerializer(
+    fieldTreeNodeFactory,
+    new FieldsSerializer(
+      fieldTreeNodeFactory,
+      new FieldSerializer(fieldTreeNodeFactory.fieldRegistry, policySerializer ?? createCorePolicySerializer())
+    )
+  );
+}
+function createCoreFieldSystem(config) {
+  const registry = config?.registry ?? createCoreFieldRegistry();
+  const factory = createCoreTreeNodeFactory(registry);
+  const serializer = createCoreTreeSerializer(factory, config?.policySerializer);
+  return { factory, serializer };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ClampMaxPolicy,
@@ -1026,13 +1243,15 @@ var FieldTreeSerializer = class {
   ClampMinPolicySerializerHandler,
   ClampPolicy,
   ClampPolicySerializerHandler,
-  DefaultBooleanField,
-  DefaultField,
-  DefaultFields,
-  DefaultFieldsFactory,
-  DefaultNumericField,
-  DefaultStringField,
-  DefaultTreeNodeFactory,
+  CoreBooleanField,
+  CoreField,
+  CoreFieldTree,
+  CoreFields,
+  CoreFieldsFactory,
+  CoreNumericField,
+  CoreStringField,
+  CoreTreeNodeFactory,
+  DataStore,
   FieldRegistry,
   FieldSerializer,
   FieldTree,
@@ -1044,5 +1263,10 @@ var FieldTreeSerializer = class {
   clampMaxPolicy,
   clampMinPolicy,
   clampPolicy,
+  createCoreFieldRegistry,
+  createCoreFieldSystem,
+  createCorePolicySerializer,
+  createCoreTreeNodeFactory,
+  createCoreTreeSerializer,
   createTypedMethodsMixin
 });