ngx-dynamic-entity-builder 1.6.0 → 1.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ngx-dynamic-entity-builder",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "Angular standalone visual builder for authoring dynamic-entity EntityConfig (fields, tabs, validators, RBAC).",
   "//typings": "Local workspace resolution only: ng-packagr 21 writes types/ngx-dynamic-entity-builder.d.ts into dist/package.json. Do NOT add a 'main' field here — ng-packagr does not generate one, so it would be copied verbatim and resolve wrongly in the published package.",
   "typings": "types/ngx-dynamic-entity-builder.d.ts",
@@ -10,8 +10,8 @@
     "@angular/core": "^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0 || ^22.0.0",
     "@angular/forms": "^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0 || ^22.0.0",
     "@angular/material": "^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0 || ^22.0.0",
-    "@dynamic-entity/core": "^1.6.0",
-    "ngx-dynamic-entity": "^1.6.0",
+    "@dynamic-entity/core": "^1.8.0",
+    "ngx-dynamic-entity": "^1.8.0",
     "rxjs": "^7.0.0"
   },
   "keywords": [

package/types/ngx-dynamic-entity-builder.d.ts

@@ -46,6 +46,39 @@ declare class BuilderStore {
      * made any role-checking predicate answer false for everyone.
      */
     private readonly _userRoles;
+    private readonly history;
+    private readonly cursor;
+    private readonly historyLength;
+    private lastEditAt;
+    /** Consecutive edits closer together than this fold into one undo step. */
+    private static readonly COALESCE_MS;
+    readonly canUndo: _angular_core.Signal<boolean>;
+    readonly canRedo: _angular_core.Signal<boolean>;
+    /**
+     * Fold the current state into history.
+     *
+     * Called explicitly by the write paths rather than from an `effect`. An effect would have
+     * been fewer call sites, but it requires an injection context: `BuilderStore` had no
+     * constructor, so `new BuilderStore()` was legal, and adding one broke every caller that
+     * did it with NG0203. Explicit calls also make the timing deterministic — a test can
+     * assert straight after an edit instead of flushing effects first.
+     *
+     * Calling it twice for one operation is harmless: the second call sees the same signal
+     * references already at the cursor and returns.
+     *
+     * `setFieldLabel` is bound to a keystroke, so recording every emission would make undo
+     * walk back one character at a time. Two consecutive edits merge when they land inside
+     * `COALESCE_MS` *and* the structure is unchanged — a rename coalesces, while adding,
+     * removing or moving anything always earns its own step however fast it is clicked.
+     */
+    private record;
+    /** Counts that distinguish a structural edit from a value edit. */
+    private shapeOf;
+    /** Start history again from the state just loaded. Nothing before it is undoable. */
+    private resetHistory;
+    undo(): void;
+    redo(): void;
+    private applyHistory;
     readonly config: _angular_core.Signal<EntityFormConfig>;
     readonly selectedFieldId: _angular_core.Signal<string>;
     readonly activeLanguage: _angular_core.Signal<string>;
@@ -109,7 +142,36 @@ declare class BuilderStore {
      * therefore see deeper than `fields()`, which stops at a tab's own fields.
      */
     private allFieldIds;
+    /**
+     * Resolve a field by key, where a key is either its `refererField` path or a bare id.
+     *
+     * Every resolution in this store funnels through here, which is why a bare id was enough
+     * to edit the wrong field: with `personal.address` and `work.address` both present, the
+     * first match won, so selecting or editing the second one silently addressed the first.
+     *
+     * The path is tried across the whole tree before any bare id is, so an exact key never
+     * loses to a nearer-but-wrong match. Bare ids still resolve — every existing caller and
+     * spec passes one, and for an unambiguous id it is the same field either way.
+     */
     private findFieldInTabs;
+    private findFieldBy;
+    /**
+     * The key a caller should hand back to address this exact field. Templates use it so a
+     * click on the second of two same-named fields selects that one.
+     */
+    keyOf(field: {
+        id: string;
+        refererField?: string;
+    }): string;
+    /**
+     * Whether this exact field is the selected one.
+     *
+     * Not `selectedFieldId() === field.id`: selection may hold a bare id or a path depending
+     * on who set it, and with two fields sharing an id a bare comparison lights up both rows
+     * — or neither, once the click starts storing a path. Resolving both sides answers for
+     * the field itself.
+     */
+    isSelected(field: NestedFieldConfig): boolean;
     addField(type: RichFieldType, targetTabId?: string): string;
     updateField(id: string, patch: Partial<NestedFieldConfig>): void;
     /**
@@ -129,10 +191,16 @@ declare class BuilderStore {
      * That was survivable while renaming was a rare manual act; label-derived ids make it
      * routine, so the references move with it.
      */
+    /**
+     * `key` addresses the field to rename; `oldId` is the bare id every *reference* to it
+     * carries. They were one parameter, which worked only while an id was unique across the
+     * config: resolving needs the path, while `showWhen`, `parentField`, `autoPatch` targets
+     * and rules are all keyed by bare id and never match a path.
+     */
     private applyRename;
-    removeField(id: string): void;
+    removeField(key: string): void;
     duplicateField(id: string): string | null;
-    moveField(id: string, direction: -1 | 1): void;
+    moveField(key: string, direction: -1 | 1): void;
     /**
      * Moves a field to another tab, keeping its id.
      *
@@ -160,7 +228,7 @@ declare class BuilderStore {
      * Only the config's default language drives the id; translating a label must not rename
      * anything.
      */
-    setFieldLabel(id: string, language: string, value: string): void;
+    setFieldLabel(key: string, language: string, value: string): void;
     /** `derived`, or `derived_2`, `derived_3`… if another field already holds it. */
     private availableId;
     setFieldPlaceholder(id: string, language: string, value: string): void;
@@ -324,6 +392,13 @@ declare class EntityBuilderComponent implements OnChanges {
     save: EventEmitter<EntityFormConfig>;
     protected readonly rbacActions: (keyof EntityPermissions)[];
     constructor();
+    /**
+     * Ctrl/Cmd+Z and Ctrl/Cmd+Shift+Z, but only when the user is not typing.
+     *
+     * A textarea or input has its own undo stack, and hijacking it would make Ctrl+Z revert a
+     * whole structural edit when the author only wanted to take back a character.
+     */
+    protected onKeydown(event: KeyboardEvent): void;
     ngOnChanges(changes: SimpleChanges): void;
     protected doSave(): void;
     protected get json(): string;