@axi-engine/fields 0.3.2 → 0.3.4

package/dist/index.js

@@ -1,1228 +1,18 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  ClampMaxPolicy: () => ClampMaxPolicy,
-  ClampMaxPolicySerializerHandler: () => ClampMaxPolicySerializerHandler,
-  ClampMinPolicy: () => ClampMinPolicy,
-  ClampMinPolicySerializerHandler: () => ClampMinPolicySerializerHandler,
-  ClampPolicy: () => ClampPolicy,
-  ClampPolicySerializerHandler: () => ClampPolicySerializerHandler,
-  CoreBooleanField: () => CoreBooleanField,
-  CoreField: () => CoreField,
-  CoreFieldTree: () => CoreFieldTree,
-  CoreFields: () => CoreFields,
-  CoreFieldsFactory: () => CoreFieldsFactory,
-  CoreNumericField: () => CoreNumericField,
-  CoreStringField: () => CoreStringField,
-  CoreTreeNodeFactory: () => CoreTreeNodeFactory,
-  DataStore: () => DataStore,
-  FieldRegistry: () => FieldRegistry,
-  FieldSerializer: () => FieldSerializer,
-  FieldTree: () => FieldTree,
-  FieldTreeSerializer: () => FieldTreeSerializer,
-  Fields: () => Fields,
-  FieldsSerializer: () => FieldsSerializer,
-  Policies: () => Policies,
-  PolicySerializer: () => PolicySerializer,
-  clampMaxPolicy: () => clampMaxPolicy,
-  clampMinPolicy: () => clampMinPolicy,
-  clampPolicy: () => clampPolicy,
-  createCoreFieldRegistry: () => createCoreFieldRegistry,
-  createCoreFieldSystem: () => createCoreFieldSystem,
-  createCorePolicySerializer: () => createCorePolicySerializer,
-  createCoreTreeNodeFactory: () => createCoreTreeNodeFactory,
-  createCoreTreeSerializer: () => createCoreTreeSerializer,
-  createTypedMethodsMixin: () => createTypedMethodsMixin
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/policies/clamp-policy.ts
-var ClampPolicy = class _ClampPolicy {
-  constructor(min, max) {
-    this.min = min;
-    this.max = max;
-  }
-  static id = "clamp";
-  id = _ClampPolicy.id;
-  apply(val) {
-    return Math.max(this.min, Math.min(this.max, val));
-  }
-  updateBounds(min, max) {
-    this.min = min;
-    this.max = max;
-  }
-};
-function clampPolicy(min, max) {
-  return new ClampPolicy(min, max);
-}
-
-// src/policies/clamp-max-policy.ts
-var ClampMaxPolicy = class _ClampMaxPolicy {
-  constructor(max) {
-    this.max = max;
-  }
-  static id = "clampMax";
-  id = _ClampMaxPolicy.id;
-  apply(val) {
-    return Math.min(this.max, val);
-  }
-  updateBounds(max) {
-    this.max = max;
-  }
-};
-function clampMaxPolicy(max) {
-  return new ClampMaxPolicy(max);
-}
-
-// src/policies/clamp-min-policy.ts
-var ClampMinPolicy = class _ClampMinPolicy {
-  constructor(min) {
-    this.min = min;
-  }
-  static id = "clampMin";
-  id = _ClampMinPolicy.id;
-  apply(val) {
-    return Math.max(this.min, val);
-  }
-  updateBounds(min) {
-    this.min = min;
-  }
-};
-function clampMinPolicy(min) {
-  return new ClampMinPolicy(min);
-}
-
-// src/policies/policies.ts
-var Policies = class {
-  policies = /* @__PURE__ */ new Map();
-  get items() {
-    return this.policies;
-  }
-  /**
-   * Retrieves a specific policy instance by its ID.
-   * Useful for accessing a policy's internal state or methods.
-   * @template P The expected type of the policy.
-   * @param id The unique ID of the policy to retrieve.
-   * @returns The policy instance, or `undefined` if not found.
-   */
-  get(id) {
-    return this.policies.get(id);
-  }
-  /**
-   * Adds a new policy to the field or replaces an existing one with the same ID.
-   * The new policy will be applied on the next `set()` operation.
-   * If a policy with the same ID already exists, its `destroy` method will be called before it is replaced.
-   * @param policy The policy instance to add.
-   */
-  add(policy) {
-    const existed = this.policies.get(policy.id);
-    existed?.destroy?.();
-    this.policies.set(policy.id, policy);
-    return this;
-  }
-  /**
-   * Removes a policy from the field by its ID and call `destroy` method.
-   * @param policyId The unique ID of the policy to remove.
-   * @returns `true` if the policy was found and removed, otherwise `false`.
-   */
-  remove(policyId) {
-    const policyToRemove = this.policies.get(policyId);
-    if (!policyToRemove) {
-      return false;
-    }
-    policyToRemove.destroy?.();
-    return this.policies.delete(policyId);
-  }
-  isEmpty() {
-    return this.policies.size === 0;
-  }
-  /**
-   * Removes all policies from the field.
-   * After this, `set()` will no longer apply any transformations to the value until new policies are added.
-   */
-  clear() {
-    this.policies.forEach((policy) => policy.destroy?.());
-    this.policies.clear();
-  }
-  /**
-   * Forces the current value to be re-processed by all policies.
-   * Useful if a policy's logic has changed and you need to re-evaluate the current state.
-   */
-  apply(val) {
-    let finalVal = val;
-    this.policies.forEach((policy) => finalVal = policy.apply(finalVal));
-    return finalVal;
-  }
-};
-
-// src/mixins/mixin-factory.ts
-function createTypedMethodsMixin(typeName, baseMethodName) {
-  const methodNames = {
-    create: `create${baseMethodName}`,
-    upset: `upset${baseMethodName}`,
-    get: `get${baseMethodName}`
-  };
-  return function(Base) {
-    return class FieldsWith extends Base {
-      // createBoolean, createMySignal, etc.
-      [methodNames.create](name, initialValue, options) {
-        return this.create(typeName, name, initialValue, options);
-      }
-      // upsetBoolean, upsetMySignal, etc.
-      [methodNames.upset](name, value, options) {
-        return this.upset(typeName, name, value, options);
-      }
-      // getBoolean, getMySignal, etc.
-      [methodNames.get](name) {
-        return this.get(name);
-      }
-    };
-  };
-}
-
-// src/field-definitions/core-field.ts
-var import_utils = require("@axi-engine/utils");
-var import_dequal = require("dequal");
-var CoreField = class _CoreField {
-  /** A type keyword of the field */
-  static typeName = "default";
-  typeName = _CoreField.typeName;
-  /** A unique identifier for the field. */
-  _name;
-  _value;
-  _onChange = new import_utils.Emitter();
-  onChange;
-  policies = new Policies();
-  get name() {
-    return this._name;
-  }
-  /**
-   * Gets the current raw value of the field.
-   * For reactive updates, it's recommended to use the `.signal` property instead.
-   */
-  get value() {
-    return this._value;
-  }
-  /**
-   * Sets a new value for the field.
-   * The provided value will be processed by all registered policies before the underlying signal is updated.
-   * @param val The new value to set.
-   */
-  set value(val) {
-    const oldVal = this._value;
-    const finalVal = this.policies.apply(val);
-    if (!(0, import_dequal.dequal)(this._value, finalVal)) {
-      this._value = finalVal;
-      this._onChange.emit(this._value, oldVal);
-    }
-  }
-  /**
-   * Creates an instance of a Field.
-   * @param name A unique identifier for the field.
-   * @param initialVal The initial value of the field.
-   * @param options Optional configuration for the field.
-   * @param options.policies An array of policies to apply to the field's value on every `set` operation.
-   * @param options.isEqual An function for compare old and new value, by default uses the strictEquals from `utils`
-   *
-   */
-  constructor(name, initialVal, options) {
-    this.onChange = this._onChange;
-    this._name = name;
-    options?.policies?.forEach((policy) => this.policies.add(policy));
-    this.value = initialVal;
-  }
-  setValueSilently(val) {
-    this._value = this.policies.apply(val);
-  }
-  batchUpdate(updateFn) {
-    this.value = updateFn(this.value);
-  }
-  /**
-   * Cleans up resources used by the field and its policies.
-   * This should be called when the field is no longer needed to prevent memory leaks from reactive policies.
-   */
-  destroy() {
-    this.policies.clear();
-    this._onChange.clear();
-  }
-};
-
-// src/field-definitions/core-boolean-field.ts
-var CoreBooleanField = class _CoreBooleanField extends CoreField {
-  static typeName = "boolean";
-  typeName = _CoreBooleanField.typeName;
-  constructor(name, initialVal, options) {
-    super(name, initialVal, options);
-  }
-  toggle() {
-    this.value = !this.value;
-    return this.value;
-  }
-};
-
-// src/field-definitions/core-string-field.ts
-var CoreStringField = class _CoreStringField extends CoreField {
-  static typeName = "string";
-  typeName = _CoreStringField.typeName;
-  constructor(name, initialVal, options) {
-    super(name, initialVal, options);
-  }
-  append(str) {
-    this.value = this.value + str;
-    return this;
-  }
-  prepend(str) {
-    this.value = str + this.value;
-    return this;
-  }
-  trim() {
-    this.value = this.value.trim();
-    return this;
-  }
-  isEmpty() {
-    return this.value.length === 0;
-  }
-  clear() {
-    this.value = "";
-  }
-};
-
-// src/field-definitions/core-numeric-field.ts
-var import_utils2 = require("@axi-engine/utils");
-var CoreNumericField = class _CoreNumericField extends CoreField {
-  static typeName = "numeric";
-  typeName = _CoreNumericField.typeName;
-  get min() {
-    const policy = this.policies.get(ClampPolicy.id) ?? this.policies.get(ClampMinPolicy.id);
-    return policy?.min;
-  }
-  get max() {
-    const policy = this.policies.get(ClampPolicy.id) ?? this.policies.get(ClampMaxPolicy.id);
-    return policy?.max;
-  }
-  constructor(name, initialVal, options) {
-    const policies = options?.policies ?? [];
-    if (!(0, import_utils2.isNullOrUndefined)(options?.min) && !(0, import_utils2.isNullOrUndefined)(options?.max)) {
-      policies.unshift(clampPolicy(options.min, options.max));
-    } else if (!(0, import_utils2.isNullOrUndefined)(options?.min)) {
-      policies.unshift(clampMinPolicy(options.min));
-    } else if (!(0, import_utils2.isNullOrUndefined)(options?.max)) {
-      policies.unshift(clampMaxPolicy(options.max));
-    }
-    super(name, initialVal, { policies });
-  }
-  isMin() {
-    const min = this.min;
-    return (0, import_utils2.isNullOrUndefined)(min) ? false : this.value <= min;
-  }
-  isMax() {
-    const max = this.max;
-    return (0, import_utils2.isNullOrUndefined)(max) ? false : this.value >= max;
-  }
-  inc(amount = 1) {
-    this.value = this.value + amount;
-  }
-  dec(amount = 1) {
-    this.value = this.value - amount;
-  }
-};
-
-// src/field-registry.ts
-var import_utils3 = require("@axi-engine/utils");
-var FieldRegistry = class extends import_utils3.ConstructorRegistry {
-};
-
-// src/fields.ts
-var import_utils4 = require("@axi-engine/utils");
-var Fields = class _Fields {
-  static typeName = "fields";
-  typeName = _Fields.typeName;
-  _fields = /* @__PURE__ */ new Map();
-  _fieldRegistry;
-  /**
-   * An event emitter that fires when a new field is added to the collection.
-   * @event
-   * @param {object} event - The event payload.
-   * @param {string} event.name - The name of the added field.
-   * @param {Field<any>} event.field - The `Field` instance that was added.
-   */
-  onAdd = new import_utils4.Emitter();
-  /**
-   * An event emitter that fires after one or more fields have been removed.
-   * @event
-   * @param {object} event - The event payload.
-   * @param {string[]} event.names - An array of names of the fields that were successfully removed.
-   */
-  onRemove = new import_utils4.Emitter();
-  /**
-   * Gets the read-only map of all `Field` instances in this container.
-   * @returns {Map<string, Field<any>>} The collection of fields.
-   */
-  get fields() {
-    return this._fields;
-  }
-  /**
-   * Creates an instance of Fields.
-   * @param {FieldRegistry} fieldRegistry - The registry used to create new `Field` instances.
-   */
-  constructor(fieldRegistry) {
-    this._fieldRegistry = fieldRegistry;
-  }
-  /**
-   * Checks if a field with the given name exists in the collection.
-   * @param {string} name The name of the field to check.
-   * @returns {boolean} `true` if the field exists, otherwise `false`.
-   */
-  has(name) {
-    return this._fields.has(name);
-  }
-  /**
-   * Adds a pre-existing `Field` instance to the collection and fires the `onAdd` event.
-   * @template T - The specific `Field` type being added.
-   * @param {Field<any>} field - The `Field` instance to add.
-   * @returns {T} The added `Field` instance, cast to type `T`.
-   * @throws If a field with the same name already exists.
-   */
-  add(field) {
-    (0, import_utils4.throwIf)(this.has(field.name), `Field with name '${field.name}' already exists`);
-    this._fields.set(field.name, field);
-    this.onAdd.emit({
-      name: field.name,
-      field
-    });
-    return field;
-  }
-  /**
-   * Creates a new `Field` instance of a specified type, adds it to the collection, and returns it.
-   * This is the primary factory method for creating fields within this container.
-   * @template T - The expected `Field` type to be returned.
-   * @param {string} typeName - The registered type name of the field to create (e.g., 'numeric', 'boolean').
-   * @param {string} name - The unique name for the new field.
-   * @param {*} initialValue - The initial value for the new field.
-   * @param {*} [options] - Optional configuration passed to the field's constructor.
-   * @returns {T} The newly created `Field` instance.
-   */
-  create(typeName, name, initialValue, options) {
-    const Ctor = this._fieldRegistry.get(typeName);
-    const field = new Ctor(name, initialValue, options);
-    this.add(field);
-    return field;
-  }
-  /**
-   * Updates an existing field's value or creates a new one if it doesn't exist.
-   * @template T - The expected `Field` type.
-   * @param {string} typeName - The type name to use if a new field needs to be created.
-   * @param {string} name - The name of the field to update or create.
-   * @param {*} value - The new value to set.
-   * @param {*} [options] - Optional configuration, used only if a new field is created.
-   * @returns {T} The existing or newly created `Field` instance.
-   */
-  upset(typeName, name, value, options) {
-    if (this.has(name)) {
-      const field = this.get(name);
-      field.value = value;
-      return field;
-    }
-    return this.create(typeName, name, value, options);
-  }
-  /**
-   * Retrieves a field by its name.
-   * @template TField - The expected `Field` type to be returned.
-   * @param {string} name - The name of the field to retrieve.
-   * @returns {TField} The `Field` instance.
-   * @throws If the field does not exist.
-   */
-  get(name) {
-    (0, import_utils4.throwIf)(!this._fields.has(name), `Field with name '${name}' not exists`);
-    return this._fields.get(name);
-  }
-  /**
-   * Removes one or more fields from the collection.
-   * This method ensures that the `destroy` method of each removed field is called to clean up its resources.
-   * @param {string| string[]} names A single name or an array of names to remove.
-   */
-  remove(names) {
-    const namesToRemove = Array.isArray(names) ? names : [names];
-    const reallyRemoved = namesToRemove.filter((name) => {
-      const field = this._fields.get(name);
-      if (!field) {
-        return false;
-      }
-      field.destroy();
-      return this._fields.delete(name);
-    });
-    if (!reallyRemoved.length) {
-      return;
-    }
-    this.onRemove.emit({ names: reallyRemoved });
-  }
-  /**
-   * Removes all fields from the collection, ensuring each is properly destroyed.
-   */
-  clear() {
-    this.remove(Array.from(this._fields.keys()));
-  }
-  destroy() {
-    this.clear();
-    this.onAdd.clear();
-    this.onRemove.clear();
-  }
-};
-
-// src/field-tree.ts
-var import_utils5 = require("@axi-engine/utils");
-var FieldTree = class _FieldTree {
-  static typeName = "fieldTree";
-  typeName = _FieldTree.typeName;
-  /** @private The internal map storing child nodes (branches or leaves). */
-  _nodes = /* @__PURE__ */ new Map();
-  /** @private The factory used to create new child nodes. */
-  _factory;
-  /**
-   * An event emitter that fires immediately after a new node is added to this tree branch.
-   * @event
-   * @param {object} event - The event payload.
-   * @param {string} event.name - The name (key) of the added node.
-   * @param event.node - The node instance that was added.
-   * @example
-   * myTree.onAdd.subscribe(({ name, node }) => {
-   *   console.log(`Node '${name}' was added.`, node);
-   * });
-   */
-  onAdd = new import_utils5.Emitter();
-  /**
-   * An event emitter that fires once after one or more nodes have been successfully removed.
-   * @event
-   * @param {object} event - The event payload.
-   * @param {string[]} event.names - An array of names of the nodes that were removed.
-   * @example
-   * myTree.onRemove.subscribe(({ names }) => {
-   *   console.log(`Nodes removed: ${names.join(', ')}`);
-   * });
-   */
-  onRemove = new import_utils5.Emitter();
-  /**
-   * Gets the collection of direct child nodes of this tree branch.
-   */
-  get nodes() {
-    return this._nodes;
-  }
-  /**
-   * Creates an instance of FieldTree.
-   * @param {FieldTreeFactory} factory - A factory responsible for creating new nodes within the tree.
-   */
-  constructor(factory) {
-    this._factory = factory;
-  }
-  /**
-   * Checks if a direct child node with the given name exists.
-   * @param {string} name - The name of the direct child node.
-   * @returns {boolean} `true` if the node exists, otherwise `false`.
-   */
-  has(name) {
-    return this._nodes.has(name);
-  }
-  /**
-   * Checks if a node exists at a given path, traversing the tree.
-   * @param {PathType} path - The path to check (e.g., 'player/stats' or ['player', 'stats']).
-   * @returns {boolean} `true` if the entire path resolves to a node, otherwise `false`.
-   */
-  hasPath(path) {
-    const traversedPath = this.traversePath(path);
-    return traversedPath.branch.has(traversedPath.leafName);
-  }
-  /**
-   * Adds a pre-existing node as a direct child of this tree branch.
-   * @param {string} name - The name to assign to the new child node.
-   * @param {TreeNode} node - The node instance to add.
-   * @returns {TreeNode} The added node.
-   * @throws If a node with the same name already exists.
-   */
-  addNode(name, node) {
-    (0, import_utils5.throwIf)(this.has(name), `Can't add node with name: '${name}', node already exists`);
-    this._nodes.set(name, node);
-    this.onAdd.emit({ name, node });
-    return node;
-  }
-  /**
-   * Retrieves a direct child node by its name.
-   * @param {string} name - The name of the child node.
-   * @returns {TreeNode} The retrieved node.
-   * @throws If a node with the given name cannot be found.
-   */
-  getNode(name) {
-    const node = this._nodes.get(name);
-    (0, import_utils5.throwIfEmpty)(node, `Can't find node with name '${name}'`);
-    return node;
-  }
-  /**
-   * Removes one or more nodes from this tree branch.
-   *
-   * This method first validates that all specified nodes exist. If validation passes,
-   * it recursively calls `destroy()` on each node to ensure proper cleanup of the entire subtree.
-   * Finally, it emits a single `onRemove` event with the names of all successfully removed nodes.
-   *
-   * @param {string | string[]} names - A single name or an array of names of the nodes to remove.
-   * @throws If any of the specified names do not correspond to an existing node.
-   */
-  removeNode(names) {
-    const toRemoveNames = Array.isArray(names) ? names : [names];
-    toRemoveNames.forEach((name) => {
-      (0, import_utils5.throwIf)(!this.has(name), `Can't remove node with name: '${name}', node doesn't exists`);
-    });
-    toRemoveNames.forEach((name) => {
-      this._nodes.get(name).destroy();
-      this._nodes.delete(name);
-    });
-    if (toRemoveNames.length) {
-      this.onRemove.emit({ names: toRemoveNames });
-    }
-  }
-  /**
-   * Creates a new `FieldTree` (branch) node at the specified path.
-   * @param {PathType} path - The path where the new `FieldTree` should be created.
-   * @param {boolean} [createPath=false] - If `true`, any missing parent branches in the path will be created automatically.
-   * @returns {FieldTree} The newly created `FieldTree` instance.
-   * @throws If the path is invalid or a node already exists at the target location.
-   */
-  createFieldTree(path, createPath) {
-    const traversedPath = this.traversePath(path, createPath);
-    return traversedPath.branch.addNode(traversedPath.leafName, this._factory.tree());
-  }
-  /**
-   * Creates a new `Fields` (leaf) container at the specified path.
-   * @param {PathType} path - The path where the new `Fields` container should be created.
-   * @param {boolean} [createPath=false] - If `true`, any missing parent branches in the path will be created automatically.
-   * @returns {Fields} The newly created `Fields` instance.
-   * @throws If the path is invalid or a node already exists at the target location.
-   */
-  createFields(path, createPath) {
-    const traversedPath = this.traversePath(path, createPath);
-    return traversedPath.branch.addNode(traversedPath.leafName, this._factory.fields());
-  }
-  /**
-   * Retrieves a `FieldTree` (branch) node from a specified path.
-   * @param {PathType} path - The path to the `FieldTree` node.
-   * @returns {FieldTree} The `FieldTree` instance at the specified path.
-   * @throws If the path is invalid or the node at the path is not a `FieldTree`.
-   */
-  getFieldTree(path) {
-    const traversedPath = this.traversePath(path);
-    const node = traversedPath.branch.getNode(traversedPath.leafName);
-    (0, import_utils5.throwIf)(
-      !(node instanceof _FieldTree),
-      `Node with name: ${traversedPath.leafName} by path: '${(0, import_utils5.ensurePathString)(path)}' should be instance of FieldTree`
-    );
-    return node;
-  }
-  /**
-   * Retrieves a `Fields` (leaf) container from a specified path.
-   * @param {PathType} path - The path to the `Fields` container.
-   * @returns {Fields} The `Fields` instance at the specified path.
-   * @throws If the path is invalid or the node at the path is not a `Fields` container.
-   */
-  getFields(path) {
-    const traversedPath = this.traversePath(path);
-    const node = traversedPath.branch.getNode(traversedPath.leafName);
-    (0, import_utils5.throwIf)(
-      !(node instanceof Fields),
-      `Node with name: ${traversedPath.leafName} by path: '${(0, import_utils5.ensurePathString)(path)}' should be instance of Fields`
-    );
-    return node;
-  }
-  /**
-   * Retrieves a `FieldTree` at the specified path. If it or any part of the path doesn't exist, it will be created.
-   * @param {PathType} path - The path to the `FieldTree` node.
-   * @returns {FieldTree} The existing or newly created `FieldTree` instance.
-   */
-  getOrCreateFieldTree(path) {
-    const traversedPath = this.traversePath(path, true);
-    return traversedPath.branch.has(traversedPath.leafName) ? traversedPath.branch.getFieldTree(traversedPath.leafName) : traversedPath.branch.createFieldTree(traversedPath.leafName);
-  }
-  /**
-   * Retrieves a `Fields` container at the specified path. If it or any part of the path doesn't exist, it will be created.
-   * @param {PathType} path - The path to the `Fields` container.
-   * @returns {Fields} The existing or newly created `Fields` instance.
-   */
-  getOrCreateFields(path) {
-    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
-   * a full, recursive cleanup of the entire subtree.
-   */
-  clear() {
-    this.removeNode(Array.from(this._nodes.keys()));
-  }
-  /**
-   * Performs a complete cleanup of this node and its entire subtree.
-   *
-   * It recursively destroys all child nodes by calling `clear()` and then
-   * unsubscribes all listeners from its own event emitters.
-   * This method should be called when a node is no longer needed.
-   */
-  destroy() {
-    this.clear();
-    this.onAdd.clear();
-    this.onRemove.clear();
-  }
-  /**
-   * @private
-   * Navigates the tree to the parent of a target node.
-   * This is the core traversal logic for all path-based operations.
-   * @param {PathType} path - The full path to the target node.
-   * @param {boolean} [createPath=false] - If `true`, creates missing `FieldTree` branches along the path.
-   * @returns {{branch: FieldTree, leafName: string}} An object containing the final branch (parent node) and the name of the leaf (target node).
-   * @throws If the path is empty, invalid, or contains a `Fields` container as an intermediate segment.
-   */
-  traversePath(path, createPath) {
-    const pathArr = (0, import_utils5.ensurePathArray)(path);
-    (0, import_utils5.throwIfEmpty)(pathArr, "The path is empty");
-    const leafName = pathArr.pop();
-    let currentNode = this;
-    for (const pathPart of pathArr) {
-      let node;
-      if (currentNode.has(pathPart)) {
-        node = currentNode.getNode(pathPart);
-      } else {
-        if (createPath) {
-          node = currentNode.createFieldTree(pathPart);
-        }
-      }
-      (0, import_utils5.throwIfEmpty)(node, `Can't find node with name ${pathPart} by path parsing: ${(0, import_utils5.ensurePathString)(path)}`);
-      (0, import_utils5.throwIf)(node instanceof Fields, `Node with name ${pathPart} should be instance of FieldTree`);
-      currentNode = node;
-    }
-    return { branch: currentNode, leafName };
-  }
-};
-
-// 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;
-  }
-  fields() {
-    return new CoreFields(this._fieldRegistry);
-  }
-};
-
-// 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 CoreFieldTree(this);
-  }
-};
-
-// src/serializer/policies/clamp-policy-serializer-handler.ts
-var ClampPolicySerializerHandler = class {
-  snapshot(policy) {
-    return { min: policy.min, max: policy.max };
-  }
-  hydrate(data) {
-    return new ClampPolicy(data.min, data.max);
-  }
-};
-
-// src/serializer/policies/clamp-max-policy-serializer-handler.ts
-var ClampMaxPolicySerializerHandler = class {
-  snapshot(policy) {
-    return { max: policy.max };
-  }
-  hydrate(data) {
-    return new ClampMaxPolicy(data.max);
-  }
-};
-
-// src/serializer/policies/clamp-min-policy-serializer-handler.ts
-var ClampMinPolicySerializerHandler = class {
-  snapshot(policy) {
-    return { min: policy.min };
-  }
-  hydrate(data) {
-    return new ClampMinPolicy(data.min);
-  }
-};
-
-// src/serializer/policy-serializer.ts
-var import_utils6 = require("@axi-engine/utils");
-var PolicySerializer = class {
-  handlers = /* @__PURE__ */ new Map();
-  register(policyId, handler) {
-    (0, import_utils6.throwIf)(this.handlers.has(policyId), `A handler for policy ID '${policyId}' is already registered.`);
-    this.handlers.set(policyId, handler);
-    return this;
-  }
-  clearHandlers() {
-    this.handlers.clear();
-  }
-  /**
-   * Creates a serializable snapshot of a policy instance.
-   * The snapshot includes the policy's state and a `__type` identifier.
-   * @param policy The policy instance to snapshot.
-   * @returns A plain object ready for JSON serialization.
-   * @throws If no handler is registered for the policy's ID.
-   */
-  snapshot(policy) {
-    const handler = this.handlers.get(policy.id);
-    (0, import_utils6.throwIfEmpty)(handler, `No serializer handler registered for policy ID: '${policy.id}'`);
-    const data = handler.snapshot(policy);
-    return {
-      __type: policy.id,
-      ...data
-    };
-  }
-  /**
-   * Restores a policy instance from its snapshot representation.
-   * @param snapshot The plain object snapshot, which must contain a `__type` property.
-   * @returns A new, fully functional policy instance.
-   * @throws If the snapshot is invalid or no handler is registered for its `__type`.
-   */
-  hydrate(snapshot) {
-    const typeId = snapshot?.__type;
-    (0, import_utils6.throwIfEmpty)(typeId, 'Invalid policy snapshot: missing "__type" identifier.');
-    const handler = this.handlers.get(typeId);
-    (0, import_utils6.throwIfEmpty)(handler, `No serializer handler registered for policy ID: '${typeId}'`);
-    const { __type, ...data } = snapshot;
-    return handler.hydrate(data);
-  }
-};
-
-// src/serializer/field-serializer.ts
-var import_utils7 = require("@axi-engine/utils");
-var FieldSerializer = class {
-  /**
-   * Creates an instance of FieldSerializer.
-   * @param {FieldRegistry} fieldRegistry - A registry that maps string type names to Field constructors.
-   * @param {PolicySerializer} policySerializer - A serializer dedicated to handling Policy instances.
-   */
-  constructor(fieldRegistry, policySerializer) {
-    this.fieldRegistry = fieldRegistry;
-    this.policySerializer = policySerializer;
-  }
-  /**
-   * Creates a serializable snapshot of a Field instance.
-   * The snapshot includes the field's type, name, current value, and the state of all its policies.
-   * @param {Field<any>} field - The Field instance to serialize.
-   * @returns {FieldSnapshot} A plain object ready for JSON serialization.
-   */
-  snapshot(field) {
-    let snapshot = {
-      __type: field.typeName,
-      name: field.name,
-      value: field.value
-    };
-    if (!field.policies.isEmpty()) {
-      const serializedPolicies = [];
-      field.policies.items.forEach((policy) => serializedPolicies.push(this.policySerializer.snapshot(policy)));
-      snapshot.policies = serializedPolicies;
-    }
-    return snapshot;
-  }
-  /**
-   * Restores a Field instance from its snapshot representation.
-   * It uses the `__type` property to find the correct constructor and hydrates
-   * the field with its value and all its policies.
-   * @param {FieldSnapshot} snapshot - The plain object snapshot to deserialize.
-   * @returns {Field<any>} A new, fully functional Field instance.
-   * @throws If the snapshot is invalid, missing a `__type`, or if the type is not registered.
-   */
-  hydrate(snapshot) {
-    const fieldType = snapshot.__type;
-    (0, import_utils7.throwIfEmpty)(fieldType, 'Invalid field snapshot: missing "__type" identifier.');
-    const Ctor = this.fieldRegistry.get(fieldType);
-    let policies;
-    if (!(0, import_utils7.isNullOrUndefined)(snapshot.policies)) {
-      policies = [];
-      snapshot.policies.forEach((p) => policies.push(this.policySerializer.hydrate(p)));
-    }
-    return new Ctor(snapshot.name, snapshot.value, { policies });
-  }
-};
-
-// src/serializer/fields-serializer.ts
-var FieldsSerializer = class {
-  /**
-   * Creates an instance of FieldsSerializer.
-   * @param {FieldsFactory} fieldsFactory - A registry that maps string type names to Field constructors.
-   * @param {FieldSerializer} fieldSerializer - A serializer of field instances.
-   */
-  constructor(fieldsFactory, fieldSerializer) {
-    this.fieldsFactory = fieldsFactory;
-    this.fieldSerializer = fieldSerializer;
-  }
-  /**
-   * Creates a serializable snapshot of a `Fields` container.
-   *
-   * The snapshot includes a `__type` identifier (currently hardcoded) and an array of snapshots
-   * for each `Field` within the container.
-   * @param {Fields} fields - The `Fields` instance to serialize.
-   * @returns {FieldsSnapshot} A plain object ready for JSON serialization.
-   */
-  snapshot(fields) {
-    const res = {
-      __type: fields.typeName
-    };
-    fields.fields.forEach((field) => res[field.name] = this.fieldSerializer.snapshot(field));
-    return res;
-  }
-  /**
-   * Restores a `Fields` container instance from its snapshot representation.
-   *
-   * It iterates through the field snapshots and hydrates them individually, adding them to the new container.
-   * @param {FieldsSnapshot} snapshot - The plain object snapshot to deserialize.
-   * @returns {Fields} A new `DefaultFields` instance populated with the restored fields.
-   */
-  hydrate(snapshot) {
-    const { __type, ...fieldsData } = snapshot;
-    const fields = this.fieldsFactory.fields();
-    for (const fieldName in fieldsData) {
-      const fieldSnapshot = fieldsData[fieldName];
-      const restoredField = this.fieldSerializer.hydrate(fieldSnapshot);
-      fields.add(restoredField);
-    }
-    return fields;
-  }
-};
-
-// src/serializer/field-tree-serializer.ts
-var import_utils8 = require("@axi-engine/utils");
-var FieldTreeSerializer = class {
-  constructor(fieldTreeNodeFactory, fieldsSerializer) {
-    this.fieldTreeNodeFactory = fieldTreeNodeFactory;
-    this.fieldsSerializer = fieldsSerializer;
-  }
-  /**
-   * Creates a serializable snapshot of the entire tree and its contained fields.
-   * @returns A plain JavaScript object representing the complete state managed by this tree.
-   */
-  snapshot(tree) {
-    const res = {
-      __type: tree.typeName
-    };
-    tree.nodes.forEach((node, key) => {
-      if (node.typeName === tree.typeName) {
-        res[key] = this.snapshot(node);
-      } else if (node.typeName === Fields.typeName) {
-        res[key] = this.fieldsSerializer.snapshot(node);
-      }
-    });
-    return res;
-  }
-  /**
-   * Restores the state of the tree from a snapshot.
-   * It intelligently creates missing nodes based on `__type` metadata and delegates hydration to child nodes.
-   * @param snapshot The snapshot object to load.
-   */
-  hydrate(snapshot) {
-    const { __type, ...nodes } = snapshot;
-    const tree = this.fieldTreeNodeFactory.tree();
-    for (const key in nodes) {
-      const nodeData = nodes[key];
-      if ((0, import_utils8.isString)(nodeData)) {
-        continue;
-      }
-      if (nodeData.__type === FieldTree.typeName) {
-        tree.addNode(key, this.hydrate(nodeData));
-      } else if (nodeData.__type === Fields.typeName) {
-        tree.addNode(key, this.fieldsSerializer.hydrate(nodeData));
-      }
-    }
-    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,
-  ClampMaxPolicySerializerHandler,
-  ClampMinPolicy,
-  ClampMinPolicySerializerHandler,
-  ClampPolicy,
-  ClampPolicySerializerHandler,
-  CoreBooleanField,
-  CoreField,
-  CoreFieldTree,
-  CoreFields,
-  CoreFieldsFactory,
-  CoreNumericField,
-  CoreStringField,
-  CoreTreeNodeFactory,
-  DataStore,
-  FieldRegistry,
-  FieldSerializer,
-  FieldTree,
-  FieldTreeSerializer,
-  Fields,
-  FieldsSerializer,
-  Policies,
-  PolicySerializer,
-  clampMaxPolicy,
-  clampMinPolicy,
-  clampPolicy,
-  createCoreFieldRegistry,
-  createCoreFieldSystem,
-  createCorePolicySerializer,
-  createCoreTreeNodeFactory,
-  createCoreTreeSerializer,
-  createTypedMethodsMixin
-});
+export * from './policies/index';
+export * from './mixins/mixin-factory';
+export * from './field';
+export * from './field-definitions';
+export * from './field-registry';
+export * from './fields';
+export * from './field-tree';
+export * from './fields-factory';
+export * from './field-tree-factory';
+export * from './core-fields';
+export * from './core-fields-factory';
+export * from './core-field-tree';
+export * from './core-field-tree-factory';
+export * from './serializer/index';
+export * from './store';
+export * from './data-store';
+export * from './setup';
+//# sourceMappingURL=index.js.map