ngx-dynamic-entity-builder 1.0.0

package/lib/builder-store.service.d.ts

@@ -0,0 +1,165 @@
+import type { AutoPatchMapping, DropdownOption, EntityFormConfig, EntityPermissions, EntityReferenceConfig, FormRule, NestedFieldConfig, NestedTabConfig, PatchOnTrueMapping, RichFieldType } from '@dynamic-entity/core';
+import { type FlagValidator, type ParamValidator } from './field-catalog';
+import * as i0 from "@angular/core";
+export interface BuilderProblem {
+    level: 'error' | 'warning';
+    message: string;
+    fieldId?: string;
+}
+export declare class BuilderStore {
+    private readonly _config;
+    private readonly _selectedFieldId;
+    private readonly _activeLanguage;
+    /** Rules live beside the config: they are persisted per form, not inside `EntityFormConfig`. */
+    private readonly _rules;
+    /**
+     * Field ids the author owns — set by an explicit rename, or by loading a saved config
+     * whose ids are already live data keys. Ids outside this set are still derived from the
+     * field's label. Builder-session state, deliberately not part of the exported config.
+     */
+    private readonly manualIds;
+    private readonly _isDirty;
+    readonly config: import("@angular/core").Signal<EntityFormConfig>;
+    readonly selectedFieldId: import("@angular/core").Signal<string>;
+    readonly activeLanguage: import("@angular/core").Signal<string>;
+    readonly rules: import("@angular/core").Signal<FormRule[]>;
+    readonly isDirty: import("@angular/core").Signal<boolean>;
+    readonly tabs: import("@angular/core").Signal<NestedTabConfig[]>;
+    readonly fields: import("@angular/core").Signal<NestedFieldConfig[]>;
+    readonly selectedField: import("@angular/core").Signal<NestedFieldConfig>;
+    readonly problems: import("@angular/core").Signal<BuilderProblem[]>;
+    readonly errors: import("@angular/core").Signal<BuilderProblem[]>;
+    readonly isValid: import("@angular/core").Signal<boolean>;
+    load(config: EntityFormConfig): void;
+    reset(entity?: string): void;
+    resetDirty(): void;
+    private emptyConfig;
+    setEntityName(entity: string): void;
+    setDefaultLanguage(language: string): void;
+    setMaskData(mask: boolean): void;
+    setPermission(action: keyof EntityPermissions, roles: string[]): void;
+    setActiveLanguage(language: string): void;
+    private getAllFields;
+    private findFieldInTabs;
+    addField(type: RichFieldType, targetTabId?: string): string;
+    updateField(id: string, patch: Partial<NestedFieldConfig>): void;
+    /**
+     * Rename a field explicitly, pinning the id so it is no longer derived from the label.
+     *
+     * Not reachable from the inspector — the id input is read-only by design. This exists for
+     * programmatic callers that must match an id to an existing data key.
+     */
+    renameField(oldId: string, newId: string): void;
+    /** Whether this field's id is pinned (loaded from storage or explicitly renamed). */
+    hasManualId(id: string): boolean;
+    /**
+     * Move a field to a new id and repoint every id-based reference in the config at it.
+     *
+     * Ids are the wiring between fields — rules, cascades, patches and `showWhen` all address
+     * fields by id — so a rename that only touches `field.id` silently breaks that wiring.
+     * That was survivable while renaming was a rare manual act; label-derived ids make it
+     * routine, so the references move with it.
+     */
+    private applyRename;
+    removeField(id: string): void;
+    duplicateField(id: string): string | null;
+    moveField(id: string, direction: -1 | 1): void;
+    /** Safe reorder for drag & drop within active tab or flat list */
+    reorderField(fromIndex: number, toIndex: number, tabId?: string): void;
+    selectField(id: string | null): void;
+    /**
+     * Set a field's label, and derive the field's id from it: type "Employee Count", get
+     * `employeeCount`. The inspector renders the id read-only, so this is the only way a
+     * new field's id is set.
+     *
+     * Two things stop derivation: a config loaded from storage (its ids are live data keys
+     * that records are already stored under — see `load`), and an explicit `renameField`
+     * call, which remains available to programmatic callers.
+     *
+     * Only the config's default language drives the id; translating a label must not rename
+     * anything.
+     */
+    setFieldLabel(id: 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;
+    toggleFlagValidator(id: string, validator: FlagValidator, on: boolean): void;
+    setParamValidator(id: string, validator: ParamValidator, value: number | null): void;
+    getParamValidator(field: NestedFieldConfig, validator: ParamValidator): number | null;
+    hasFlagValidator(field: NestedFieldConfig, validator: FlagValidator): boolean;
+    /**
+     * Where a choice field's options come from.
+     *
+     * `entity` is absent on purpose: in this model an entity reference is a field *type*
+     * (`entity-ref`), not a data source a dropdown can switch to, so offering it here would mean
+     * mutating the field's type — and rebuilding its control — from a source picker. The
+     * exclusion that matters within a choice field is inline `options` vs `listName`.
+     */
+    fieldDataSource(field: NestedFieldConfig | undefined): 'none' | 'manual' | 'lookup';
+    /**
+     * Switch a choice field's data source, clearing the one it is leaving.
+     *
+     * The reference makes these mutually exclusive (doc §4.4) and it has to stay that way here:
+     * `optionsFor` resolves inline options first, so a field left holding both would silently
+     * ignore its list.
+     */
+    setFieldDataSource(fieldId: string, source: 'none' | 'manual' | 'lookup'): void;
+    /** Set the named list a choice field reads its options from. */
+    setListName(fieldId: string, listName: string): void;
+    /** Link a field to a field defined in another entity configuration (Phase 8). */
+    linkReferencedField(fieldId: string, sourceEntityKey: string, sourceField: NestedFieldConfig): void;
+    /** Unlink a referenced field back to an independent field. */
+    unlinkReferencedField(fieldId: string): void;
+    /** Sync a drifted referenced field with the updated source field definition. */
+    syncReferencedField(fieldId: string, currentSourceField: NestedFieldConfig): void;
+    /** Scan all referenced fields in the config and update their hasDrift state against current source configs. */
+    checkDrift(sourceConfigs: Record<string, EntityFormConfig>): void;
+    addOption(fieldId: string): void;
+    /** Merge language keys into an option. `setOptionLabel` is the usual single-language path. */
+    updateOption(fieldId: string, index: number, patch: DropdownOption): void;
+    /**
+     * Set an option's text for one language.
+     *
+     * An option is a language-keyed object and the displayed text **is** the stored value,
+     * so this is the only way to edit one — there is no separate value to set.
+     */
+    setOptionLabel(fieldId: string, index: number, language: string, value: string): void;
+    removeOption(fieldId: string, index: number): void;
+    /** Merge a patch into a field's `entityReference` block, keeping it enabled. */
+    updateEntityReference(fieldId: string, patch: Partial<EntityReferenceConfig>): void;
+    addAutoPatchMapping(fieldId: string): void;
+    setAutoPatchTargetTab(fieldId: string, targetTab: string): void;
+    updateAutoPatchMapping(fieldId: string, index: number, patch: Partial<AutoPatchMapping>): void;
+    /** Removing the last mapping drops `autoPatch` entirely — no empty config in the export. */
+    removeAutoPatchMapping(fieldId: string, index: number): void;
+    addPatchOnTrueMapping(fieldId: string): void;
+    updatePatchOnTrueMapping(fieldId: string, index: number, patch: Partial<PatchOnTrueMapping>): void;
+    removePatchOnTrueMapping(fieldId: string, index: number): void;
+    /** Replace a field's `showWhen` map; an empty map removes the condition. */
+    setShowWhen(fieldId: string, showWhen: Record<string, unknown> | undefined): void;
+    /** Rules for the field currently selected in the inspector. */
+    readonly rulesForSelectedField: import("@angular/core").Signal<FormRule[]>;
+    loadRules(rules: FormRule[]): void;
+    addRule(rule: FormRule): string;
+    updateRule(id: string, patch: Partial<FormRule>): void;
+    removeRule(id: string): void;
+    toggleRule(id: string, enabled: boolean): void;
+    /** Move a rule in priority order. Priorities are renumbered 1..n so they stay contiguous. */
+    moveRule(id: string, direction: -1 | 1): void;
+    exportRules(): FormRule[];
+    addTab(): string;
+    /** Every tab id in the tree, at any depth. Tab ids must be globally unique — they are paths. */
+    private allTabIds;
+    addSubTab(parentId: string): string;
+    setPrimaryTab(tabId: string): void;
+    updateTab(id: string, patch: Partial<NestedTabConfig>): void;
+    setTabLabel(id: string, language: string, value: string): void;
+    removeTab(id: string): void;
+    moveTab(id: string, direction: -1 | 1): void;
+    exportConfig(): EntityFormConfig;
+    private mutate;
+    private uniqueId;
+    private validate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BuilderStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BuilderStore>;
+}

package/lib/clone.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Deep clone with a JSON fallback.
+ *
+ * `structuredClone` is not universally available (older browsers, and jsdom before v22),
+ * so it must never be called unguarded — an unguarded call throws a ReferenceError and the
+ * caller silently does nothing. Config and rule objects are JSON-safe, so the fallback is
+ * lossless here.
+ */
+export declare function deepClone<T>(value: T): T;

package/lib/components/connection-source-config.component.d.ts

@@ -0,0 +1,16 @@
+import { BuilderStore } from '../builder-store.service';
+import * as i0 from "@angular/core";
+/**
+ * ConnectionSourceConfigComponent — allows configuring connection source settings
+ * for an entity or field (Phase 7.2).
+ */
+export declare class ConnectionSourceConfigComponent {
+    protected readonly store: BuilderStore;
+    protected readonly field: import("@angular/core").Signal<import("ngx-dynamic-entity").NestedFieldConfig>;
+    protected connectionSourceEntity(field: any): string;
+    protected setConnectionSourceEntity(field: any, entity: string): void;
+    protected connectionTargetField(field: any): string;
+    protected setConnectionTargetField(field: any, targetField: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionSourceConfigComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConnectionSourceConfigComponent, "ngx-connection-source-config", never, {}, {}, never, never, true, never>;
+}

package/lib/components/entity-builder-canvas.component.d.ts

@@ -0,0 +1,9 @@
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { BuilderStore } from '../builder-store.service';
+import * as i0 from "@angular/core";
+export declare class EntityBuilderCanvasComponent {
+    protected readonly store: BuilderStore;
+    protected onDrop(event: CdkDragDrop<unknown>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityBuilderCanvasComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntityBuilderCanvasComponent, "ngx-entity-builder-canvas", never, {}, {}, never, never, true, never>;
+}

package/lib/components/entity-builder-tree-node.component.d.ts

@@ -0,0 +1,17 @@
+import { type NestedFieldConfig } from '@dynamic-entity/core';
+import { BuilderStore } from '../builder-store.service';
+import * as i0 from "@angular/core";
+export declare class EntityBuilderTreeNodeComponent {
+    protected readonly store: BuilderStore;
+    field: NestedFieldConfig;
+    index: number;
+    totalCount: number;
+    protected fieldTypeLabel(type: string): string;
+    protected fieldTypeIcon(type: string): string;
+    protected fieldLabel(field: {
+        id: string;
+        label?: any;
+    }): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityBuilderTreeNodeComponent, never>;
+    static ɵcmp: i0.ɵɵ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>;
+}

package/lib/components/entity-reference-config.component.d.ts

@@ -0,0 +1,29 @@
+import type { NestedFieldConfig } from '@dynamic-entity/core';
+import { BuilderStore } from '../builder-store.service';
+import * as i0 from "@angular/core";
+/**
+ * EntityReferenceConfigComponent — authors the `entityReference` block of an entity-ref field:
+ * registry key, display fields, static filters, and the parent→child cascade.
+ *
+ * Also authors `autoPatch`, since the mappings only make sense against the record the
+ * selected reference returns.
+ */
+export declare class EntityReferenceConfigComponent {
+    protected readonly store: BuilderStore;
+    protected readonly field: import("@angular/core").Signal<NestedFieldConfig>;
+    /** Sibling fields that can drive a cascade — anything but this field itself. */
+    protected readonly parentCandidates: import("@angular/core").Signal<NestedFieldConfig[]>;
+    private readonly filtersParseError;
+    protected readonly filtersError: import("@angular/core").Signal<string>;
+    protected ref(field: NestedFieldConfig): import("@dynamic-entity/core").EntityReferenceConfig;
+    protected patchRef(field: NestedFieldConfig, patch: Record<string, unknown>): void;
+    protected fieldLabel(field: NestedFieldConfig): string;
+    protected tabLabel(tabId: string): string;
+    protected displayFieldsText(field: NestedFieldConfig): string;
+    protected setDisplayFields(field: NestedFieldConfig, value: string): void;
+    protected filtersText(field: NestedFieldConfig): string;
+    /** Invalid JSON is reported inline and left unapplied rather than silently dropped. */
+    protected setFilters(field: NestedFieldConfig, value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityReferenceConfigComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntityReferenceConfigComponent, "ngx-entity-reference-config", never, {}, {}, never, never, true, never>;
+}

package/lib/components/field-inspector.component.d.ts

@@ -0,0 +1,33 @@
+import type { DropdownOption, NestedFieldConfig } from '@dynamic-entity/core';
+import { BuilderStore } from '../builder-store.service';
+import { type FieldTypeMeta } from '../field-catalog';
+import * as i0 from "@angular/core";
+/**
+ * FieldInspectorComponent — edits every property of the currently selected field.
+ */
+export declare class FieldInspectorComponent {
+    protected readonly store: BuilderStore;
+    protected readonly field: import("@angular/core").Signal<NestedFieldConfig>;
+    protected readonly meta: import("@angular/core").Signal<FieldTypeMeta>;
+    protected lang(): string;
+    protected toNum(value: unknown): number | null;
+    protected labelValue(field: NestedFieldConfig): string;
+    protected placeholderValue(field: NestedFieldConfig): string;
+    protected optionLabel(option: DropdownOption): string;
+    protected showWhenEntries(field: NestedFieldConfig): {
+        key: string;
+        display: string;
+    }[];
+    protected addShowWhen(field: NestedFieldConfig): void;
+    protected renameShowWhen(field: NestedFieldConfig, oldKey: string, newKey: string): void;
+    protected setShowWhenValue(field: NestedFieldConfig, key: string, raw: string): void;
+    protected removeShowWhen(field: NestedFieldConfig, key: string): void;
+    /**
+     * `showWhen` compares with `!==`, so the authored type has to survive the round trip:
+     * "true"/"false" become booleans and numeric text becomes a number.
+     */
+    private parseShowWhen;
+    private stringifyShowWhen;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldInspectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FieldInspectorComponent, "ngx-field-inspector", never, {}, {}, never, never, true, never>;
+}

package/lib/components/field-palette.component.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from '@angular/core';
+import type { RichFieldType } from '@dynamic-entity/core';
+import { type FieldTypeMeta } from '../field-catalog';
+import * as i0 from "@angular/core";
+/**
+ * FieldPaletteComponent — the list of buildable field types (Angular Material).
+ */
+export declare class FieldPaletteComponent {
+    readonly catalog: readonly FieldTypeMeta[];
+    pick: EventEmitter<RichFieldType>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldPaletteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FieldPaletteComponent, "ngx-field-palette", never, {}, { "pick": "pick"; }, never, never, true, never>;
+}

package/lib/components/field-rules-list.component.d.ts

@@ -0,0 +1,19 @@
+import type { FormRule } from '@dynamic-entity/core';
+import { BuilderStore } from '../builder-store.service';
+import * as i0 from "@angular/core";
+/**
+ * FieldRulesListComponent — the rules attached to the selected field: view, reorder,
+ * enable/disable, edit, delete. `RuleFormComponent` authors one rule; this owns the set.
+ */
+export declare class FieldRulesListComponent {
+    protected readonly store: BuilderStore;
+    /** The rule currently open in the editor — a new draft or a copy of an existing rule. */
+    protected readonly editing: import("@angular/core").WritableSignal<FormRule>;
+    protected startCreate(): void;
+    protected startEdit(rule: FormRule): void;
+    protected commit(rule: FormRule): void;
+    /** One-line human summary: `status EQUAL "archived" → hide`. */
+    protected summarize(rule: FormRule): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldRulesListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FieldRulesListComponent, "ngx-field-rules-list", never, {}, {}, never, never, true, never>;
+}

package/lib/components/referenced-field-config.component.d.ts

@@ -0,0 +1,18 @@
+import { ConfigSourceService } from 'ngx-dynamic-entity';
+import type { NestedFieldConfig } from '@dynamic-entity/core';
+import { BuilderStore } from '../builder-store.service';
+import * as i0 from "@angular/core";
+export declare class ReferencedFieldConfigComponent {
+    protected readonly store: BuilderStore;
+    protected readonly configSource: ConfigSourceService;
+    protected readonly field: import("@angular/core").Signal<NestedFieldConfig>;
+    protected toggleReferenced(field: NestedFieldConfig, enabled: boolean): void;
+    protected updateEntityKey(field: NestedFieldConfig, key: string): void;
+    protected updateFieldId(field: NestedFieldConfig, fieldId: string): void;
+    protected syncWithSource(field: NestedFieldConfig): Promise<void>;
+    private checkDriftForField;
+    private findField;
+    private findFieldInList;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReferencedFieldConfigComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ReferencedFieldConfigComponent, "ngx-referenced-field-config", never, {}, {}, never, never, true, never>;
+}

package/lib/components/rule-form.component.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter } from '@angular/core';
+import type { FormRule, RuleOperator } from '@dynamic-entity/core';
+import * as i0 from "@angular/core";
+/**
+ * RuleFormComponent — dialog/panel form for creating or editing a FormRule.
+ */
+export declare class RuleFormComponent {
+    rule: FormRule;
+    save: EventEmitter<FormRule>;
+    cancel: EventEmitter<void>;
+    readonly operators: RuleOperator[];
+    addCondition(): void;
+    removeCondition(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RuleFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RuleFormComponent, "ngx-rule-form", never, { "rule": { "alias": "rule"; "required": false; }; }, { "save": "save"; "cancel": "cancel"; }, never, never, true, never>;
+}

package/lib/components/tab-manager.component.d.ts

@@ -0,0 +1,19 @@
+import { InjectionToken } from '@angular/core';
+import type { NestedTabConfig } from '@dynamic-entity/core';
+import { BuilderStore } from '../builder-store.service';
+import * as i0 from "@angular/core";
+export declare const SYSTEM_DEFAULT_CAN_EDIT: InjectionToken<(roles: string[]) => boolean>;
+/**
+ * TabManagerComponent — add / rename / reorder / remove tabs & sub-tabs with systemDefault protection.
+ */
+export declare class TabManagerComponent {
+    protected readonly store: BuilderStore;
+    private readonly canEditSystemDefaultsFn;
+    protected lang(): string;
+    protected tabLabel(tab: {
+        label?: any;
+    }): string;
+    protected canEditTab(tab: NestedTabConfig): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabManagerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabManagerComponent, "ngx-tab-manager", never, {}, {}, never, never, true, never>;
+}

package/lib/entity-builder.component.d.ts

@@ -0,0 +1,42 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { type CommonModuleEntry, type EntityFormConfig, type EntityPermissions } from '@dynamic-entity/core';
+import { BuilderStore } from './builder-store.service';
+import * as i0 from "@angular/core";
+/**
+ * EntityBuilderComponent — the top-level visual builder for an EntityFormConfig.
+ */
+export declare class EntityBuilderComponent implements OnChanges {
+    protected readonly store: BuilderStore;
+    /** Existing config to edit. When omitted, the builder starts blank. */
+    config?: EntityFormConfig;
+    /** Languages available for label/placeholder editing. First entry is the default. */
+    languages: string[];
+    /** Optional role list — enables multi-select role pickers for RBAC instead of free text. */
+    availableRoles: string[];
+    /** Optional common-module definitions for module tabs; defaults to the built-in list from core. */
+    commonModules: readonly CommonModuleEntry[];
+    /** Emitted on every change to the working config. */
+    configChange: EventEmitter<EntityFormConfig>;
+    /** Emitted when the user clicks Save. Carries a clean, deep-cloned config. */
+    save: EventEmitter<EntityFormConfig>;
+    protected readonly rbacActions: (keyof EntityPermissions)[];
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    protected onDrop(event: CdkDragDrop<unknown>): void;
+    protected fieldTypeLabel(type: string): string;
+    protected fieldTypeIcon(type: string): string;
+    protected fieldLabel(field: {
+        id: string;
+        label?: any;
+    }): string;
+    protected doSave(): void;
+    protected get json(): string;
+    protected copyJson(): void;
+    protected rolesFor(action: keyof EntityPermissions): readonly string[];
+    protected setRoles(action: keyof EntityPermissions, roles: string[]): void;
+    /** Parse a comma-separated role string into a trimmed, de-duplicated array. */
+    protected setRolesFromText(action: keyof EntityPermissions, text: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityBuilderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntityBuilderComponent, "ngx-entity-builder", never, { "config": { "alias": "config"; "required": false; }; "languages": { "alias": "languages"; "required": false; }; "availableRoles": { "alias": "availableRoles"; "required": false; }; "commonModules": { "alias": "commonModules"; "required": false; }; }, { "configChange": "configChange"; "save": "save"; }, never, ["[ngxBuilderPreview]"], true, never>;
+}

package/lib/field-catalog.d.ts

@@ -0,0 +1,5 @@
+/**
+ * field-catalog.ts — re-exports shared field catalog from @dynamic-entity/core.
+ * Single source of truth shared by both visual builder and renderer.
+ */
+export { FIELD_TYPE_CATALOG, getFieldTypeMeta, humanizeId, createFieldConfig, type FieldTypeMeta, type FlagValidator, type ParamValidator, } from '@dynamic-entity/core';

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "ngx-dynamic-entity-builder",
+  "version": "1.0.0",
+  "description": "Angular 17 standalone visual builder for authoring dynamic-entity EntityConfig (fields, tabs, validators, RBAC).",
+  "dependencies": {
+    "ngx-dynamic-entity": "*",
+    "tslib": "^2.3.0"
+  },
+  "peerDependencies": {
+    "@angular/cdk": "^17.0.0",
+    "@angular/common": "^17.0.0",
+    "@angular/core": "^17.0.0",
+    "@angular/forms": "^17.0.0",
+    "@angular/material": "^17.0.0",
+    "@dynamic-entity/core": "^1.0.0",
+    "ngx-dynamic-entity": "^1.0.0",
+    "rxjs": "^7.0.0"
+  },
+  "keywords": [
+    "angular",
+    "dynamic-entity",
+    "form-builder",
+    "config-builder",
+    "dynamic-forms",
+    "low-code"
+  ],
+  "license": "MIT",
+  "sideEffects": false,
+  "module": "fesm2022/ngx-dynamic-entity-builder.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "esm2022": "./esm2022/ngx-dynamic-entity-builder.mjs",
+      "esm": "./esm2022/ngx-dynamic-entity-builder.mjs",
+      "default": "./fesm2022/ngx-dynamic-entity-builder.mjs"
+    }
+  }
+}

package/public-api.d.ts

@@ -0,0 +1,13 @@
+export * from './lib/entity-builder.component';
+export * from './lib/components/field-palette.component';
+export * from './lib/components/field-inspector.component';
+export * from './lib/components/tab-manager.component';
+export * from './lib/components/rule-form.component';
+export * from './lib/components/field-rules-list.component';
+export * from './lib/components/entity-reference-config.component';
+export * from './lib/components/connection-source-config.component';
+export * from './lib/components/entity-builder-canvas.component';
+export * from './lib/components/entity-builder-tree-node.component';
+export * from './lib/builder-store.service';
+export * from './lib/field-catalog';
+export type { EntityFormConfig, NestedTabConfig, NestedFieldConfig, RichFieldType, DropdownOption, EntityPermissions, EntityReferenceConfig, AutoPatchConfig, AutoPatchMapping, PatchOnTrueMapping, FormRule, RuleCondition, RuleAction, RuleOperator, } from '@dynamic-entity/core';