palistor 0.0.24

package/dist/store/store/palistor.js

@@ -0,0 +1,772 @@
+import { applyPatch } from "../applyPatch/applyPatch";
+import { recomputeAndNotify as _recomputeAndNotify } from "../compute/recompute";
+import { recomputeTargeted, collectGroupComputeNodes, recomputeLeaves } from "../compute/recompute";
+import { ProxyBuilder } from "../buildProxy/buildProxy";
+import { PersistManager } from "../persist/persistManager";
+import { ResetPipeline } from "../resetPipeline/resetPipeline";
+import { SubmitPipeline } from "../submitPipeline/submitPipeline";
+import { OnChangePipeline } from "../onChangePipeline/onChangePipeline";
+import { WritePipeline } from "../writePipeline/writePipeline";
+import { formatPatch } from "../writePipeline/writePipeline";
+import { NotificationHub } from "../init/createNotificationHub";
+import { ResolveManager } from "../init/createResolveManager";
+import { buildValuesCache, updateValuesCacheEntry } from "../valuesCache/valuesCache";
+import { NodeRegistry } from "./NodeRegistry/nodeRegistry";
+import { ServiceRegistry } from "./serviceRegistry";
+import { DirtyTracker } from "./dirtyTracker";
+import { GroupDepsMap } from "./groupDepsMap";
+import { EntityRegistry } from "../entityRegistry";
+import { generateTmpId } from "../entityRegistry";
+import { isLeafNode, isListNode, isGroupNode, configKeys } from "../traversal";
+import { normalizeConfig } from "../normalizeConfig";
+// ─── Palistor ─────────────────────────────────────────────────────────────────
+/**
+ * Публичный класс формы. Одновременно является DI-контейнером для всех
+ * внутренних подсистем и реализует публичный интерфейс `ProxyStore`.
+ *
+ * @example
+ * const store = new Palistor({ config: myConfig, initialValues: {...} });
+ * store.proxy.email.value = "test@example.com";
+ * store.submit();
+ */
+export class Palistor {
+    // ─── Конструктор ──────────────────────────────────────────────────────────
+    constructor(options) {
+        /**
+         * @internal Plain POJO mirrors for each entity — used in valuesCache.values
+         * (list arrays) and nodeSlot for O(1) updates.
+         * Key: entityId, Value: plain object `{ id, field1, field2, ... }`.
+         */
+        this.entityProjectionObjs = new Map();
+        /**
+         * Нереактивный контекст — произвольные данные, доступные через `store.context`.
+         * Устанавливается через `setContext()` или хук `useStoreContext()`.
+         */
+        this._context = {};
+        const { config, initialValues = {} } = options;
+        // ─── Field mapping (две проекции карты) ──────────────────────────────────
+        // fwd: internal → external (для ownKeys/spread).
+        // externalToInternal: external → internal (для GET/SET/tracking).
+        // Обе пусты, когда fieldMapping не передан → `?? key` возвращает ключ как есть
+        // → нулевой оверхед по умолчанию.
+        const fwd = options.fieldMapping ?? {};
+        this.fieldMapping = fwd;
+        this.externalToInternal = {};
+        for (const internal in fwd) {
+            const external = fwd[internal];
+            if (external !== undefined)
+                this.externalToInternal[external] = internal;
+        }
+        // ─── Нормализация конфига (external → internal) ───────────────────────────
+        // Конфиг пишется в ПУБЛИЧНЫХ (замапленных) именах. Один проход приводит его
+        // к internal-именам ДО init/compute/traversal — всё ядро ниже работает с
+        // internal-именами без изменений. Пустая карта → возвращается исходный
+        // config без копий (нулевой оверхед).
+        const rootConfig = normalizeConfig(config, this.externalToInternal, fwd);
+        this.rootConfig = rootConfig;
+        // ─── Сервисы ────────────────────────────────────────────────────────────
+        this.services = new ServiceRegistry();
+        const { translate, notify } = this.services;
+        // ─── NodeRegistry ────────────────────────────────────────────────────────
+        this.nodes = new NodeRegistry(rootConfig, initialValues, translate);
+        this.nodes.setKernel(this);
+        const { nodeState, nodePaths, nodeParents, computeNodes } = this.nodes;
+        // ─── DirtyTracker + ValuesCache ──────────────────────────────────────────
+        this.dirty = new DirtyTracker();
+        this.values = buildValuesCache(rootConfig, nodeState);
+        // ─── EntityRegistry ──────────────────────────────────────────────────────
+        this.entityRegistry = new EntityRegistry();
+        // Register all list states so EntityRegistry.rekey() can update itemIds
+        for (const ls of this.nodes.allListStates) {
+            this.entityRegistry.registerList(ls);
+        }
+        // ─── GroupDepsMap + первый recompute ──────────────────────────────────────
+        this.groupDepsMap = new GroupDepsMap(rootConfig, nodePaths, nodeParents);
+        this.recompute(); // первый полный пересчёт — строит карту зависимостей
+        this.dirty.capture(rootConfig, nodeState);
+        // ─── NotificationHub ────────────────────────────────────────────────────
+        this.hub = new NotificationHub({ computeNodes, nodePaths });
+        // ─── ResolveManager ──────────────────────────────────────────────────────
+        this.resolveManager = new ResolveManager({
+            rootConfig,
+            nodeState,
+            recompute: () => this.recompute(),
+            notifyChanged: (c) => this.notifyChanged(c),
+            notify,
+            initialValueMap: this.dirty.initialValueMap,
+            valuesCache: this.values,
+            store: this,
+            listStates: this.nodes.listStates,
+            setEntitiesRaw: (items, listNode) => this._setEntitiesRaw(items, listNode),
+            syncListValuesCache: (listState) => this.syncListValuesCache(listState),
+            entityRegistry: this.entityRegistry,
+        });
+        // ─── Pipeline классы ─────────────────────────────────────────────────────
+        this.writePipeline = new WritePipeline(this);
+        this.resetPipeline = new ResetPipeline(this);
+        this.submitPipeline = new SubmitPipeline(this);
+        this.onChangePipeline = new OnChangePipeline(this);
+        this.proxyBuilder = new ProxyBuilder(this);
+        this._proxy = this.proxyBuilder.build(rootConfig);
+        // ─── PersistManager ───────────────────────────────────────────────────────
+        this._persist = new PersistManager(this);
+        // ─── Wire resolve retrigger ──────────────────────────────────────────────
+        const postNotifyHook = this.resolveManager.createPostNotifyHook();
+        if (postNotifyHook)
+            this.hub.setPostNotifyHook(postNotifyHook);
+        // ─── Начальный контекст (Phase 4) ────────────────────────────────────────
+        if (options.context) {
+            this._context = options.context;
+        }
+        // ─── Launch eager resolvers ──────────────────────────────────────────────
+        this.resolveManager.launchEager();
+    }
+    // ─── @internal методы-фасады ──────────────────────────────────────────────
+    /**
+     * Пересчитать состояние узлов.
+     *
+     * - `changedNodes` передан и не пуст → таргетированный пересчёт (быстро)
+     * - иначе → полный пересчёт всего дерева (init, reset, resolve-завершение)
+     *
+     * При первом вызове без changedNodes строит карту групповых зависимостей.
+     *
+     * @internal
+     */
+    recompute(changedNodes) {
+        const { nodeState, nodePaths, nodeParents, groupComputeMap } = this.nodes;
+        const { translate } = this.services;
+        if (changedNodes && changedNodes.size > 0) {
+            return recomputeTargeted(changedNodes, {
+                rootConfig: this.rootConfig,
+                groupComputeMap,
+                nodeState,
+                nodeParents,
+                nodePaths,
+                groupDeps: this.groupDepsMap.deps,
+                valuesCache: this.values,
+                translate,
+            });
+        }
+        const computeNodes = collectGroupComputeNodes(this.rootConfig, groupComputeMap);
+        if (!this.groupDepsMap.isBuilt) {
+            const trackingWrap = this.groupDepsMap.getTrackingWrap();
+            const result = recomputeLeaves(computeNodes, nodeState, this.values, translate, trackingWrap);
+            this.groupDepsMap.markBuilt();
+            return result;
+        }
+        return recomputeLeaves(computeNodes, nodeState, this.values, translate);
+    }
+    /**
+     * Уведомить подписчиков об изменённых узлах.
+     * Пересчитывает dirty-флаги и инкрементирует версии.
+     *
+     * @internal
+     */
+    notifyChanged(changed) {
+        this.hub.notifyChanged(changed, {
+            rootConfig: this.rootConfig,
+            nodeState: this.nodes.nodeState,
+            initialValueMap: this.dirty.initialValueMap,
+            listStates: this.nodes.listStates,
+            nodeParents: this.nodes.nodeParents,
+            nodePaths: this.nodes.nodePaths,
+        });
+    }
+    // ─── @internal pipeline-методы ────────────────────────────────────────────
+    /** @internal Применить bulk-патч к узлу (один recompute + notify). */
+    setValuesNode(node, patch) {
+        const formatted = formatPatch(node, patch, this.values.values);
+        const changed = applyPatch(node, this.nodes.nodeState, formatted, new Set(), this.values);
+        _recomputeAndNotify(changed, () => this.recompute(), (c) => this.notifyChanged(c));
+    }
+    // ─── ProxyStore — публичный API ───────────────────────────────────────────
+    get proxy() {
+        return this._proxy;
+    }
+    get context() {
+        return this._context;
+    }
+    setContext(ctx) {
+        const changedKeys = new Set();
+        for (const key of Object.keys(ctx)) {
+            if (this._context[key] !== ctx[key])
+                changedKeys.add(key);
+        }
+        this._context = { ...this._context, ...ctx };
+        if (changedKeys.size > 0) {
+            const changedPaths = new Set();
+            for (const key of changedKeys)
+                changedPaths.add(`$context.${key}`);
+            this.resolveManager.retriggerByPaths(changedPaths);
+        }
+    }
+    get persist() {
+        return this._persist;
+    }
+    subscribe(node, listener) {
+        return this.hub.subscribe(node, listener);
+    }
+    subscribeGlobal(listener) {
+        return this.hub.subscribeGlobal(listener);
+    }
+    getVersion() {
+        return this.hub.getVersion();
+    }
+    getNodeVersion(node) {
+        return this.hub.getNodeVersion(node);
+    }
+    getValues() {
+        return structuredClone(this.values.values);
+    }
+    setTranslator(t) {
+        if (this.services.setTranslator(t))
+            this.hub.bumpLeafVersions();
+    }
+    setNotifier(fn) {
+        this.services.setNotifier(fn);
+    }
+    submit() {
+        return this.submitPipeline.execute(this.rootConfig);
+    }
+    reset(values) {
+        this.resetPipeline.execute(this.rootConfig, values);
+    }
+    setValues(patch) {
+        this.setValuesNode(this.rootConfig, patch);
+    }
+    /**
+     * Создать или обновить entity (или массив entities) в реестре.
+     *
+     * - Если entity с таким id не существует — создаётся и регистрируются leaf-ноды.
+     * - Если существует — рекурсивный merge; обновлённые leaf-ноды маркируются как изменённые.
+     * - Batch-режим: массив entities обрабатывается одним recompute + notifyChanged.
+     */
+    set(data) {
+        const items = Array.isArray(data) ? data : [data];
+        const changed = this._setEntitiesRaw(items);
+        if (changed.size === 0)
+            return;
+        const recomputed = this.recompute(changed);
+        // Merge original changed: entity leaves have no computed props,
+        // so recomputed may be empty — still need to notify about the entity values.
+        for (const n of changed)
+            recomputed.add(n);
+        this.notifyChanged(recomputed);
+    }
+    /**
+     * Переименовать entity: перенести с oldId на newId.
+     *
+     * - Обновляет EntityRegistry (entities Map, bindings, resolvedCache, id leaf value).
+     * - Обновляет itemIds во всех ListState-объектах.
+     * - Обновляет entityProjectionObjs (переносит POJO-зеркало).
+     * - Уведомляет подписчиков об изменении id leaf.
+     *
+     * No-op если entity с oldId не существует.
+     */
+    rekey(oldId, newId) {
+        const entity = this.entityRegistry.get(oldId);
+        if (!entity)
+            return;
+        // EntityRegistry.rekey() updates: entities Map, id.value, bindings, resolvedCache, allRegisteredLists.itemIds
+        this.entityRegistry.rekey(oldId, newId);
+        // Move entityProjectionObjs entry
+        const projObj = this.entityProjectionObjs.get(oldId);
+        if (projObj) {
+            this.entityProjectionObjs.delete(oldId);
+            this.entityProjectionObjs.set(newId, projObj);
+        }
+        // Notify: id leaf changed
+        const idLeaf = entity.id;
+        const changed = new Set([idLeaf]);
+        // Update nodeState value for id leaf
+        const leafState = this.nodes.nodeState.get(idLeaf);
+        if (leafState) {
+            this.nodes.nodeState.set(idLeaf, { ...leafState, value: newId });
+            if (projObj)
+                projObj["id"] = newId;
+        }
+        const recomputed = this.recompute(changed);
+        for (const n of changed)
+            recomputed.add(n);
+        this.notifyChanged(recomputed);
+    }
+    /**
+     * Удалить entity из реестра по ID.
+     *
+     * - Удаляет leaf-ноды entity из NodeRegistry (computeNodes, groupComputeMap).
+     * - Очищает bindings и resolvedCache.
+     * - Уведомляет подписчиков.
+     *
+     * No-op если entity не существует.
+     */
+    delete(id) {
+        const entityNode = this.entityRegistry.get(id);
+        if (!entityNode)
+            return;
+        // C2: каскадное удаление child-entity, принадлежащих этой entity.
+        // Снимаем копию множества — childrenByOwner мутируется при рекурсивном delete.
+        const childIds = this.entityRegistry.getChildrenByOwner(id);
+        if (childIds && childIds.size > 0) {
+            for (const childId of [...childIds]) {
+                this.delete(childId);
+            }
+        }
+        // Собрать все leaf-ноды entity
+        const deletedLeaves = new Set();
+        this.collectEntityLeaves(entityNode, deletedLeaves);
+        // Удалить leaf-ноды из NodeRegistry (предотвращает утечку памяти)
+        for (const leaf of deletedLeaves) {
+            this.nodes.unregisterLeaf(leaf);
+        }
+        // Phase 4: cleanup per-entity field resolve states
+        this.resolveManager.cleanupEntityResolveStates(id);
+        // Удалить entity из реестра (очищает bindings + resolvedCache)
+        this.entityRegistry.delete(id);
+        // Уведомить подписчиков
+        this.notifyChanged(deletedLeaves);
+    }
+    /**
+     * Сбросить resolved-кэш для entity (все template или конкретный).
+     *
+     * - `invalidate(id)` — очистить весь кэш для entity
+     * - `invalidate(id, templateNode)` — очистить только для конкретной пары
+     *
+     * При следующем mount useForm(entity, template) resolve будет перезапущен.
+     */
+    invalidate(id, templateNode) {
+        this.entityRegistry.clearResolved(id, templateNode);
+    }
+    /**
+     * Submit entity через template.
+     * Вызывается из EntityProjectionProxy.submit().
+     *
+     * 1. submitting: true → notify
+     * 2. Валидация через template field rules (validate)
+     * 3. templateNode.onSubmit(entityProxy, store)
+     * 4. templateNode.afterSubmit(result, { reset })
+     * 5. submitting: false → notify
+     *
+     * @internal
+     */
+    async executeEntityTemplateSubmit(entityId, templateNode, entityProxy) {
+        // Шаг 1: Найти entity в реестре. Если не найдена — ранний выход с ошибкой.
+        const entityNode = this.entityRegistry.get(entityId);
+        if (!entityNode) {
+            return {
+                success: false,
+                errors: [{ path: "", message: `Entity "${entityId}" not found` }],
+            };
+        }
+        // Шаг 2: Получить (или создать) объект состояния привязки { loading, submitting }
+        // для пары (entityId, templateNode). Используется EntityProjectionProxy
+        // для отображения спиннера в UI.
+        const bindingState = this.resolveManager.entityStates.getOrCreate(entityId, templateNode);
+        const entityNodeObj = entityNode;
+        // Шаг 3: Поднять флаг submitting и уведомить подписчиков (React перерендерит
+        // компоненты, привязанные к этой entity — например, кнопка покажет спиннер).
+        bindingState.submitting = true;
+        this.notifyChanged(new Set([entityNodeObj]));
+        try {
+            // Шаг 4: Валидация — рекурсивно обойти template-поля и вызвать validate()
+            // для каждого leaf-поля, у которого есть валидатор. Текущие значения
+            // берутся из nodeState entity.
+            const errors = [];
+            this.collectEntityTemplateErrors(templateNode, entityNode, errors, "");
+            // Если есть ошибки валидации — вернуть их, не вызывая onSubmit.
+            if (errors.length > 0) {
+                return { success: false, errors };
+            }
+            // Шаг 5: Вызвать пользовательский onSubmit(entityProxy, store).
+            // entityProxy — это Proxy entity с template-правилами, store — сам Palistor.
+            // Обычно здесь выполняется API-запрос на сервер.
+            let result;
+            if (typeof templateNode.onSubmit === "function") {
+                result = await templateNode.onSubmit(entityProxy, this);
+            }
+            // Шаг 6: Вызвать afterSubmit(result, { reset }) — хук после успешного submit.
+            // reset для entity template — no-op (у entity нет встроенного сброса, в отличие от form).
+            if (typeof templateNode.afterSubmit === "function") {
+                const reset = () => void 0; // entity template has no built-in reset
+                await templateNode.afterSubmit(result, { reset });
+            }
+            return { success: true, result };
+        }
+        finally {
+            // Шаг 7 (always): Снять флаг submitting и уведомить подписчиков.
+            // finally гарантирует сброс даже при ошибке в onSubmit/afterSubmit.
+            bindingState.submitting = false;
+            this.notifyChanged(new Set([entityNodeObj]));
+        }
+    }
+    // ─── Приватные helpers для entity ────────────────────────────────────────
+    /**
+     * Upsert entities in EntityRegistry and register/update their leaf nodes.
+     * Returns Set of changed leaf nodes. Does NOT call recompute or notifyChanged.
+     *
+     * Used internally by `set()` and by `executeListResolve` via the
+     * `setEntitiesRaw` callback in ResolveManagerDeps.
+     *
+     * Phase 4: when `listNode` is provided, triggers entity field resolves for
+     * each template field entry belonging to that list.
+     *
+     * @internal
+     */
+    _setEntitiesRaw(items, listNode) {
+        const changed = new Set();
+        for (const item of items) {
+            // Создать новый EntityNode или обновить существующий (рекурсивный merge).
+            // Если item.id отсутствует — EntityRegistry сгенерирует временный _tmp_* id.
+            const entityNode = this.entityRegistry.upsert(item);
+            const entityId = entityNode.id.value;
+            // Все entity-ноды живут в namespace "_entity_." для изоляции от config-нод формы.
+            const entityPrefix = `_entity_.${entityId}`;
+            // projectionObj — «зеркало» entity в виде plain POJO { id, field1, field2 }.
+            // Используется в valuesCache.values как элемент массива списка.
+            // Ссылочная идентичность POJO сохраняется между upsert-ами, меняются только значения.
+            let projectionObj = this.entityProjectionObjs.get(entityId);
+            if (!projectionObj) {
+                projectionObj = {};
+                this.entityProjectionObjs.set(entityId, projectionObj);
+            }
+            // DFS-обход entity-дерева: зарегистрировать новые leaf-ноды
+            // или обнаружить изменения в существующих.
+            this.walkAndSyncEntityNode(entityNode, entityPrefix, entityNode, changed, projectionObj);
+            // Entity field resolves are lazy-only: triggered when a component first reads
+            // field.value or field.loading (via queueMicrotask in buildEntityProjectionProxy).
+            // This avoids N×M concurrent requests for large lists where N = entities, M = resolve fields.
+        }
+        return changed;
+    }
+    /**
+     * Синхронизировать valuesCache с составом списка — ЕДИНЫЙ метод (root + per-entity).
+     *
+     * Ветвится по `listState.ownerEntity`:
+     *   - `null`  → root: пишем массив POJO-зеркал в `nodeSlot` config-узла
+     *     (`valuesCache.values.users = [{id:"u1",…}, …]` — тот же массив, что читает
+     *     `proxy.users.value`, поэтому React видит обновление);
+     *   - entity  → per-entity (вариант C, C3/C4): материализуем состав в projectionObj
+     *     владельца по пути списка (`["contacts"]` или `["profile","contacts"]`). Это
+     *     включает вложенный список в `store.getValues()` — projectionObj владельца
+     *     входит в массив корневого списка по ссылке, а child-projectionObj-ы
+     *     рекурсивно материализуют свои списки.
+     *
+     * No-op, если слот/путь/projectionObj владельца отсутствуют.
+     *
+     * @internal
+     */
+    syncListValuesCache(listState) {
+        const materialized = listState.itemIds
+            .map((id) => this.entityProjectionObjs.get(id))
+            .filter((obj) => obj !== undefined);
+        if (listState.ownerEntity === null) {
+            // Root: слот в valuesCache (пара { parent, key }) по config-узлу.
+            const slot = this.values.nodeSlot.get(listState.listConfigNode);
+            if (!slot)
+                return;
+            slot.parent[slot.key] = materialized;
+            return;
+        }
+        // Per-entity: спускаемся к родительскому POJO по пути и пишем состав.
+        const listConfigNode = listState.listConfigNode;
+        const path = this.nodes.listFieldKeys.get(listConfigNode);
+        if (!path || path.length === 0)
+            return;
+        const ownerId = this._entityId(listState.ownerEntity);
+        const projectionObj = this.entityProjectionObjs.get(ownerId);
+        if (!projectionObj)
+            return;
+        let target = projectionObj;
+        for (let i = 0; i < path.length - 1; i++) {
+            const k = path[i];
+            let next = target[k];
+            if (!next || typeof next !== "object" || Array.isArray(next)) {
+                next = {};
+                target[k] = next;
+            }
+            target = next;
+        }
+        target[path[path.length - 1]] = materialized;
+    }
+    /** @internal Текущий id entity (учитывает rekey через nodeState). */
+    _entityId(entity) {
+        const idLeaf = entity.id;
+        return (this.nodes.nodeState.get(idLeaf)?.value ??
+            entity.id.value);
+    }
+    /**
+     * Восстановить состав корневых И per-entity списков из снимка значений
+     * (вариант C, C3 — persist hydrate).
+     *
+     * `applyPatch` пропускает list-узлы, поэтому состав списков восстанавливается
+     * отдельным проходом: для каждого list-поля создаём child-entity, проставляем
+     * owner-ссылку (для вложенных), заполняем `itemIds`/`initialItemIds` и
+     * синхронизируем valuesCache. Рекурсивно обрабатывает nested-of-nested.
+     *
+     * Возвращает множество изменённых узлов для последующего notify.
+     *
+     * @internal
+     */
+    restoreLists(values) {
+        const changed = new Set();
+        this._restoreListsRec(this.rootConfig, values, null, changed);
+        return changed;
+    }
+    _restoreListsRec(configNode, valueObj, ownerEntity, changed) {
+        for (const key of configKeys(configNode)) {
+            const child = configNode[key];
+            if (!child || typeof child !== "object")
+                continue;
+            // Вложенная группа (не список): рекурсия, чтобы достать списки внутри неё.
+            if (!Array.isArray(child)) {
+                if (isGroupNode(child)) {
+                    const nested = valueObj?.[key];
+                    if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+                        this._restoreListsRec(child, nested, ownerEntity, changed);
+                    }
+                }
+                continue;
+            }
+            if (!isListNode(child))
+                continue;
+            const arr = valueObj?.[key];
+            if (!Array.isArray(arr))
+                continue;
+            const listConfigNode = child;
+            const template = child[0];
+            const ids = [];
+            for (const itemObj of arr) {
+                if (!itemObj || typeof itemObj !== "object")
+                    continue;
+                const rawId = itemObj.id;
+                const id = typeof rawId === "string" && rawId.trim() !== "" ? rawId : generateTmpId();
+                const flat = this._stripListFields({ ...itemObj, id }, template);
+                const leafChanged = this._setEntitiesRaw([flat]);
+                for (const n of leafChanged)
+                    changed.add(n);
+                ids.push(id);
+                const childEntity = this.entityRegistry.get(id);
+                if (childEntity) {
+                    if (ownerEntity) {
+                        this.entityRegistry.setEntityOwner(childEntity, this._entityId(ownerEntity), listConfigNode);
+                    }
+                    // Рекурсия во вложенные списки этого item.
+                    this._restoreListsRec(template, itemObj, childEntity, changed);
+                }
+            }
+            if (ownerEntity) {
+                const els = this.entityRegistry.getOrCreateEntityListState(ownerEntity, listConfigNode);
+                els.itemIds = ids;
+                els.initialItemIds = [...ids];
+                this.syncListValuesCache(els);
+                changed.add(els);
+            }
+            else {
+                const listState = this.nodes.listStates.get(listConfigNode);
+                if (listState) {
+                    listState.itemIds = ids;
+                    listState.initialItemIds = [...ids];
+                    this.syncListValuesCache(listState);
+                    // U2: ListState — ключ трекинга; listConfigNode — мост обратной совместимости.
+                    changed.add(listState);
+                    changed.add(listConfigNode);
+                }
+            }
+        }
+    }
+    /**
+     * Вернуть поверхностную копию объекта данных entity без list-полей
+     * (их состав восстанавливается отдельно через EntityListState). Иначе
+     * `createEntityNode` затянул бы массив как обычный leaf-value.
+     */
+    _stripListFields(itemObj, template) {
+        const result = {};
+        for (const key of Object.keys(itemObj)) {
+            const tField = template?.[key];
+            if (Array.isArray(tField))
+                continue; // list-поле — пропускаем
+            result[key] = itemObj[key];
+        }
+        return result;
+    }
+    /**
+     * Рекурсивный обход entity node: регистрирует новые leaf-ноды через
+     * `registerDynamicLeaf` и собирает изменённые в `changed`.
+     *
+     * Также поддерживает entity projection POJO (projectionObj):
+     * - Новые leaf-ноды: регистрируют nodeSlot → projectionObj
+     * - Существующие leaf-ноды: обновляют через updateValuesCacheEntry
+     *
+     * @param node          Текущий узел entity для обхода
+     * @param prefix        Dot-путь текущего узла (e.g. "_entity_.u1")
+     * @param parent        Родительский объект (для регистрации leaf-нод)
+     * @param changed       Множество изменённых узлов (накапливается)
+     * @param projectionObj Plain POJO at the current nesting level for valuesCache
+     */
+    walkAndSyncEntityNode(node, prefix, parent, changed, projectionObj) {
+        // Зарегистрировать dot-path группового узла (e.g. "_entity_.u1", "_entity_.u1.address").
+        // nodePaths используется в compute-подсистеме для определения «группы» листа
+        // (getNodeGroupPath) и при таргетированном recompute.
+        if (!this.nodes.nodePaths.has(parent)) {
+            this.nodes.nodePaths.set(parent, prefix);
+        }
+        for (const key of Object.keys(node)) {
+            const child = node[key];
+            // Пропускаем примитивы (не часть entity-дерева)
+            if (!child || typeof child !== "object")
+                continue;
+            const childObj = child;
+            const childPath = `${prefix}.${key}`;
+            if (isLeafNode(childObj)) {
+                // ── Листовой узел (EntityLeafNode): { value: <текущее значение> } ──
+                const leaf = childObj;
+                if (!this.nodes.nodeState.has(childObj)) {
+                    // Первая встреча с этим leaf — зарегистрировать в NodeRegistry:
+                    // - nodeState: хранит FieldState (value, isVisible, dirty, etc.)
+                    // - nodePaths: маппинг node → dot-path
+                    // - nodeParents: маппинг node → parent group
+                    // Все entity leaf-ы всегда visible, не обязательны, не disabled.
+                    this.nodes.registerDynamicLeaf(childObj, childPath, parent, {
+                        value: leaf.value,
+                        isVisible: true,
+                        isRequired: false,
+                        isDisabled: false,
+                        isReadOnly: false,
+                        dirty: false,
+                        revalidate: false,
+                    });
+                    // Seed initialValueMap so recomputeDirtyTargeted compares against the entity's
+                    // loaded value instead of `undefined` — prevents spurious dirty=true on first load.
+                    this.dirty.initialValueMap.set(childObj, leaf.value);
+                    // Привязать leaf к POJO-зеркалу через nodeSlot.
+                    // При следующих updateValuesCacheEntry(node, newValue)
+                    // значение в projectionObj обновится автоматически за O(1).
+                    if (projectionObj !== undefined) {
+                        this.values.nodeSlot.set(childObj, { parent: projectionObj, key });
+                        projectionObj[key] = leaf.value;
+                    }
+                    changed.add(childObj);
+                }
+                else {
+                    // Leaf уже зарегистрирован — проверяем, изменилось ли значение.
+                    // Это происходит при повторном upsert (обновление entity с сервера).
+                    const state = this.nodes.nodeState.get(childObj);
+                    if (state.value !== leaf.value) {
+                        // Обновляем nodeState напрямую (без writePipeline — это raw-запись)
+                        state.value = leaf.value;
+                        // Обновить projectionObj через nodeSlot: O(1), не нужно искать POJO.
+                        updateValuesCacheEntry(this.values, childObj, leaf.value);
+                        changed.add(childObj);
+                    }
+                    // Если значение не изменилось — leaf не попадёт в changed,
+                    // подписчики не будут уведомлены (оптимизация).
+                }
+            }
+            else {
+                // ── Групповой узел (EntityGroupNode): вложенный объект без "value" ──
+                // Например: address: { city: { value: "Moscow" } }
+                // Создаём вложенный POJO в projectionObj (если нужно) и рекурсируем.
+                let nestedProjectionObj;
+                if (projectionObj !== undefined) {
+                    if (!projectionObj[key] || typeof projectionObj[key] !== "object") {
+                        projectionObj[key] = {};
+                    }
+                    nestedProjectionObj = projectionObj[key];
+                }
+                this.walkAndSyncEntityNode(child, childPath, childObj, changed, nestedProjectionObj);
+            }
+        }
+    }
+    /**
+     * Рекурсивно собрать все leaf-ноды из entity node tree.
+     * Используется в `delete()` для очистки NodeRegistry.
+     */
+    collectEntityLeaves(node, result) {
+        for (const key of Object.keys(node)) {
+            const child = node[key];
+            if (!child || typeof child !== "object")
+                continue;
+            if (isLeafNode(child)) {
+                // Leaf-нода: объект с полем "value" → добавить в результат
+                result.add(child);
+            }
+            else {
+                // Группа — рекурсивно обойти вложенные узлы
+                this.collectEntityLeaves(child, result);
+            }
+        }
+    }
+    /**
+     * Collect validation errors for entity-template fields.
+     * Iterates template fields recursively, calls templateField.validate() with
+     * current entity values.
+     *
+     * @internal
+     */
+    collectEntityTemplateErrors(templateNode, entityNode, errors, parentPath) {
+        const translate = this.services.translate;
+        // Построить plain-объект значений entity — передаётся вторым аргументом
+        // в каждый validate(), чтобы валидатор мог проверять зависимости между полями.
+        // Пример: validate: (v, vals) => vals.password !== vals.confirmPassword ? "Mismatch" : undefined
+        const entityValues = this.buildEntityValuesForTemplate(entityNode);
+        for (const key of configKeys(templateNode)) {
+            const templateField = templateNode[key];
+            if (!templateField || typeof templateField !== "object")
+                continue;
+            // Формируем dot-path для сообщения об ошибке (e.g. "address.city")
+            const path = parentPath ? `${parentPath}.${key}` : key;
+            if (isLeafNode(templateField)) {
+                // Leaf-поле template — проверяем, есть ли validate() функция
+                if (typeof templateField.validate === "function") {
+                    // Извлечь текущее значение из entity. Приоритет:
+                    // 1. nodeState (актуальное значение после write pipeline)
+                    // 2. fallback на entityField.value (если node ещё не зарегистрирован)
+                    const entityField = entityNode[key];
+                    const currentValue = entityField && typeof entityField === "object"
+                        ? this.nodes.nodeState.get(entityField)?.value ?? entityField.value
+                        : undefined;
+                    // Вызвать validate(currentValue, allEntityValues, translateFn).
+                    // Если возвращает строку — это сообщение об ошибке.
+                    // undefined / false = поле валидно.
+                    const result = templateField.validate(currentValue, entityValues, translate);
+                    if (result)
+                        errors.push({ path, message: result });
+                }
+            }
+            else {
+                // Группа template — рекурсия в соответствующий вложенный узел entity.
+                // Template и entity должны иметь одинаковую структуру вложенности.
+                const entityField = entityNode[key];
+                if (entityField && typeof entityField === "object") {
+                    this.collectEntityTemplateErrors(templateField, entityField, errors, path);
+                }
+            }
+        }
+    }
+    /**
+     * Build flat values object from entity node, reading from nodeState.
+     * Used in template validators (collectEntityTemplateErrors).
+     *
+     * @internal
+     */
+    buildEntityValuesForTemplate(entityNode) {
+        // Результат: plain-объект вида { id: "u1", name: "Alice", address: { city: "Moscow" } }
+        const values = {};
+        for (const key of Object.keys(entityNode)) {
+            const field = entityNode[key];
+            if (field && typeof field === "object") {
+                if (isLeafNode(field)) {
+                    // Leaf: читаем value из nodeState (актуальное), fallback на field.value
+                    values[key] =
+                        this.nodes.nodeState.get(field)?.value ??
+                            field.value;
+                }
+                else {
+                    // Группа: рекурсивно собрать вложенный объект
+                    values[key] = this.buildEntityValuesForTemplate(field);
+                }
+            }
+        }
+        return values;
+    }
+}
+//# sourceMappingURL=palistor.js.map