@loom-forge/editor 0.1.0

package/README.md

@@ -0,0 +1,91 @@
+# @loom-forge/editor
+
+O **controller de edição**: a definição num `TreeState` do ApexStore, com ops atômicas em
+transação, undo/redo por snapshot e o patch da mudança a cada commit. Não reimplementa estado,
+transação nem undo — compõe o [ApexStore](https://github.com/andersondrosa).
+
+```bash
+pnpm add @loom-forge/editor @statedelta-apex/tree-state
+```
+
+## `createEditor(definition, opts?)`
+
+```ts
+import { createEditor } from "@loom-forge/editor";
+
+const ed = createEditor(definition, {
+  address: createMyersAddress(), // emite o patch da mudança
+  onChange: (c) => persist(c.patch),
+});
+ed.insert("section-1", { id: "f1", type: "Field" }, 0);
+ed.move("f1", "section-2");
+ed.undo();
+render(ed.getDefinition());
+```
+
+```ts
+function createEditor(definition: DefNode, opts?: CreateEditorOptions): Editor;
+
+interface CreateEditorOptions {
+  treeId?: string;
+  address?: AddressPort; // json-myers — patch por commit
+  onChange?(change: { def: DefNode; patch?: unknown }): void;
+}
+```
+
+| Método                             | Descrição                                                       |
+| ---------------------------------- | --------------------------------------------------------------- |
+| `getDefinition()`                  | definição atual (aninhada), derivada do TreeState               |
+| `insert(parentId, node, atIndex?)` | insere subárvore sob `parentId` (default: fim)                  |
+| `remove(id)`                       | remove o nó + subárvore (**cascade**)                           |
+| `move(id, toParentId, atIndex?)`   | re-parenta + posiciona                                          |
+| `reorder(id, atIndex)`             | reordena dentro do pai atual                                    |
+| `update(id, patch)`                | atualiza props/placement/type/events/layout (não move/renomeia) |
+| `undo()` / `redo()`                | `boolean` — pilha de snapshots                                  |
+| `canUndo()` / `canRedo()`          | `boolean`                                                       |
+| `subscribe(listener)`              | notifica a definição a cada mudança; retorna unsubscribe        |
+
+Cada op é uma **transação atômica** (rollback no throw → sem entrada de undo) e emite o patch
+identity-aware no `onChange`. **Invariante (conformance):** `address.patch(antes, change.patch)` ===
+`ed.getDefinition()`.
+
+### bridge (flat ↔ nested)
+
+```ts
+import { fromNested, toNested, type FlatNode } from "@loom-forge/editor";
+```
+
+`fromNested(def): FlatNode[]` (aninhado → flat, atribui `name=id`/`parentId`/`__order`) e
+`toNested(records): DefNode` (flat → aninhado, ordena por `__order`, remove os campos internos).
+Round-trip garantido: `toNested(fromNested(def)) === def`.
+
+---
+
+## Os vizinhos
+
+O patch vem do [`@loom-forge/address`](../address/README.md) (o `AddressPort`, DI), e é ele que
+faz o `onChange` carregar a mudança em formato de fio. A camada de tipos é o
+[`@loom-forge/check`](../check/README.md). O invariante que prende os três está na suíte de
+conformance: `address.patch(antes, change.patch) === ed.getDefinition()`.
+
+## Um editor por COMPONENTE
+
+O editor segura **uma árvore** — a de um `ComponentDef` — e o `id` é único dentro dela (ADR-205:
+`name = id` no `TreeState`). Num sistema com vários componentes os ids se repetem entre eles,
+então quem edita o documento inteiro mantém **um editor por componente**, e não um do documento.
+Foi assim que a bancada montou o inspetor: cada componente em edição tem o seu `createEditor`,
+o campo do inspetor grava no commit (blur ou `Enter`) — um passo de desfazer por **edição**, não
+por tecla — e `update(id, { props })` / `update(id, { placement })` é a op de cada campo.
+
+Duas consequências que a bancada achou e valem para qualquer consumidor:
+
+- **um id repetido dentro da definição bloqueia a edição** dela até ser corrigido: o editor não
+  tem como apontar para um nó só. Quem acusa é o `checkIdentity` do `@loom-forge/forge`, antes
+  de qualquer op;
+- **trocar a definição por outra autoria** (o texto editado à mão, outra sessão) é outra árvore,
+  que o editor não viu: o histórico recomeça com um `createEditor` novo. Um `undo` que
+  atravessasse a troca desfaria uma mudança que este editor não fez.
+
+O `update(id, patch)` escreve o campo inteiro — em `events`, é a intenção com a cadeia dela
+(`params`, `then`, `catch`; ADR-018 do repo) —, e é o `patch` do `AddressPort` que diz ao fio
+o que mudou por dentro.

package/dist/index.d.ts

@@ -0,0 +1,61 @@
+import { AddressPort, DefNode } from '@loom-forge/core';
+
+interface EditorChange {
+    /** definição (aninhada) após a mudança. */
+    def: DefNode;
+    /** patch identity-aware da mudança (se um AddressPort foi provido). */
+    patch?: unknown;
+}
+interface CreateEditorOptions {
+    treeId?: string;
+    /** AddressPort (json-myers) — emite o patch da mudança no `onChange`. */
+    address?: AddressPort;
+    onChange?(change: EditorChange): void;
+}
+interface Editor {
+    /** definição atual (aninhada), derivada do TreeState. */
+    getDefinition(): DefNode;
+    /** insere uma subárvore sob `parentId`, na posição `atIndex` (default: fim). */
+    insert(parentId: string, node: DefNode, atIndex?: number): void;
+    /** remove o nó e toda a subárvore (cascade). */
+    remove(id: string): void;
+    /** re-parenta para `toParentId` e posiciona em `atIndex`. */
+    move(id: string, toParentId: string, atIndex?: number): void;
+    /** reordena dentro do pai atual. */
+    reorder(id: string, atIndex: number): void;
+    /** atualiza campos do nó (props/placement/type/events/layout…); não move nem renomeia. */
+    update(id: string, patch: Partial<Omit<DefNode, "id" | "children">>): void;
+    undo(): boolean;
+    redo(): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    /** notifica a definição (aninhada) a cada mudança. */
+    subscribe(listener: (def: DefNode) => void): () => void;
+}
+declare function createEditor(definition: DefNode, opts?: CreateEditorOptions): Editor;
+
+/** Record flat de um nó no TreeState. `name` (= id) satisfaz a unicidade de irmãos do
+ *  Apex; `__order` é a ordem entre irmãos (interno). O index signature satisfaz o
+ *  `T extends Record<string, unknown>` do TreeState. */
+interface FlatNode {
+    id: string;
+    parentId: string | null;
+    name: string;
+    type?: string;
+    __order: number;
+    props?: Record<string, unknown>;
+    placement?: unknown;
+    events?: DefNode["events"];
+    layout?: string;
+    fallback?: DefNode["fallback"];
+    requires?: Record<string, string>;
+    version?: string;
+    [key: string]: unknown;
+}
+/** Aninhado → flat (pré-ordem). Atribui `name = id`, `parentId` e `__order` (posição). */
+declare function fromNested(root: DefNode): FlatNode[];
+/** Flat → aninhado. Agrupa por `parentId`, ordena cada grupo por `__order`, e remove os
+ *  campos internos — o `DefNode` resultante é limpo. Assume raiz única. */
+declare function toNested(records: FlatNode[]): DefNode;
+
+export { type CreateEditorOptions, type Editor, type EditorChange, type FlatNode, createEditor, fromNested, toNested };

package/dist/index.js

@@ -0,0 +1,134 @@
+import { createTree } from '@statedelta-apex/tree-state';
+
+// src/controller.ts
+
+// src/bridge.ts
+var INTERNAL = /* @__PURE__ */ new Set(["parentId", "__order", "name"]);
+function fromNested(root) {
+  const out = [];
+  const walk = (node, parentId, order) => {
+    const { children, ...rest } = node;
+    out.push({ ...rest, name: node.id, parentId, __order: order });
+    (children ?? []).forEach((child, i) => walk(child, node.id, i));
+  };
+  walk(root, null, 0);
+  return out;
+}
+function toNested(records) {
+  const byParent = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const key = r.parentId ?? null;
+    const group = byParent.get(key);
+    if (group) group.push(r);
+    else byParent.set(key, [r]);
+  }
+  const strip = (r) => {
+    const node = {};
+    for (const k of Object.keys(r)) if (!INTERNAL.has(k)) node[k] = r[k];
+    return node;
+  };
+  const build = (r) => {
+    const node = strip(r);
+    const kids = (byParent.get(r.id) ?? []).slice().sort((a, b) => a.__order - b.__order).map(build);
+    if (kids.length) node.children = kids;
+    return node;
+  };
+  const roots = (byParent.get(null) ?? []).slice().sort((a, b) => a.__order - b.__order);
+  if (!roots[0]) throw new Error("toNested: defini\xE7\xE3o sem raiz.");
+  return build(roots[0]);
+}
+
+// src/controller.ts
+function createEditor(definition, opts = {}) {
+  const tree = createTree(
+    opts.treeId ?? "loom-editor",
+    fromNested(definition)
+  );
+  const undoStack = [];
+  const redoStack = [];
+  const listeners = /* @__PURE__ */ new Set();
+  const current = () => toNested(tree.getState());
+  const parentOf = (id) => tree.getState().find((r) => r.id === id)?.parentId ?? null;
+  const siblingIds = (parentId) => tree.getState().filter((r) => (r.parentId ?? null) === parentId).sort((a, b) => a.__order - b.__order).map((r) => r.id);
+  const place = (id, parentId, atIndex) => {
+    const sibs = siblingIds(parentId).filter((s) => s !== id);
+    const i = atIndex == null ? sibs.length : Math.max(0, Math.min(atIndex, sibs.length));
+    sibs.splice(i, 0, id);
+    sibs.forEach((sid, k) => tree.update(sid, { __order: k }));
+  };
+  const emit = (before) => {
+    const def = current();
+    opts.onChange?.({ def, patch: opts.address?.diff(before, def) });
+    for (const l of listeners) l(def);
+  };
+  const commit = (fn) => {
+    const before = current();
+    const snap = tree.snapshot();
+    tree.transaction(fn);
+    undoStack.push(snap);
+    redoStack.length = 0;
+    emit(before);
+  };
+  const restoreTo = (snap, counterStack) => {
+    const before = current();
+    counterStack.push(tree.snapshot());
+    tree.restore(snap);
+    emit(before);
+  };
+  return {
+    getDefinition: current,
+    insert(parentId, node, atIndex) {
+      commit(() => {
+        for (const r of fromNested(node))
+          tree.add(r.id === node.id ? { ...r, parentId } : r);
+        place(node.id, parentId, atIndex);
+      });
+    },
+    remove(id) {
+      commit(() => {
+        tree.remove(id);
+      });
+    },
+    move(id, toParentId, atIndex) {
+      commit(() => {
+        tree.move(id, toParentId);
+        place(id, toParentId, atIndex);
+      });
+    },
+    reorder(id, atIndex) {
+      commit(() => place(id, parentOf(id), atIndex));
+    },
+    update(id, patch) {
+      commit(() => {
+        const safe = { ...patch };
+        for (const k of ["id", "parentId", "__order", "name", "children"])
+          delete safe[k];
+        tree.update(id, safe);
+      });
+    },
+    undo() {
+      const snap = undoStack.pop();
+      if (!snap) return false;
+      restoreTo(snap, redoStack);
+      return true;
+    },
+    redo() {
+      const snap = redoStack.pop();
+      if (!snap) return false;
+      restoreTo(snap, undoStack);
+      return true;
+    },
+    canUndo: () => undoStack.length > 0,
+    canRedo: () => redoStack.length > 0,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+
+export { createEditor, fromNested, toNested };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/bridge.ts","../src/controller.ts"],"names":[],"mappings":";;;;;AA6BA,IAAM,2BAAW,IAAI,GAAA,CAAI,CAAC,UAAA,EAAY,SAAA,EAAW,MAAM,CAAC,CAAA;AAGjD,SAAS,WAAW,IAAA,EAA2B;AACpD,EAAA,MAAM,MAAkB,EAAC;AACzB,EAAA,MAAM,IAAA,GAAO,CACX,IAAA,EACA,QAAA,EACA,KAAA,KACS;AACT,IAAA,MAAM,EAAE,QAAA,EAAU,GAAG,IAAA,EAAK,GAAI,IAAA;AAC9B,IAAA,GAAA,CAAI,IAAA,CAAK,EAAE,GAAG,IAAA,EAAM,IAAA,EAAM,KAAK,EAAA,EAAI,QAAA,EAAU,OAAA,EAAS,KAAA,EAAO,CAAA;AAC7D,IAAA,CAAC,QAAA,IAAY,EAAC,EAAG,OAAA,CAAQ,CAAC,KAAA,EAAO,CAAA,KAAM,IAAA,CAAK,KAAA,EAAO,IAAA,CAAK,EAAA,EAAI,CAAC,CAAC,CAAA;AAAA,EAChE,CAAA;AACA,EAAA,IAAA,CAAK,IAAA,EAAM,MAAM,CAAC,CAAA;AAClB,EAAA,OAAO,GAAA;AACT;AAIO,SAAS,SAAS,OAAA,EAA8B;AACrD,EAAA,MAAM,QAAA,uBAAe,GAAA,EAA+B;AACpD,EAAA,KAAA,MAAW,KAAK,OAAA,EAAS;AACvB,IAAA,MAAM,GAAA,GAAM,EAAE,QAAA,IAAY,IAAA;AAC1B,IAAA,MAAM,KAAA,GAAQ,QAAA,CAAS,GAAA,CAAI,GAAG,CAAA;AAC9B,IAAA,IAAI,KAAA,EAAO,KAAA,CAAM,IAAA,CAAK,CAAC,CAAA;AAAA,SAClB,QAAA,CAAS,GAAA,CAAI,GAAA,EAAK,CAAC,CAAC,CAAC,CAAA;AAAA,EAC5B;AAEA,EAAA,MAAM,KAAA,GAAQ,CAAC,CAAA,KAAyB;AACtC,IAAA,MAAM,OAAgC,EAAC;AACvC,IAAA,KAAA,MAAW,CAAA,IAAK,MAAA,CAAO,IAAA,CAAK,CAAC,GAAG,IAAI,CAAC,QAAA,CAAS,GAAA,CAAI,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAA,GAAI,EAAE,CAAC,CAAA;AACnE,IAAA,OAAO,IAAA;AAAA,EACT,CAAA;AACA,EAAA,MAAM,KAAA,GAAQ,CAAC,CAAA,KAAyB;AACtC,IAAA,MAAM,IAAA,GAAO,MAAM,CAAC,CAAA;AACpB,IAAA,MAAM,IAAA,GAAA,CAAQ,SAAS,GAAA,CAAI,CAAA,CAAE,EAAE,CAAA,IAAK,IACjC,KAAA,EAAM,CACN,KAAK,CAAC,CAAA,EAAG,MAAM,CAAA,CAAE,OAAA,GAAU,EAAE,OAAO,CAAA,CACpC,IAAI,KAAK,CAAA;AACZ,IAAA,IAAI,IAAA,CAAK,MAAA,EAAQ,IAAA,CAAK,QAAA,GAAW,IAAA;AACjC,IAAA,OAAO,IAAA;AAAA,EACT,CAAA;AAEA,EAAA,MAAM,SAAS,QAAA,CAAS,GAAA,CAAI,IAAI,CAAA,IAAK,EAAC,EACnC,KAAA,EAAM,CACN,IAAA,CAAK,CAAC,CAAA,EAAG,CAAA,KAAM,CAAA,CAAE,OAAA,GAAU,EAAE,OAAO,CAAA;AACvC,EAAA,IAAI,CAAC,KAAA,CAAM,CAAC,GAAG,MAAM,IAAI,MAAM,qCAA+B,CAAA;AAC9D,EAAA,OAAO,KAAA,CAAM,KAAA,CAAM,CAAC,CAAC,CAAA;AACvB;;;AC/BO,SAAS,YAAA,CACd,UAAA,EACA,IAAA,GAA4B,EAAC,EACrB;AACR,EAAA,MAAM,IAAA,GAAO,UAAA;AAAA,IACX,KAAK,MAAA,IAAU,aAAA;AAAA,IACf,WAAW,UAAU;AAAA,GACvB;AAEA,EAAA,MAAM,YAAoB,EAAC;AAC3B,EAAA,MAAM,YAAoB,EAAC;AAC3B,EAAA,MAAM,SAAA,uBAAgB,GAAA,EAA4B;AAElD,EAAA,MAAM,OAAA,GAAU,MAAe,QAAA,CAAS,IAAA,CAAK,UAAU,CAAA;AACvD,EAAA,MAAM,QAAA,GAAW,CAAC,EAAA,KAChB,IAAA,CAAK,QAAA,EAAS,CAAE,IAAA,CAAK,CAAC,CAAA,KAAM,CAAA,CAAE,EAAA,KAAO,EAAE,GAAG,QAAA,IAAY,IAAA;AACxD,EAAA,MAAM,UAAA,GAAa,CAAC,QAAA,KAClB,IAAA,CACG,QAAA,EAAS,CACT,MAAA,CAAO,CAAC,CAAA,KAAA,CAAO,CAAA,CAAE,QAAA,IAAY,IAAA,MAAU,QAAQ,CAAA,CAC/C,IAAA,CAAK,CAAC,CAAA,EAAG,CAAA,KAAM,CAAA,CAAE,OAAA,GAAU,CAAA,CAAE,OAAO,CAAA,CACpC,GAAA,CAAI,CAAC,CAAA,KAAM,CAAA,CAAE,EAAE,CAAA;AAGpB,EAAA,MAAM,KAAA,GAAQ,CACZ,EAAA,EACA,QAAA,EACA,OAAA,KACS;AACT,IAAA,MAAM,IAAA,GAAO,WAAW,QAAQ,CAAA,CAAE,OAAO,CAAC,CAAA,KAAM,MAAM,EAAE,CAAA;AACxD,IAAA,MAAM,CAAA,GACJ,OAAA,IAAW,IAAA,GACP,IAAA,CAAK,MAAA,GACL,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,IAAA,CAAK,GAAA,CAAI,OAAA,EAAS,IAAA,CAAK,MAAM,CAAC,CAAA;AAChD,IAAA,IAAA,CAAK,MAAA,CAAO,CAAA,EAAG,CAAA,EAAG,EAAE,CAAA;AACpB,IAAA,IAAA,CAAK,OAAA,CAAQ,CAAC,GAAA,EAAK,CAAA,KAAM,IAAA,CAAK,MAAA,CAAO,GAAA,EAAK,EAAE,OAAA,EAAS,CAAA,EAAG,CAAC,CAAA;AAAA,EAC3D,CAAA;AAEA,EAAA,MAAM,IAAA,GAAO,CAAC,MAAA,KAA0B;AACtC,IAAA,MAAM,MAAM,OAAA,EAAQ;AACpB,IAAA,IAAA,CAAK,QAAA,GAAW,EAAE,GAAA,EAAK,KAAA,EAAO,IAAA,CAAK,SAAS,IAAA,CAAK,MAAA,EAAQ,GAAG,CAAA,EAAG,CAAA;AAC/D,IAAA,KAAA,MAAW,CAAA,IAAK,SAAA,EAAW,CAAA,CAAE,GAAG,CAAA;AAAA,EAClC,CAAA;AAEA,EAAA,MAAM,MAAA,GAAS,CAAC,EAAA,KAAyB;AACvC,IAAA,MAAM,SAAS,OAAA,EAAQ;AACvB,IAAA,MAAM,IAAA,GAAO,KAAK,QAAA,EAAS;AAC3B,IAAA,IAAA,CAAK,YAAY,EAAE,CAAA;AACnB,IAAA,SAAA,CAAU,KAAK,IAAI,CAAA;AACnB,IAAA,SAAA,CAAU,MAAA,GAAS,CAAA;AACnB,IAAA,IAAA,CAAK,MAAM,CAAA;AAAA,EACb,CAAA;AACA,EAAA,MAAM,SAAA,GAAY,CAAC,IAAA,EAAY,YAAA,KAA+B;AAC5D,IAAA,MAAM,SAAS,OAAA,EAAQ;AACvB,IAAA,YAAA,CAAa,IAAA,CAAK,IAAA,CAAK,QAAA,EAAU,CAAA;AACjC,IAAA,IAAA,CAAK,QAAQ,IAAI,CAAA;AACjB,IAAA,IAAA,CAAK,MAAM,CAAA;AAAA,EACb,CAAA;AAEA,EAAA,OAAO;AAAA,IACL,aAAA,EAAe,OAAA;AAAA,IACf,MAAA,CAAO,QAAA,EAAU,IAAA,EAAM,OAAA,EAAS;AAC9B,MAAA,MAAA,CAAO,MAAM;AACX,QAAA,KAAA,MAAW,CAAA,IAAK,WAAW,IAAI,CAAA;AAC7B,UAAA,IAAA,CAAK,GAAA,CAAI,CAAA,CAAE,EAAA,KAAO,IAAA,CAAK,EAAA,GAAK,EAAE,GAAG,CAAA,EAAG,QAAA,EAAS,GAAI,CAAC,CAAA;AACpD,QAAA,KAAA,CAAM,IAAA,CAAK,EAAA,EAAI,QAAA,EAAU,OAAO,CAAA;AAAA,MAClC,CAAC,CAAA;AAAA,IACH,CAAA;AAAA,IACA,OAAO,EAAA,EAAI;AACT,MAAA,MAAA,CAAO,MAAM;AACX,QAAA,IAAA,CAAK,OAAO,EAAE,CAAA;AAAA,MAChB,CAAC,CAAA;AAAA,IACH,CAAA;AAAA,IACA,IAAA,CAAK,EAAA,EAAI,UAAA,EAAY,OAAA,EAAS;AAC5B,MAAA,MAAA,CAAO,MAAM;AACX,QAAA,IAAA,CAAK,IAAA,CAAK,IAAI,UAAU,CAAA;AACxB,QAAA,KAAA,CAAM,EAAA,EAAI,YAAY,OAAO,CAAA;AAAA,MAC/B,CAAC,CAAA;AAAA,IACH,CAAA;AAAA,IACA,OAAA,CAAQ,IAAI,OAAA,EAAS;AACnB,MAAA,MAAA,CAAO,MAAM,KAAA,CAAM,EAAA,EAAI,SAAS,EAAE,CAAA,EAAG,OAAO,CAAC,CAAA;AAAA,IAC/C,CAAA;AAAA,IACA,MAAA,CAAO,IAAI,KAAA,EAAO;AAChB,MAAA,MAAA,CAAO,MAAM;AACX,QAAA,MAAM,IAAA,GAAgC,EAAE,GAAG,KAAA,EAAM;AACjD,QAAA,KAAA,MAAW,KAAK,CAAC,IAAA,EAAM,UAAA,EAAY,SAAA,EAAW,QAAQ,UAAU,CAAA;AAC9D,UAAA,OAAO,KAAK,CAAC,CAAA;AACf,QAAA,IAAA,CAAK,MAAA,CAAO,IAAI,IAAI,CAAA;AAAA,MACtB,CAAC,CAAA;AAAA,IACH,CAAA;AAAA,IACA,IAAA,GAAO;AACL,MAAA,MAAM,IAAA,GAAO,UAAU,GAAA,EAAI;AAC3B,MAAA,IAAI,CAAC,MAAM,OAAO,KAAA;AAClB,MAAA,SAAA,CAAU,MAAM,SAAS,CAAA;AACzB,MAAA,OAAO,IAAA;AAAA,IACT,CAAA;AAAA,IACA,IAAA,GAAO;AACL,MAAA,MAAM,IAAA,GAAO,UAAU,GAAA,EAAI;AAC3B,MAAA,IAAI,CAAC,MAAM,OAAO,KAAA;AAClB,MAAA,SAAA,CAAU,MAAM,SAAS,CAAA;AACzB,MAAA,OAAO,IAAA;AAAA,IACT,CAAA;AAAA,IACA,OAAA,EAAS,MAAM,SAAA,CAAU,MAAA,GAAS,CAAA;AAAA,IAClC,OAAA,EAAS,MAAM,SAAA,CAAU,MAAA,GAAS,CAAA;AAAA,IAClC,UAAU,QAAA,EAAU;AAClB,MAAA,SAAA,CAAU,IAAI,QAAQ,CAAA;AACtB,MAAA,OAAO,MAAM;AACX,QAAA,SAAA,CAAU,OAAO,QAAQ,CAAA;AAAA,MAC3B,CAAA;AAAA,IACF;AAAA,GACF;AACF","file":"index.js","sourcesContent":["import type { DefNode } from \"@loom-forge/core\";\n\n/* ──────────────────────────────────────────────────────────────────────────────\n   Bridge flat ↔ nested. O `TreeState` do ApexStore é FLAT (`{id, parentId, name}`,\n   filhos derivados do parentId — modelo filesystem); o `DefNode` é ANINHADO\n   (`children: DefNode[]`). O renderer quer aninhado; o editor trabalha flat (move O(1),\n   cascade, transações). A ordem entre irmãos vira `__order` (bookkeeping do editor),\n   removido na volta — o aninhado fica limpo (ordem = posição no array).\n   ────────────────────────────────────────────────────────────────────────────── */\n\n/** Record flat de um nó no TreeState. `name` (= id) satisfaz a unicidade de irmãos do\n *  Apex; `__order` é a ordem entre irmãos (interno). O index signature satisfaz o\n *  `T extends Record<string, unknown>` do TreeState. */\nexport interface FlatNode {\n  id: string;\n  parentId: string | null;\n  name: string;\n  type?: string;\n  __order: number;\n  props?: Record<string, unknown>;\n  placement?: unknown;\n  events?: DefNode[\"events\"];\n  layout?: string;\n  fallback?: DefNode[\"fallback\"];\n  requires?: Record<string, string>;\n  version?: string;\n  [key: string]: unknown;\n}\n\nconst INTERNAL = new Set([\"parentId\", \"__order\", \"name\"]);\n\n/** Aninhado → flat (pré-ordem). Atribui `name = id`, `parentId` e `__order` (posição). */\nexport function fromNested(root: DefNode): FlatNode[] {\n  const out: FlatNode[] = [];\n  const walk = (\n    node: DefNode,\n    parentId: string | null,\n    order: number,\n  ): void => {\n    const { children, ...rest } = node;\n    out.push({ ...rest, name: node.id, parentId, __order: order });\n    (children ?? []).forEach((child, i) => walk(child, node.id, i));\n  };\n  walk(root, null, 0);\n  return out;\n}\n\n/** Flat → aninhado. Agrupa por `parentId`, ordena cada grupo por `__order`, e remove os\n *  campos internos — o `DefNode` resultante é limpo. Assume raiz única. */\nexport function toNested(records: FlatNode[]): DefNode {\n  const byParent = new Map<string | null, FlatNode[]>();\n  for (const r of records) {\n    const key = r.parentId ?? null;\n    const group = byParent.get(key);\n    if (group) group.push(r);\n    else byParent.set(key, [r]);\n  }\n\n  const strip = (r: FlatNode): DefNode => {\n    const node: Record<string, unknown> = {};\n    for (const k of Object.keys(r)) if (!INTERNAL.has(k)) node[k] = r[k];\n    return node as unknown as DefNode;\n  };\n  const build = (r: FlatNode): DefNode => {\n    const node = strip(r);\n    const kids = (byParent.get(r.id) ?? [])\n      .slice()\n      .sort((a, b) => a.__order - b.__order)\n      .map(build);\n    if (kids.length) node.children = kids;\n    return node;\n  };\n\n  const roots = (byParent.get(null) ?? [])\n    .slice()\n    .sort((a, b) => a.__order - b.__order);\n  if (!roots[0]) throw new Error(\"toNested: definição sem raiz.\");\n  return build(roots[0]);\n}\n","import { createTree } from \"@statedelta-apex/tree-state\";\nimport type { AddressPort, DefNode } from \"@loom-forge/core\";\nimport { fromNested, toNested, type FlatNode } from \"./bridge\";\n\n/* ──────────────────────────────────────────────────────────────────────────────\n   Editor controller sobre o ApexStore — DI/opt-in. A definição vive num `TreeState`\n   (move O(1) / cascade / queries); cada op é uma `transaction` ATÔMICA (rollback no\n   throw); undo/redo via snapshot/restore (pilha); cada commit emite o patch da mudança\n   (json-myers, via AddressPort). Não reimplementa estado/transação/undo — compõe o Apex.\n   A bridge flat↔nested mantém o renderer (que quer aninhado) feliz.\n   ────────────────────────────────────────────────────────────────────────────── */\n\nexport interface EditorChange {\n  /** definição (aninhada) após a mudança. */\n  def: DefNode;\n  /** patch identity-aware da mudança (se um AddressPort foi provido). */\n  patch?: unknown;\n}\n\nexport interface CreateEditorOptions {\n  treeId?: string;\n  /** AddressPort (json-myers) — emite o patch da mudança no `onChange`. */\n  address?: AddressPort;\n  onChange?(change: EditorChange): void;\n}\n\nexport interface Editor {\n  /** definição atual (aninhada), derivada do TreeState. */\n  getDefinition(): DefNode;\n  /** insere uma subárvore sob `parentId`, na posição `atIndex` (default: fim). */\n  insert(parentId: string, node: DefNode, atIndex?: number): void;\n  /** remove o nó e toda a subárvore (cascade). */\n  remove(id: string): void;\n  /** re-parenta para `toParentId` e posiciona em `atIndex`. */\n  move(id: string, toParentId: string, atIndex?: number): void;\n  /** reordena dentro do pai atual. */\n  reorder(id: string, atIndex: number): void;\n  /** atualiza campos do nó (props/placement/type/events/layout…); não move nem renomeia. */\n  update(id: string, patch: Partial<Omit<DefNode, \"id\" | \"children\">>): void;\n  undo(): boolean;\n  redo(): boolean;\n  canUndo(): boolean;\n  canRedo(): boolean;\n  /** notifica a definição (aninhada) a cada mudança. */\n  subscribe(listener: (def: DefNode) => void): () => void;\n}\n\nexport function createEditor(\n  definition: DefNode,\n  opts: CreateEditorOptions = {},\n): Editor {\n  const tree = createTree<FlatNode>(\n    opts.treeId ?? \"loom-editor\",\n    fromNested(definition),\n  );\n  type Snap = ReturnType<typeof tree.snapshot>;\n  const undoStack: Snap[] = [];\n  const redoStack: Snap[] = [];\n  const listeners = new Set<(def: DefNode) => void>();\n\n  const current = (): DefNode => toNested(tree.getState());\n  const parentOf = (id: string): string | null =>\n    tree.getState().find((r) => r.id === id)?.parentId ?? null;\n  const siblingIds = (parentId: string | null): string[] =>\n    tree\n      .getState()\n      .filter((r) => (r.parentId ?? null) === parentId)\n      .sort((a, b) => a.__order - b.__order)\n      .map((r) => r.id);\n\n  /** posiciona `id` entre os irmãos de `parentId` em `atIndex`, renumerando `__order`. */\n  const place = (\n    id: string,\n    parentId: string | null,\n    atIndex?: number,\n  ): void => {\n    const sibs = siblingIds(parentId).filter((s) => s !== id);\n    const i =\n      atIndex == null\n        ? sibs.length\n        : Math.max(0, Math.min(atIndex, sibs.length));\n    sibs.splice(i, 0, id);\n    sibs.forEach((sid, k) => tree.update(sid, { __order: k }));\n  };\n\n  const emit = (before: DefNode): void => {\n    const def = current();\n    opts.onChange?.({ def, patch: opts.address?.diff(before, def) });\n    for (const l of listeners) l(def);\n  };\n  /** transação atômica + entrada de undo + emissão. Throw → rollback, sem undo. */\n  const commit = (fn: () => void): void => {\n    const before = current();\n    const snap = tree.snapshot();\n    tree.transaction(fn);\n    undoStack.push(snap);\n    redoStack.length = 0;\n    emit(before);\n  };\n  const restoreTo = (snap: Snap, counterStack: Snap[]): void => {\n    const before = current();\n    counterStack.push(tree.snapshot());\n    tree.restore(snap);\n    emit(before);\n  };\n\n  return {\n    getDefinition: current,\n    insert(parentId, node, atIndex) {\n      commit(() => {\n        for (const r of fromNested(node))\n          tree.add(r.id === node.id ? { ...r, parentId } : r);\n        place(node.id, parentId, atIndex);\n      });\n    },\n    remove(id) {\n      commit(() => {\n        tree.remove(id);\n      });\n    },\n    move(id, toParentId, atIndex) {\n      commit(() => {\n        tree.move(id, toParentId);\n        place(id, toParentId, atIndex);\n      });\n    },\n    reorder(id, atIndex) {\n      commit(() => place(id, parentOf(id), atIndex));\n    },\n    update(id, patch) {\n      commit(() => {\n        const safe: Record<string, unknown> = { ...patch };\n        for (const k of [\"id\", \"parentId\", \"__order\", \"name\", \"children\"])\n          delete safe[k];\n        tree.update(id, safe);\n      });\n    },\n    undo() {\n      const snap = undoStack.pop();\n      if (!snap) return false;\n      restoreTo(snap, redoStack);\n      return true;\n    },\n    redo() {\n      const snap = redoStack.pop();\n      if (!snap) return false;\n      restoreTo(snap, undoStack);\n      return true;\n    },\n    canUndo: () => undoStack.length > 0,\n    canRedo: () => redoStack.length > 0,\n    subscribe(listener) {\n      listeners.add(listener);\n      return () => {\n        listeners.delete(listener);\n      };\n    },\n  };\n}\n"]}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@loom-forge/editor",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "loom · controller de editor sobre o ApexStore: a definição num TreeState, ops atômicas em transação, undo/redo por snapshot, patch identity-aware por commit. Bridge flat ↔ nested.",
+  "keywords": [
+    "editor",
+    "undo",
+    "redo",
+    "patch",
+    "json"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Anderson D. Rosa",
+    "url": "https://github.com/andersondrosa"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/andersondrosa/loom-forge.git",
+    "directory": "packages/editor"
+  },
+  "homepage": "https://github.com/andersondrosa/loom-forge/tree/main/packages/editor#readme",
+  "bugs": {
+    "url": "https://github.com/andersondrosa/loom-forge/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@loom-forge/core": "0.1.0"
+  },
+  "peerDependencies": {
+    "@statedelta-apex/tree-state": "^0.3.0"
+  },
+  "devDependencies": {
+    "@statedelta-apex/tree-state": "^0.3.0",
+    "json-myers": "^3.2.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.3",
+    "@loom-forge/address": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}