ngx-dynamic-entity-builder 1.4.0 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ngx-dynamic-entity-builder",
-  "version": "1.4.0",
+  "version": "1.5.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.4.0",
-    "ngx-dynamic-entity": "^1.4.0",
+    "@dynamic-entity/core": "^1.5.0",
+    "ngx-dynamic-entity": "^1.5.0",
     "rxjs": "^7.0.0"
   },
   "keywords": [

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

@@ -346,6 +346,35 @@ declare class FieldPaletteComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldPaletteComponent, "ngx-field-palette", never, {}, { "pick": "pick"; }, never, never, true, never>;
 }
 
+/** One choosable field: the reference stored, the label shown, and the path behind it. */
+interface FieldPathOption {
+    value: string;
+    label: string;
+    path: string;
+}
+/**
+ * Every field in the config, offered by path.
+ *
+ * Four places in the builder name a field — `showWhen` keys, `patchOnTrue` mappings,
+ * `autoPatch` targets and rule triggers/targets — and each was a free-text box. Typing an id
+ * is the one way left to author an ambiguous reference: ids are unique per scope, so
+ * `address` names nothing in particular once two tabs have one. Choosing from this list
+ * always yields a path.
+ *
+ * `collectFieldScopes` rather than the tab-level view, so a field nested inside a `group` is
+ * offered too, and every entry carries the scope `refOf` needs.
+ */
+declare function fieldPathOptions(config: EntityFormConfig | null | undefined, language: string): FieldPathOption[];
+/**
+ * The options plus whatever is already selected.
+ *
+ * A reference written before paths existed is a bare id, and one written against a field
+ * since deleted is a path nothing answers to. Neither appears in the list, and a `mat-select`
+ * silently drops a value it has no option for — so opening such a config and saving it would
+ * quietly erase the reference. They are kept, and shown as they are.
+ */
+declare function withExistingOptions(options: readonly FieldPathOption[], current: readonly (string | undefined)[]): FieldPathOption[];
+
 /**
  * FieldInspectorComponent — edits every property of the currently selected field.
  */
@@ -358,10 +387,45 @@ declare class FieldInspectorComponent {
     protected labelValue(field: NestedFieldConfig): string;
     protected placeholderValue(field: NestedFieldConfig): string;
     protected optionLabel(option: DropdownOption): string;
+    /**
+     * Every tab a field can live on, sub-tabs included.
+     *
+     * `moveFieldToTab` existed on the store with nothing calling it, so a field authored on the
+     * wrong tab had to be deleted and rebuilt — losing its validators, options and every rule
+     * aimed at it.
+     */
+    protected readonly tabOptions: _angular_core.Signal<{
+        id: string;
+        label: string;
+    }[]>;
+    /**
+     * The tab the selected field currently sits on.
+     *
+     * Looked up by identity rather than parsed out of the path: the scope of
+     * `incident.incidentDetails.incidentTime` is two segments and the field belongs to the
+     * *last* of them, while a field inside a group has the group id in that position and
+     * belongs to no tab of that name at all.
+     */
+    protected currentTabId(field: NestedFieldConfig): string;
+    protected moveToTab(field: NestedFieldConfig, tabId: string): void;
+    /**
+     * Fields offered wherever this inspector names one — the `showWhen` key and both ends of a
+     * `patchOnTrue` mapping. All three were free text, which is the one way left to write a
+     * reference that names two fields at once.
+     */
+    protected readonly fieldOptions: _angular_core.Signal<FieldPathOption[]>;
+    /** Options plus whatever is already selected, so an unknown reference is never dropped. */
+    protected optionsWith(...current: (string | undefined)[]): FieldPathOption[];
     protected showWhenEntries(field: NestedFieldConfig): {
         key: string;
         display: string;
     }[];
+    /**
+     * Seeds a new condition with the first field not already watched.
+     *
+     * It used to seed the literal string `field`, which is not a field id at all — so a new
+     * condition started out referencing nothing and silently hid the field until it was edited.
+     */
     protected addShowWhen(field: NestedFieldConfig): void;
     protected renameShowWhen(field: NestedFieldConfig, oldKey: string, newKey: string): void;
     protected setShowWhenValue(field: NestedFieldConfig, key: string, raw: string): void;
@@ -391,12 +455,6 @@ declare class TabManagerComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabManagerComponent, "ngx-tab-manager", never, {}, {}, never, never, true, never>;
 }
 
