@axi-engine/fields 0.2.3 → 0.3.1

package/dist/index.mjs

@@ -142,13 +142,13 @@ function createTypedMethodsMixin(typeName, baseMethodName) {
   };
 }
 
-// src/field-definitions/default-field.ts
+// src/field-definitions/core-field.ts
 import { Emitter } from "@axi-engine/utils";
 import { dequal } from "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;
@@ -209,10 +209,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);
   }
@@ -222,10 +222,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);
   }
@@ -249,11 +249,11 @@ var DefaultStringField = class _DefaultStringField extends DefaultField {
   }
 };
 
-// src/field-definitions/default-numeric-field.ts
+// src/field-definitions/core-numeric-field.ts
 import { isNullOrUndefined } from "@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;
@@ -433,9 +433,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) {
@@ -475,34 +475,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
 import { Emitter as Emitter3, ensurePathArray, ensurePathString, throwIf as throwIf3, throwIfEmpty as throwIfEmpty2 } from "@axi-engine/utils";
 var FieldTree = class _FieldTree {
@@ -543,7 +515,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;
@@ -682,6 +654,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
@@ -733,21 +715,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);
   }
 };
 
@@ -968,6 +988,196 @@ var FieldTreeSerializer = class {
     return tree;
   }
 };
+
+// src/data-store-field-resolver.ts
+import { isBoolean, isNumber, isString as isString2 } from "@axi-engine/utils";
+var NumericFieldResolver = class {
+  typeName = CoreNumericField.typeName;
+  supports(value) {
+    return isNumber(value);
+  }
+};
+var BooleanFieldResolver = class {
+  typeName = CoreBooleanField.typeName;
+  supports(value) {
+    return isBoolean(value);
+  }
+};
+var StringFieldResolver = class {
+  typeName = CoreStringField.typeName;
+  supports(value) {
+    return isString2(value);
+  }
+};
+
+// src/data-store.ts
+import { ensurePathArray as ensurePathArray2, ensurePathString as ensurePathString2, throwIfEmpty as throwIfEmpty5 } from "@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 = ensurePathArray2(path);
+    throwIfEmpty5(pathArr, `Wrong path or path is empty: ${ensurePathString2(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 = ensurePathArray2(path);
+    throwIfEmpty5(pathArr, `Wrong path or path is empty: ${ensurePathString2(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 ensurePathArray2(path).length === 1;
+  }
+  getDestinationFields(path) {
+    const pathArr = ensurePathArray2(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 };
+}
 export {
   ClampMaxPolicy,
   ClampMaxPolicySerializerHandler,
@@ -975,13 +1185,15 @@ export {
   ClampMinPolicySerializerHandler,
   ClampPolicy,
   ClampPolicySerializerHandler,
-  DefaultBooleanField,
-  DefaultField,
-  DefaultFields,
-  DefaultFieldsFactory,
-  DefaultNumericField,
-  DefaultStringField,
-  DefaultTreeNodeFactory,
+  CoreBooleanField,
+  CoreField,
+  CoreFieldTree,
+  CoreFields,
+  CoreFieldsFactory,
+  CoreNumericField,
+  CoreStringField,
+  CoreTreeNodeFactory,
+  DataStore,
   FieldRegistry,
   FieldSerializer,
   FieldTree,
@@ -993,5 +1205,10 @@ export {
   clampMaxPolicy,
   clampMinPolicy,
   clampPolicy,
+  createCoreFieldRegistry,
+  createCoreFieldSystem,
+  createCorePolicySerializer,
+  createCoreTreeNodeFactory,
+  createCoreTreeSerializer,
   createTypedMethodsMixin
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axi-engine/fields",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "",
   "license": "MIT",
   "keywords": [
@@ -28,7 +28,12 @@
     "dist"
   ],
   "dependencies": {
-    "@axi-engine/utils": "^0.1.6",
     "dequal": "^2.0.3"
+  },
+  "devDependencies": {
+    "@axi-engine/utils": "^0.1.6"
+  },
+  "peerDependencies": {
+    "@axi-engine/utils": "^0.1.6"
   }
 }