ngx-dynamic-entity 0.0.1 → 1.1.0

package/esm2022/lib/providers/provide-field-types.mjs

@@ -0,0 +1,72 @@
+import { makeEnvironmentProviders } from '@angular/core';
+import { FIELD_TYPE_SETS } from '../tokens/injection-tokens';
+import { TextFieldComponent } from '../field-types/text-field.component';
+import { TextareaFieldComponent } from '../field-types/textarea-field.component';
+import { NumberFieldComponent } from '../field-types/number-field.component';
+import { CurrencyFieldComponent } from '../field-types/currency-field.component';
+import { EmailFieldComponent } from '../field-types/email-field.component';
+import { PasswordFieldComponent } from '../field-types/password-field.component';
+import { CheckboxFieldComponent } from '../field-types/checkbox-field.component';
+import { BooleanFieldComponent } from '../field-types/boolean-field.component';
+import { DateFieldComponent } from '../field-types/date-field.component';
+import { MonthYearFieldComponent } from '../field-types/month-year-field.component';
+import { DropdownFieldComponent } from '../field-types/dropdown-field.component';
+import { RadioFieldComponent } from '../field-types/radio-field.component';
+import { MultiSelectFieldComponent } from '../field-types/multi-select-field.component';
+import { EntityRefFieldComponent } from '../field-types/entity-ref-field.component';
+import { GroupFieldComponent } from '../field-types/group-field.component';
+import { ArrayFieldComponent } from '../field-types/array-field.component';
+import { ImageFieldComponent } from '../field-types/image-field.component';
+import { FileFieldComponent } from '../field-types/file-field.component';
+/**
+ * Field-type registration — the tree-shaking seam.
+ *
+ * `FieldRegistryService` imports no components. Whatever you register here is what gets
+ * bundled, so an app that only uses text/number/dropdown pays for three components and
+ * their imports, not nineteen.
+ *
+ * ```ts
+ * // Everything (convenient; bundles all built-ins):
+ * provideNgxDynamicEntity(), provideBuiltInFieldTypes()
+ *
+ * // Only what this app renders:
+ * provideFieldTypes({ text: TextFieldComponent, number: NumberFieldComponent })
+ * ```
+ *
+ * Both merge into `FIELD_TYPE_REGISTRY`; later registrations win on key collision.
+ */
+/** Map of every built-in field type key → component. Referencing this pulls in all of them. */
+export function builtInFieldTypes() {
+    return {
+        text: TextFieldComponent,
+        textarea: TextareaFieldComponent,
+        number: NumberFieldComponent,
+        currency: CurrencyFieldComponent,
+        email: EmailFieldComponent,
+        password: PasswordFieldComponent,
+        checkbox: CheckboxFieldComponent,
+        boolean: BooleanFieldComponent,
+        date: DateFieldComponent,
+        datetime: DateFieldComponent,
+        monthYear: MonthYearFieldComponent,
+        dropdown: DropdownFieldComponent,
+        radio: RadioFieldComponent,
+        multiSelect: MultiSelectFieldComponent,
+        'entity-ref': EntityRefFieldComponent,
+        group: GroupFieldComponent,
+        array: ArrayFieldComponent,
+        image: ImageFieldComponent,
+        file: FileFieldComponent,
+    };
+}
+/** Register a specific set of field types. Only the components you name are bundled. */
+export function provideFieldTypes(types) {
+    return makeEnvironmentProviders([
+        { provide: FIELD_TYPE_SETS, useValue: types, multi: true },
+    ]);
+}
+/** Register all 19 built-in field type keys. Convenience for apps that use most of them. */
+export function provideBuiltInFieldTypes() {
+    return provideFieldTypes(builtInFieldTypes());
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/providers/provide-ngx-dynamic-entity.mjs

@@ -1,23 +1,22 @@
 import { makeEnvironmentProviders } from '@angular/core';
-import { DYNAMIC_ENTITY_API_URL, ENTITY_REF_REGISTRY, FIELD_TYPE_REGISTRY, HOOK_REGISTRY, MASKED_ROLES, MIGRATION_STRATEGY, VALIDATOR_REGISTRY, } from '../tokens/injection-tokens';
+import { ENTITY_REF_REGISTRY, FIELD_TYPE_REGISTRY, HOOK_REGISTRY, RECORD_MIGRATIONS, LOOKUP_REGISTRY, MASKED_ROLES, VALIDATOR_REGISTRY, } from '../tokens/injection-tokens';
 /**
  * Provider function for ngx-dynamic-entity.
  * All options are optional — consumers provide only what they use (ISP).
  *
  * Usage in app.config.ts:
  *   provideNgxDynamicEntity({
- *     apiUrl: 'http://localhost:3000/api/entities',
  *     maskedRoles: ['IT_SUPPORT'],
  *     entityRefs: { clients: () => clientService.getOptions() },
  *   })
  */
 export const provideNgxDynamicEntity = (config = {}) => makeEnvironmentProviders([
-    { provide: DYNAMIC_ENTITY_API_URL, useValue: config.apiUrl ?? '' },
     { provide: MASKED_ROLES, useValue: config.maskedRoles ?? [] },
-    { provide: MIGRATION_STRATEGY, useValue: config.migrationStrategy ?? 'graceful' },
     { provide: FIELD_TYPE_REGISTRY, useValue: new Map(Object.entries(config.fieldTypes ?? {})) },
     { provide: ENTITY_REF_REGISTRY, useValue: new Map(Object.entries(config.entityRefs ?? {})) },
+    { provide: LOOKUP_REGISTRY, useValue: new Map(Object.entries(config.lookups ?? {})) },
     { provide: VALIDATOR_REGISTRY, useValue: new Map(Object.entries(config.validators ?? {})) },
     { provide: HOOK_REGISTRY, useValue: new Map(Object.entries(config.hooks ?? {})) },
+    { provide: RECORD_MIGRATIONS, useValue: config.migrations ?? [] },
 ]);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZS1uZ3gtZHluYW1pYy1lbnRpdHkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3Byb3ZpZGVycy9wcm92aWRlLW5neC1keW5hbWljLWVudGl0eS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQXdCLHdCQUF3QixFQUFRLE1BQU0sZUFBZSxDQUFDO0FBRXJGLE9BQU8sRUFDTCxtQkFBbUIsRUFDbkIsbUJBQW1CLEVBQ25CLGFBQWEsRUFFYixpQkFBaUIsRUFDakIsZUFBZSxFQUNmLFlBQVksRUFDWixrQkFBa0IsR0FDbkIsTUFBTSw0QkFBNEIsQ0FBQztBQTZCcEM7Ozs7Ozs7OztHQVNHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sdUJBQXVCLEdBQUcsQ0FBQyxTQUFpQyxFQUFFLEVBQXdCLEVBQUUsQ0FDbkcsd0JBQXdCLENBQUM7SUFDdkIsRUFBRSxPQUFPLEVBQUUsWUFBWSxFQUFFLFFBQVEsRUFBRSxNQUFNLENBQUMsV0FBVyxJQUFJLEVBQUUsRUFBRTtJQUM3RCxFQUFFLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxRQUFRLEVBQUUsSUFBSSxHQUFHLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsVUFBVSxJQUFJLEVBQUUsQ0FBQyxDQUFDLEVBQUU7SUFDNUYsRUFBRSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsUUFBUSxFQUFFLElBQUksR0FBRyxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLFVBQVUsSUFBSSxFQUFFLENBQUMsQ0FBQyxFQUFFO0lBQzVGLEVBQUUsT0FBTyxFQUFFLGVBQWUsRUFBRSxRQUFRLEVBQUUsSUFBSSxHQUFHLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsT0FBTyxJQUFJLEVBQUUsQ0FBQyxDQUFDLEVBQUU7SUFDckYsRUFBRSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsUUFBUSxFQUFFLElBQUksR0FBRyxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLFVBQVUsSUFBSSxFQUFFLENBQUMsQ0FBQyxFQUFFO0lBQzNGLEVBQUUsT0FBTyxFQUFFLGFBQWEsRUFBRSxRQUFRLEVBQUUsSUFBSSxHQUFHLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsS0FBSyxJQUFJLEVBQUUsQ0FBQyxDQUFDLEVBQUU7SUFDakYsRUFBRSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsUUFBUSxFQUFFLE1BQU0sQ0FBQyxVQUFVLElBQUksRUFBRSxFQUFFO0NBQ2xFLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVudmlyb25tZW50UHJvdmlkZXJzLCBtYWtlRW52aXJvbm1lbnRQcm92aWRlcnMsIFR5cGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB0eXBlIHsgRW50aXR5UmVmZXJlbmNlTG9hZGVyLCBMb29rdXBMaXN0U291cmNlLCBSZWNvcmRNaWdyYXRpb24gfSBmcm9tICdAZHluYW1pYy1lbnRpdHkvY29yZSc7XG5pbXBvcnQge1xuICBFTlRJVFlfUkVGX1JFR0lTVFJZLFxuICBGSUVMRF9UWVBFX1JFR0lTVFJZLFxuICBIT09LX1JFR0lTVFJZLFxuICB0eXBlIEhvb2tGbixcbiAgUkVDT1JEX01JR1JBVElPTlMsXG4gIExPT0tVUF9SRUdJU1RSWSxcbiAgTUFTS0VEX1JPTEVTLFxuICBWQUxJREFUT1JfUkVHSVNUUlksXG59IGZyb20gJy4uL3Rva2Vucy9pbmplY3Rpb24tdG9rZW5zJztcblxuZXhwb3J0IGludGVyZmFjZSBOZ3hEeW5hbWljRW50aXR5Q29uZmlnIHtcbiAgLyoqIFJvbGVzIHRoYXQgc2VlIG1hc2tlZCBmaWVsZCB2YWx1ZXMgYXMgWFhYWFhYWFhYICovXG4gIG1hc2tlZFJvbGVzPzogc3RyaW5nW107XG4gIC8qKiBDdXN0b20gZmllbGQgdHlwZSBjb21wb25lbnRzIGtleWVkIGJ5IHR5cGUgc3RyaW5nICovXG4gIGZpZWxkVHlwZXM/OiBSZWNvcmQ8c3RyaW5nLCBUeXBlPGFueT4+O1xuICAvKipcbiAgICogRW50aXR5LXJlZiBvcHRpb24gbG9hZGVycyBrZXllZCBieSBlbnRpdHkga2V5IChBRFItMDA2KS5cbiAgICogRWFjaCByZWNlaXZlcyBgeyBwYXJlbnRWYWx1ZSwgZmlsdGVycywgbGFuZyB9YCBhbmQgbWF5IHJldHVybiBhbiBhcnJheSwgUHJvbWlzZSwgb3IgT2JzZXJ2YWJsZS5cbiAgICovXG4gIGVudGl0eVJlZnM/OiBSZWNvcmQ8c3RyaW5nLCBFbnRpdHlSZWZlcmVuY2VMb2FkZXI+O1xuICAvKipcbiAgICogTmFtZWQgbWFzdGVyIGxpc3RzIGtleWVkIGJ5IGxpc3QgbmFtZSwgZm9yIGZpZWxkcyB0aGF0IHNldCBgbGlzdE5hbWVgLlxuICAgKiBFYWNoIG1heSBiZSB0aGUgdmFsdWVzIHRoZW1zZWx2ZXMgKGFycmF5L1Byb21pc2UvT2JzZXJ2YWJsZSkgb3IgYSBsb2FkZXIgZnVuY3Rpb24g4oCUIHByZWZlclxuICAgKiBhIGxvYWRlciBmb3IgYW55dGhpbmcgZmV0Y2hlZCwgc28gYW4gdW51c2VkIGxpc3QgaXMgbmV2ZXIgbG9hZGVkLlxuICAgKi9cbiAgbG9va3Vwcz86IFJlY29yZDxzdHJpbmcsIExvb2t1cExpc3RTb3VyY2U+O1xuICAvKiogQ3VzdG9tIHZhbGlkYXRvciBmdW5jdGlvbnMga2V5ZWQgYnkgdmFsaWRhdG9yIG5hbWUgKi9cbiAgdmFsaWRhdG9ycz86IFJlY29yZDxzdHJpbmcsIGFueT47XG4gIC8qKiBIb29rIGZ1bmN0aW9ucyBrZXllZCBieSBob29rIG5hbWUgKi9cbiAgaG9va3M/OiBSZWNvcmQ8c3RyaW5nLCBIb29rRm4+O1xuICAvKipcbiAgICogT3JkZXJlZCBzdGVwcyB0aGF0IHVwZ3JhZGUgYSBzYXZlZCByZWNvcmQgd2hlbiBgRW50aXR5Rm9ybUNvbmZpZy52ZXJzaW9uYCBtb3ZlcyBhaGVhZFxuICAgKiBvZiB0aGUgcmVjb3JkJ3MgYF9jb25maWdWZXJzaW9uYC4gQXBwbGllZCB0byBgaW5pdGlhbERhdGFgIGJlZm9yZSB0aGUgZm9ybSBpcyBwYXRjaGVkLlxuICAgKi9cbiAgbWlncmF0aW9ucz86IFJlY29yZE1pZ3JhdGlvbltdO1xufVxuXG4vKipcbiAqIFByb3ZpZGVyIGZ1bmN0aW9uIGZvciBuZ3gtZHluYW1pYy1lbnRpdHkuXG4gKiBBbGwgb3B0aW9ucyBhcmUgb3B0aW9uYWwg4oCUIGNvbnN1bWVycyBwcm92aWRlIG9ubHkgd2hhdCB0aGV5IHVzZSAoSVNQKS5cbiAqXG4gKiBVc2FnZSBpbiBhcHAuY29uZmlnLnRzOlxuICogICBwcm92aWRlTmd4RHluYW1pY0VudGl0eSh7XG4gKiAgICAgbWFza2VkUm9sZXM6IFsnSVRfU1VQUE9SVCddLFxuICogICAgIGVudGl0eVJlZnM6IHsgY2xpZW50czogKCkgPT4gY2xpZW50U2VydmljZS5nZXRPcHRpb25zKCkgfSxcbiAqICAgfSlcbiAqL1xuZXhwb3J0IGNvbnN0IHByb3ZpZGVOZ3hEeW5hbWljRW50aXR5ID0gKGNvbmZpZzogTmd4RHluYW1pY0VudGl0eUNvbmZpZyA9IHt9KTogRW52aXJvbm1lbnRQcm92aWRlcnMgPT5cbiAgbWFrZUVudmlyb25tZW50UHJvdmlkZXJzKFtcbiAgICB7IHByb3ZpZGU6IE1BU0tFRF9ST0xFUywgdXNlVmFsdWU6IGNvbmZpZy5tYXNrZWRSb2xlcyA/PyBbXSB9LFxuICAgIHsgcHJvdmlkZTogRklFTERfVFlQRV9SRUdJU1RSWSwgdXNlVmFsdWU6IG5ldyBNYXAoT2JqZWN0LmVudHJpZXMoY29uZmlnLmZpZWxkVHlwZXMgPz8ge30pKSB9LFxuICAgIHsgcHJvdmlkZTogRU5USVRZX1JFRl9SRUdJU1RSWSwgdXNlVmFsdWU6IG5ldyBNYXAoT2JqZWN0LmVudHJpZXMoY29uZmlnLmVudGl0eVJlZnMgPz8ge30pKSB9LFxuICAgIHsgcHJvdmlkZTogTE9PS1VQX1JFR0lTVFJZLCB1c2VWYWx1ZTogbmV3IE1hcChPYmplY3QuZW50cmllcyhjb25maWcubG9va3VwcyA/PyB7fSkpIH0sXG4gICAgeyBwcm92aWRlOiBWQUxJREFUT1JfUkVHSVNUUlksIHVzZVZhbHVlOiBuZXcgTWFwKE9iamVjdC5lbnRyaWVzKGNvbmZpZy52YWxpZGF0b3JzID8/IHt9KSkgfSxcbiAgICB7IHByb3ZpZGU6IEhPT0tfUkVHSVNUUlksIHVzZVZhbHVlOiBuZXcgTWFwKE9iamVjdC5lbnRyaWVzKGNvbmZpZy5ob29rcyA/PyB7fSkpIH0sXG4gICAgeyBwcm92aWRlOiBSRUNPUkRfTUlHUkFUSU9OUywgdXNlVmFsdWU6IGNvbmZpZy5taWdyYXRpb25zID8/IFtdIH0sXG4gIF0pO1xuIl19

package/esm2022/lib/services/cascade-data.service.mjs

@@ -0,0 +1,129 @@
+import { Injectable, inject } from '@angular/core';
+import { applyCascadeFilter } from '@dynamic-entity/core';
+import { EntityRefRegistryService } from './entity-ref-registry.service';
+import { EntityReferenceService } from './entity-reference.service';
+import * as i0 from "@angular/core";
+/**
+ * CascadeDataService — loads entity-reference options and applies parent→child cascades.
+ *
+ * Loaders come from the registry only (ADR-006). This service owns the three things a
+ * field component should not: resolving the loader, coercing whatever it returned
+ * (array | Promise | Observable) into a Promise, and filtering by the parent's value.
+ */
+export class CascadeDataService {
+    registry = inject(EntityRefRegistryService);
+    references = inject(EntityReferenceService);
+    /** Preload runs by formConfigId, so a second call joins the first rather than re-fetching. */
+    preloads = new Map();
+    /** Registry key for a field: explicit `linkedEntityKey`, else the field id. */
+    entityKeyFor(field) {
+        return field.entityReference?.linkedEntityKey ?? field.id;
+    }
+    /** Whether a loader is registered for this field. */
+    canLoad(field) {
+        return this.registry.has(this.entityKeyFor(field));
+    }
+    /**
+     * Load the options for a field, cascade-filtered against `parentValue`.
+     * Returns `[]` when no loader is registered, or when a cascade child has no parent value yet.
+     */
+    async load(field, ctx = {}) {
+        const cfg = field.entityReference;
+        if (!this.canLoad(field))
+            return [];
+        // A cascade child with no parent selection must offer nothing.
+        const hasParentValue = ctx.parentValue !== null && ctx.parentValue !== undefined && ctx.parentValue !== '';
+        if (cfg?.parentField && !hasParentValue)
+            return [];
+        const lang = ctx.lang ?? 'en';
+        // When the cascade can be resolved locally (`lookupFilter`/`lookupPath`), fetch the
+        // unfiltered set once and filter per parent below — switching parent then costs nothing.
+        // Otherwise the loader is the only thing that can narrow the list, so `parentValue` is
+        // passed through and becomes part of the cache identity (one entry per parent).
+        const filtersLocally = !!(cfg?.lookupFilter || cfg?.lookupPath);
+        const options = await this.references.load(this.entityKeyFor(field), {
+            ...ctx,
+            parentValue: filtersLocally ? undefined : ctx.parentValue,
+            filters: { ...(cfg?.filters ?? {}), ...(ctx.filters ?? {}) },
+            displayFields: cfg?.displayFields,
+            lang,
+        });
+        return applyCascadeFilter(options, ctx.parentValue, cfg, lang);
+    }
+    // ─── Preload ────────────────────────────────────────────────────────────────
+    /**
+     * Warm the cache for every entity a config's cascades depend on, so changing a parent
+     * resolves from memory instead of a round-trip.
+     *
+     * Idempotent per `formConfigId`: calling it again returns the in-flight or completed run
+     * rather than re-fetching.
+     */
+    initializeCascadeData(formConfigId, config, lang = 'en') {
+        const existing = this.preloads.get(formConfigId);
+        if (existing)
+            return existing;
+        const fields = this.cascadeFields(config);
+        const run = Promise.all(fields.map(field => this.references.load(this.entityKeyFor(field), {
+            filters: field.entityReference?.filters,
+            displayFields: field.entityReference?.displayFields,
+            lang,
+        }))).then(() => undefined);
+        this.preloads.set(formConfigId, run);
+        return run;
+    }
+    /** Resolves true once `initializeCascadeData` for this config has finished. */
+    async waitForData(formConfigId) {
+        const run = this.preloads.get(formConfigId);
+        if (!run)
+            return false;
+        await run;
+        return true;
+    }
+    /**
+     * Child options for a parent selection, from cache only — no load is triggered.
+     * Returns `[]` when the entity has not been preloaded.
+     */
+    getCachedChildOptions(field, parentValue, lang = 'en') {
+        const cfg = field.entityReference;
+        const cached = this.references.peek(this.entityKeyFor(field), {
+            filters: cfg?.filters,
+            displayFields: cfg?.displayFields,
+            lang,
+        });
+        if (!cached)
+            return [];
+        return applyCascadeFilter(cached, parentValue, cfg, lang);
+    }
+    /** Forget the preload for one config. The option cache itself is untouched. */
+    clearCache(formConfigId) {
+        this.preloads.delete(formConfigId);
+    }
+    /** Every entity-ref field in the config that participates in a cascade. */
+    cascadeFields(config) {
+        const found = [];
+        const walkFields = (fields) => {
+            for (const field of fields ?? []) {
+                const cfg = field.entityReference;
+                if (cfg?.enabled && (cfg.parentField || cfg.lookupPath || cfg.lookupFilter)) {
+                    found.push(field);
+                }
+                walkFields(field.children);
+            }
+        };
+        const walkTabs = (tabs) => {
+            for (const tab of tabs ?? []) {
+                walkFields(tab.fields);
+                walkTabs(tab.children);
+            }
+        };
+        walkTabs(config?.tabs);
+        return found;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CascadeDataService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CascadeDataService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CascadeDataService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cascade-data.service.js","sourceRoot":"","sources":["../../../../src/lib/services/cascade-data.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport type {\n  EntityFormConfig,\n  NestedFieldConfig,\n  NestedTabConfig,\n  ReferenceLoaderContext,\n  ReferenceOption,\n} from '@dynamic-entity/core';\nimport { applyCascadeFilter } from '@dynamic-entity/core';\nimport { EntityRefRegistryService } from './entity-ref-registry.service';\nimport { EntityReferenceService } from './entity-reference.service';\n\n/**\n * CascadeDataService — loads entity-reference options and applies parent→child cascades.\n *\n * Loaders come from the registry only (ADR-006). This service owns the three things a\n * field component should not: resolving the loader, coercing whatever it returned\n * (array | Promise | Observable) into a Promise, and filtering by the parent's value.\n */\n@Injectable({ providedIn: 'root' })\nexport class CascadeDataService {\n  private readonly registry = inject(EntityRefRegistryService);\n  private readonly references = inject(EntityReferenceService);\n\n  /** Preload runs by formConfigId, so a second call joins the first rather than re-fetching. */\n  private readonly preloads = new Map<string, Promise<void>>();\n\n  /** Registry key for a field: explicit `linkedEntityKey`, else the field id. */\n  entityKeyFor(field: NestedFieldConfig): string {\n    return field.entityReference?.linkedEntityKey ?? field.id;\n  }\n\n  /** Whether a loader is registered for this field. */\n  canLoad(field: NestedFieldConfig): boolean {\n    return this.registry.has(this.entityKeyFor(field));\n  }\n\n  /**\n   * Load the options for a field, cascade-filtered against `parentValue`.\n   * Returns `[]` when no loader is registered, or when a cascade child has no parent value yet.\n   */\n  async load(\n    field: NestedFieldConfig,\n    ctx: ReferenceLoaderContext = {},\n  ): Promise<ReferenceOption[]> {\n    const cfg = field.entityReference;\n    if (!this.canLoad(field)) return [];\n\n    // A cascade child with no parent selection must offer nothing.\n    const hasParentValue =\n      ctx.parentValue !== null && ctx.parentValue !== undefined && ctx.parentValue !== '';\n    if (cfg?.parentField && !hasParentValue) return [];\n\n    const lang = ctx.lang ?? 'en';\n\n    // When the cascade can be resolved locally (`lookupFilter`/`lookupPath`), fetch the\n    // unfiltered set once and filter per parent below — switching parent then costs nothing.\n    // Otherwise the loader is the only thing that can narrow the list, so `parentValue` is\n    // passed through and becomes part of the cache identity (one entry per parent).\n    const filtersLocally = !!(cfg?.lookupFilter || cfg?.lookupPath);\n\n    const options = await this.references.load(this.entityKeyFor(field), {\n      ...ctx,\n      parentValue: filtersLocally ? undefined : ctx.parentValue,\n      filters: { ...(cfg?.filters ?? {}), ...(ctx.filters ?? {}) },\n      displayFields: cfg?.displayFields,\n      lang,\n    });\n\n    return applyCascadeFilter(options, ctx.parentValue, cfg, lang);\n  }\n\n  // ─── Preload ────────────────────────────────────────────────────────────────\n\n  /**\n   * Warm the cache for every entity a config's cascades depend on, so changing a parent\n   * resolves from memory instead of a round-trip.\n   *\n   * Idempotent per `formConfigId`: calling it again returns the in-flight or completed run\n   * rather than re-fetching.\n   */\n  initializeCascadeData(formConfigId: string, config: EntityFormConfig, lang = 'en'): Promise<void> {\n    const existing = this.preloads.get(formConfigId);\n    if (existing) return existing;\n\n    const fields = this.cascadeFields(config);\n    const run = Promise.all(\n      fields.map(field =>\n        this.references.load(this.entityKeyFor(field), {\n          filters: field.entityReference?.filters,\n          displayFields: field.entityReference?.displayFields,\n          lang,\n        }),\n      ),\n    ).then(() => undefined);\n\n    this.preloads.set(formConfigId, run);\n    return run;\n  }\n\n  /** Resolves true once `initializeCascadeData` for this config has finished. */\n  async waitForData(formConfigId: string): Promise<boolean> {\n    const run = this.preloads.get(formConfigId);\n    if (!run) return false;\n    await run;\n    return true;\n  }\n\n  /**\n   * Child options for a parent selection, from cache only — no load is triggered.\n   * Returns `[]` when the entity has not been preloaded.\n   */\n  getCachedChildOptions(\n    field: NestedFieldConfig,\n    parentValue: unknown,\n    lang = 'en',\n  ): ReferenceOption[] {\n    const cfg = field.entityReference;\n    const cached = this.references.peek(this.entityKeyFor(field), {\n      filters: cfg?.filters,\n      displayFields: cfg?.displayFields,\n      lang,\n    });\n    if (!cached) return [];\n    return applyCascadeFilter(cached, parentValue, cfg, lang);\n  }\n\n  /** Forget the preload for one config. The option cache itself is untouched. */\n  clearCache(formConfigId: string): void {\n    this.preloads.delete(formConfigId);\n  }\n\n  /** Every entity-ref field in the config that participates in a cascade. */\n  private cascadeFields(config: EntityFormConfig): NestedFieldConfig[] {\n    const found: NestedFieldConfig[] = [];\n    const walkFields = (fields: NestedFieldConfig[] | undefined) => {\n      for (const field of fields ?? []) {\n        const cfg = field.entityReference;\n        if (cfg?.enabled && (cfg.parentField || cfg.lookupPath || cfg.lookupFilter)) {\n          found.push(field);\n        }\n        walkFields(field.children);\n      }\n    };\n    const walkTabs = (tabs: NestedTabConfig[] | undefined) => {\n      for (const tab of tabs ?? []) {\n        walkFields(tab.fields);\n        walkTabs(tab.children);\n      }\n    };\n    walkTabs(config?.tabs);\n    return found;\n  }\n}\n"]}

package/esm2022/lib/services/config-source.service.mjs

@@ -0,0 +1,67 @@
+import { Injectable, Inject, Optional } from '@angular/core';
+import { isObservable, firstValueFrom } from 'rxjs';
+import { CONFIG_SOURCE } from '../tokens/injection-tokens';
+import * as i0 from "@angular/core";
+export class ConfigSourceService {
+    cache = new Map();
+    inFlight = new Map();
+    handler;
+    constructor(handler) {
+        this.handler = handler;
+    }
+    /** Retrieve an entity config by key, with caching and in-flight deduplication. */
+    async getConfig(entityKey) {
+        if (!entityKey || !this.handler)
+            return undefined;
+        if (this.cache.has(entityKey))
+            return this.cache.get(entityKey);
+        if (this.inFlight.has(entityKey))
+            return this.inFlight.get(entityKey);
+        const promise = (async () => {
+            try {
+                const raw = this.handler(entityKey);
+                let resolved;
+                if (isObservable(raw)) {
+                    resolved = await firstValueFrom(raw);
+                }
+                else {
+                    resolved = await Promise.resolve(raw);
+                }
+                if (resolved) {
+                    this.cache.set(entityKey, resolved);
+                }
+                return resolved;
+            }
+            catch (err) {
+                console.warn(`ConfigSourceService failed to load config for entity "${entityKey}"`, err);
+                return undefined;
+            }
+            finally {
+                this.inFlight.delete(entityKey);
+            }
+        })();
+        this.inFlight.set(entityKey, promise);
+        return promise;
+    }
+    /** Clear cached configs (e.g. after a config edit in the builder). */
+    clearCache(entityKey) {
+        if (entityKey) {
+            this.cache.delete(entityKey);
+        }
+        else {
+            this.cache.clear();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConfigSourceService, deps: [{ token: CONFIG_SOURCE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConfigSourceService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConfigSourceService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [CONFIG_SOURCE]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/entity-ref-cache.mjs

@@ -0,0 +1,20 @@
+/** Default in-memory store. Lives as long as the injector that created it. */
+export class InMemoryEntityRefCacheStore {
+    map = new Map();
+    get(key) {
+        return this.map.get(key);
+    }
+    set(key, value) {
+        this.map.set(key, value);
+    }
+    delete(key) {
+        this.map.delete(key);
+    }
+    keys() {
+        return [...this.map.keys()];
+    }
+    clear() {
+        this.map.clear();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/entity-ref-registry.service.mjs

@@ -12,8 +12,8 @@ import * as i0 from "@angular/core";
 export class EntityRefRegistryService {
     registry = inject(ENTITY_REF_REGISTRY, { optional: true }) ?? new Map();
     /**
-     * Get the option loader function for an entity key.
-     * @returns Async function that returns options array, or null if not registered.
+     * Get the option loader for an entity key.
+     * @returns The loader, or null if none is registered.
      */
     resolve(entityKey) {
         return this.registry.get(entityKey) ?? null;
@@ -28,4 +28,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/entity-ref-selection.service.mjs

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * EntityRefSelectionService — the channel an entity-ref field uses to publish *which record*
+ * the user picked, so the owning form can run `autoPatch` against it.
+ *
+ * The control value alone is not enough: `autoPatch` copies fields out of the selected
+ * record, which only the field component has after loading its options.
+ *
+ * Provided at `DynamicFormComponent` level so each form instance gets its own channel;
+ * the `root` fallback keeps standalone field components injectable in isolation.
+ */
+export class EntityRefSelectionService {
+    subject = new Subject();
+    selection$ = this.subject.asObservable();
+    emit(fieldId, option) {
+        this.subject.next({ fieldId, option });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EntityRefSelectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EntityRefSelectionService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EntityRefSelectionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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