@axi-engine/fields 0.3.8 → 0.3.10

package/dist/index.mjs

@@ -318,6 +318,9 @@ var Fields = class _Fields {
   onRemove = new Emitter2();
   /**
    * Gets the read-only map of all `Field` instances in this container.
+   *
+   * @internal
+   *
    * @returns {Map<string, Field<any>>} The collection of fields.
    */
   get fields() {
@@ -464,11 +467,28 @@ var FieldTree = class _FieldTree {
    */
   onRemove = new Emitter3();
   /**
-   * Gets the collection of direct child nodes of this tree branch.
+   * Provides direct access to the internal node storage.
+   *
+   * @remarks
+   * This is primarily intended for **serialization**, debugging, or low-level iteration.
+   * Avoid modifying this map directly to maintain internal consistency; use {@link addNode} or {@link removeNode} instead.
+   * @internal
    */
   get nodes() {
     return this._nodes;
   }
+  /**
+   * Exposes the internal factory instance used by this tree.
+   *
+   * @remarks
+   * Direct usage of this getter is generally unnecessary.
+   * Prefer using {@link createDetachedTree} or {@link createDetachedFields} to create isolated instances.
+   *
+   * @returns {FieldTreeFactory} The factory instance.
+   */
+  get factory() {
+    return this._factory;
+  }
   /**
    * Creates an instance of FieldTree.
    * @param {FieldTreeFactory} factory - A factory responsible for creating new nodes within the tree.
@@ -640,6 +660,23 @@ var FieldTree = class _FieldTree {
     this.onAdd.clear();
     this.onRemove.clear();
   }
+  /**
+   * Creates a new, detached FieldTree instance using the same factory as this tree.
+   * This new tree has no parent and is completely isolated.
+   *
+   * @returns A new instance of the same tree type.
+   */
+  createDetachedTree() {
+    return this._factory.tree();
+  }
+  /**
+   * Creates a new, detached Fields container using the same factory.
+   *
+   * @returns
+   */
+  createDetachedFields() {
+    return this._factory.fields();
+  }
   /**
    * @private
    * Navigates the tree to the parent of a target node.
@@ -837,13 +874,35 @@ var FieldSerializer = class {
     const fieldType = snapshot.__type;
     throwIfEmpty3(fieldType, 'Invalid field snapshot: missing "__type" identifier.');
     const Ctor = this.fieldRegistry.getOrThrow(fieldType);
-    let policies;
-    if (!isNullOrUndefined2(snapshot.policies)) {
-      policies = [];
-      snapshot.policies.forEach((p) => policies.push(this.policySerializer.hydrate(p)));
-    }
+    let policies = this.hydratePolicies(snapshot);
     return new Ctor(snapshot.name, snapshot.value, { policies });
   }
+  /**
+   * Updates an existing Field instance with data from a snapshot.
+   *
+   * This method modifies the field in-place, preserving the object reference.
+   * It updates the field's value and completely replaces its current policies
+   * with the ones defined in the snapshot.
+   *
+   * @param {Field<any>} field - The existing Field instance to update.
+   * @param {FieldSnapshot} snapshot - The snapshot containing the new state.
+   */
+  patch(field, snapshot) {
+    let policies = this.hydratePolicies(snapshot);
+    field.policies.clear();
+    if (policies) {
+      policies.forEach((p) => field.policies.add(p));
+    }
+    field.value = snapshot.value;
+  }
+  hydratePolicies(snapshot) {
+    if (isNullOrUndefined2(snapshot.policies)) {
+      return void 0;
+    }
+    const policies = [];
+    snapshot.policies.forEach((p) => policies.push(this.policySerializer.hydrate(p)));
+    return policies;
+  }
 };
 
 // src/serializer/fields-serializer.ts
@@ -894,9 +953,17 @@ var FieldsSerializer = class {
 // src/serializer/field-tree-serializer.ts
 import { isString } from "@axi-engine/utils";
 var FieldTreeSerializer = class {
+  _factory;
+  _fieldsSerializer;
+  get factory() {
+    return this._factory;
+  }
+  get fieldsSerializer() {
+    return this._fieldsSerializer;
+  }
   constructor(fieldTreeNodeFactory, fieldsSerializer) {
-    this.fieldTreeNodeFactory = fieldTreeNodeFactory;
-    this.fieldsSerializer = fieldsSerializer;
+    this._factory = fieldTreeNodeFactory;
+    this._fieldsSerializer = fieldsSerializer;
   }
   /**
    * Creates a serializable snapshot of the entire tree and its contained fields.
@@ -922,7 +989,7 @@ var FieldTreeSerializer = class {
    */
   hydrate(snapshot) {
     const { __type, ...nodes } = snapshot;
-    const tree = this.fieldTreeNodeFactory.tree();
+    const tree = this._factory.tree();
     for (const key in nodes) {
       const nodeData = nodes[key];
       if (isString(nodeData)) {
@@ -962,23 +1029,52 @@ var StringFieldResolver = class {
   }
 };
 
+// src/guards.ts
+import { isNullOrUndefined as isNullOrUndefined3 } from "@axi-engine/utils";
+function isFields(value) {
+  return !isNullOrUndefined3(value) && value.typeName === Fields.typeName;
+}
+function isFieldTree(value) {
+  return !isNullOrUndefined3(value) && value.typeName === FieldTree.typeName;
+}
+function isDataStore(value) {
+  return !isNullOrUndefined3(value) && value.typeName === DataStore.typeName;
+}
+
 // src/data-store.ts
-var DataStore = class {
-  constructor(tree) {
-    this.tree = tree;
+var DataStore = class _DataStore {
+  static typeName = "dataStore";
+  typeName = _DataStore.typeName;
+  resolvers = [];
+  _variables;
+  _tree;
+  _factory;
+  get variables() {
+    if (!this._variables) {
+      this._variables = this._factory.fields();
+    }
+    return this._variables;
+  }
+  get tree() {
+    if (!this._tree) {
+      this._tree = this._factory.tree();
+    }
+    return this._tree;
+  }
+  constructor(treeOrFactory, variables) {
+    if (!isFieldTree(treeOrFactory)) {
+      this._factory = treeOrFactory;
+    } else {
+      this._tree = treeOrFactory;
+      this._factory = this._tree.factory;
+    }
+    if (variables) {
+      this._variables = variables;
+    }
     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);
   }
@@ -1048,8 +1144,8 @@ var DataStore = class {
   getField(path) {
     const pathArr = ensurePathArray2(path);
     throwIfEmpty4(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]);
+    if (this.isPathToVariables(pathArr)) {
+      return this.variables.get(pathArr[0]);
     }
     const fieldName = pathArr.pop();
     const fields = this.tree.getFields(pathArr);
@@ -1070,8 +1166,8 @@ var DataStore = class {
   remove(path) {
     const pathArr = ensurePathArray2(path);
     throwIfEmpty4(pathArr, `Wrong path or path is empty: ${ensurePathString2(path)}, should contain at least one path segment`);
-    if (this.isPathToRootFields(pathArr)) {
-      this.rootFields.remove(pathArr);
+    if (this.isPathToVariables(pathArr)) {
+      this.variables.remove(pathArr);
       return;
     }
     const node = this.tree.findParentNode(pathArr);
@@ -1082,25 +1178,26 @@ var DataStore = class {
       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 };
+  /**
+   * Creates a new, independent instance of the Store with a fresh, empty data state (FieldsTree).
+   *
+   * The new instance retains the same capabilities (e.g., factory configuration)
+   * as the current one but is completely detached from the existing data hierarchy.
+   * This is useful for creating local scopes, stack frames, or temporary data contexts.
+   *
+   * @returns {DataStore} A new, isolated DataStore instance.
+   */
+  createIsolated() {
+    return new _DataStore(this._factory);
   }
+  /** code below -> implementation of the DataStore from utils */
   has(path) {
     const pathArr = ensurePathArray2(path);
-    if (this.isPathToRootFields(pathArr)) {
-      return this.rootFields.has(pathArr[0]);
+    if (this.isPathToVariables(pathArr)) {
+      return this.variables.has(pathArr[0]);
     }
     return this.tree.hasPath(pathArr);
   }
-  /** implementation of the DataStore from utils */
   get(path) {
     return this.getField(path).value;
   }
@@ -1116,19 +1213,86 @@ var DataStore = class {
   delete(path) {
     this.remove(path);
   }
+  /**
+   * @internal Used for serialization
+   */
+  getInternalVariables() {
+    return this._variables;
+  }
+  /**
+   * @internal Used for serialization
+   */
+  getInternalTree() {
+    return this._tree;
+  }
+  /**
+   * @private
+  */
+  isPathToVariables(path) {
+    return ensurePathArray2(path).length === 1;
+  }
+  /**
+   * @private
+   */
+  getDestinationFields(path) {
+    const pathArr = ensurePathArray2(path);
+    if (this.isPathToVariables(pathArr)) {
+      return { fields: this.variables, leafName: pathArr[0] };
+    }
+    const leafName = pathArr.pop();
+    return { fields: this.tree.getOrCreateFields(path), leafName };
+  }
 };
 
-// src/guards.ts
-import { isNullOrUndefined as isNullOrUndefined3 } from "@axi-engine/utils";
-function isFields(value) {
-  return value != null && value.typeName === Fields.typeName;
-}
-function isFieldTree(value) {
-  return value != null && value.typeName === FieldTree.typeName;
-}
-function isStore(value) {
-  return !isNullOrUndefined3(value) && typeof value.createFields === "function" && typeof value.createTree === "function";
-}
+// src/serializer/data-store-serializer.ts
+import { isNullOrUndefined as isNullOrUndefined4 } from "@axi-engine/utils";
+var DataStoreSerializer = class {
+  /**
+   * Creates an instance of DataStoreSerializer.
+   * @param {FieldTreeSerializer} fieldTreeSerializer - The serializer used for the underlying tree and fields.
+   */
+  constructor(fieldTreeSerializer) {
+    this.fieldTreeSerializer = fieldTreeSerializer;
+  }
+  /**
+   * Captures the current state of a DataStore into a serializable snapshot.
+   *
+   * It checks for the existence of internal variables and the internal tree,
+   * serializing them only if they have been initialized (lazy serialization).
+   *
+   * @param {DataStore} store - The store instance to serialize.
+   * @returns {DataStoreSnapshot} The snapshot object.
+   */
+  snapshot(store) {
+    let snapshot = {
+      __type: store.typeName
+    };
+    const variables = store.getInternalVariables();
+    if (variables) {
+      snapshot.variables = this.fieldTreeSerializer.fieldsSerializer.snapshot(variables);
+    }
+    const tree = store.getInternalTree();
+    if (tree) {
+      snapshot.tree = this.fieldTreeSerializer.snapshot(tree);
+    }
+    return snapshot;
+  }
+  /**
+   * Reconstructs a DataStore instance from a snapshot.
+   *
+   * If the snapshot contains a tree, the store is initialized with it.
+   * If not, the store is initialized with the factory (lazy mode), and the
+   * detached variables are injected if present.
+   *
+   * @param {DataStoreSnapshot} snapshot - The snapshot to hydrate.
+   * @returns {DataStore} A new, fully restored DataStore instance.
+   */
+  hydrate(snapshot) {
+    const tree = isNullOrUndefined4(snapshot.tree) ? void 0 : this.fieldTreeSerializer.hydrate(snapshot.tree);
+    const variables = isNullOrUndefined4(snapshot.variables) ? void 0 : this.fieldTreeSerializer.fieldsSerializer.hydrate(snapshot.variables);
+    return new DataStore(tree ? tree : this.fieldTreeSerializer.factory, variables);
+  }
+};
 
 // src/setup.ts
 function createCoreFieldRegistry() {
@@ -1180,6 +1344,7 @@ export {
   CoreStringField,
   CoreTreeNodeFactory,
   DataStore,
+  DataStoreSerializer,
   FieldRegistry,
   FieldSerializer,
   FieldTree,
@@ -1197,7 +1362,7 @@ export {
   createCoreTreeNodeFactory,
   createCoreTreeSerializer,
   createTypedMethodsMixin,
+  isDataStore,
   isFieldTree,
-  isFields,
-  isStore
+  isFields
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axi-engine/fields",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "description": "A compact, reactive state management library based on a tree of observable fields.",
   "license": "MIT",
   "repository": {