-/** One choosable field: the reference stored, the label shown, and the path behind it. */
-interface RuleFieldOption {
-    value: string;
-    label: string;
-    path: string;
-}
 /**
  * RuleFormComponent — dialog/panel form for creating or editing a FormRule.
  */
@@ -406,33 +464,23 @@ declare class RuleFormComponent {
     save: EventEmitter<FormRule>;
     cancel: EventEmitter<void>;
     readonly operators: RuleOperator[];
-    /**
-     * Every field in the config, offered by path.
-     *
-     * Both pickers used to be free text — the trigger was typed by hand and the targets could
-     * not be edited at all, so a rule only ever acted on the field it triggered from. Typing an
-     * id is also the one way left to write an ambiguous reference: ids are unique per scope, so
-     * `address` names nothing in particular once two tabs have one. Choosing from this list
-     * always yields a path.
-     */
-    protected readonly fieldOptions: _angular_core.Signal<RuleFieldOption[]>;
-    /**
-     * The options plus whatever the rule already names.
-     *
-     * A rule written before paths existed holds a bare id, and one written against a field that
-     * has since been deleted holds a path nothing answers to. Neither appears in the list, and a
-     * `mat-select` silently drops a value it has no option for — so opening such a rule and
-     * saving it would quietly erase the reference. They are kept, and shown as they are.
-     */
-    private withExisting;
+    protected readonly fieldOptions: _angular_core.Signal<FieldPathOption[]>;
     /**
      * Methods, not `computed`. Both read `rule`, which is a plain `@Input` object mutated in
      * place rather than a signal — a computed would cache the first evaluation and never see a
      * different rule being edited.
      */
-    protected triggerOptions(): RuleFieldOption[];
-    protected targetOptions(): RuleFieldOption[];
-    /** Field targets only — a rule may also target a tab, which this picker does not manage. */
+    protected triggerOptions(): FieldPathOption[];
+    protected targetOptions(): FieldPathOption[];
+    private cachedTargets;
+    /**
+     * Field targets only — a rule may also target a tab, which this picker does not manage.
+     *
+     * The array identity is held stable while the contents are unchanged. This is bound through
+     * `[ngModel]` on a multi-select, and a fresh array on each call made `ngModel` see a new
+     * value on every change-detection pass: it wrote, which scheduled another pass, which built
+     * another array. Opening the rule editor locked the browser outright.
+     */
     protected targetValues(): string[];
     /**
      * Replaces the field targets, leaving any tab target untouched.
@@ -476,6 +524,17 @@ declare class EntityReferenceConfigComponent {
     protected readonly field: _angular_core.Signal<NestedFieldConfig>;
     /** Sibling fields that can drive a cascade — anything but this field itself. */
     protected readonly parentCandidates: _angular_core.Signal<NestedFieldConfig[]>;
+    private readonly fieldOptions;
+    /**
+     * Cascade parents, offered by path.
+     *
+     * The picker existed but its values were bare ids, which name a field only while no second
+     * scope reuses the id — so the one control that was already a list could still produce an
+     * ambiguous reference.
+     */
+    protected parentOptions(): FieldPathOption[];
+    /** Options plus whatever is already selected, so an unknown reference is never dropped. */
+    protected optionsWith(...current: (string | undefined)[]): FieldPathOption[];
     private readonly filtersParseError;
     protected readonly filtersError: _angular_core.Signal<string>;
     protected ref(field: NestedFieldConfig): ngx_dynamic_entity.EntityReferenceConfig;
@@ -519,5 +578,5 @@ declare class EntityBuilderTreeNodeComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<EntityBuilderTreeNodeComponent, "ngx-entity-builder-tree-node", never, { "field": { "alias": "field"; "required": true; }; "index": { "alias": "index"; "required": true; }; "totalCount": { "alias": "totalCount"; "required": true; }; }, {}, never, never, true, never>;
 }
 
-export { BuilderStore, EntityBuilderCanvasComponent, EntityBuilderComponent, EntityBuilderTreeNodeComponent, EntityReferenceConfigComponent, FieldInspectorComponent, FieldPaletteComponent, FieldRulesListComponent, RuleFormComponent, TabManagerComponent };
-export type { BuilderFieldGroup, BuilderProblem };
+export { BuilderStore, EntityBuilderCanvasComponent, EntityBuilderComponent, EntityBuilderTreeNodeComponent, EntityReferenceConfigComponent, FieldInspectorComponent, FieldPaletteComponent, FieldRulesListComponent, RuleFormComponent, TabManagerComponent, fieldPathOptions, withExistingOptions };
+export type { BuilderFieldGroup, BuilderProblem, FieldPathOption };