ngx-dynamic-entity 0.0.1 → 1.1.0

package/esm2022/lib/services/lookup-registry.service.mjs

@@ -0,0 +1,246 @@
+import { Injectable, inject } from '@angular/core';
+import { lookupValuesToOptions, normalizeLookupValues, resolveLabel } from '@dynamic-entity/core';
+import { LOOKUP_REGISTRY } from '../tokens/injection-tokens';
+import * as i0 from "@angular/core";
+/** Cache-key field separator. Kept out of template literals so it stays visible in source. */
+const SEP = '|';
+/**
+ * LookupRegistryService — the cache in front of consumer-registered master lists.
+ *
+ * Three layers, deliberately the same shape as `EntityReferenceService`, because the problem is
+ * the same: one list is typically used by many fields across many entities.
+ *  1. **options** — resolved `DropdownOption[]` per (list name, lang).
+ *  2. **in-flight** — the pending Promise, so N fields on one list trigger one load, not N.
+ *  3. **labels** — synchronous value → text (parity plan §6.2). This is not a nicety: since
+ *     `viewMode` defaults to true a record opens read-only, so rendering a stored value as
+ *     text is the *first* thing a `listName` field has to do. An async-only registry would
+ *     paint the raw stored value and then flip, on every record open.
+ *
+ * A failed load rejects and caches nothing, so one transient error does not serve an empty
+ * list forever — the same fix made for entity references in phase 5.
+ */
+export class LookupRegistryService {
+    registry = inject(LOOKUP_REGISTRY, { optional: true }) ?? new Map();
+    /** `listName|lang` -> resolved options. */
+    options = new Map();
+    /** `listName|lang` -> normalised values, so a consumer can reach `code` / `isSystemDefined`. */
+    values = new Map();
+    /** Loads in progress, keyed as above. */
+    inFlight = new Map();
+    /** `listName|lang|text` -> display text, for the synchronous read-only path. */
+    labels = new Map();
+    has(listName) {
+        return this.registry.has(listName);
+    }
+    /**
+     * Options for a named list, from cache when present.
+     * Concurrent callers with the same key share one load.
+     */
+    async load(listName, lang = 'en') {
+        const key = this.cacheKey(listName, lang);
+        const cached = this.options.get(key);
+        if (cached)
+            return cached;
+        const pending = this.inFlight.get(key);
+        if (pending)
+            return pending;
+        const source = this.registry.get(listName);
+        if (source === undefined)
+            return [];
+        const load = this.invoke(source, lang).then(raw => {
+            const values = normalizeLookupValues(raw);
+            const options = lookupValuesToOptions(values);
+            this.values.set(key, values);
+            this.options.set(key, options);
+            this.rememberLabels(listName, lang, options);
+            return options;
+        });
+        // Only the `.then` above writes to the cache, and a rejection skips it: the caller still
+        // gets an empty list, but the next call retries instead of reading a poisoned entry.
+        const guarded = load
+            .catch(() => [])
+            .finally(() => this.inFlight.delete(key));
+        this.inFlight.set(key, guarded);
+        return guarded;
+    }
+    /** Cached options without triggering a load. `undefined` when not loaded. */
+    peek(listName, lang = 'en') {
+        return this.options.get(this.cacheKey(listName, lang));
+    }
+    /**
+     * Cached list values, carrying `_id`, `code`, `isSystemDefined` and `from`.
+     * The library never reads those; this is the seam for a consumer that needs them.
+     */
+    valuesFor(listName, lang = 'en') {
+        return this.values.get(this.cacheKey(listName, lang));
+    }
+    /**
+     * Display text for a stored value, synchronously. `undefined` when the list has not loaded
+     * or holds no matching value — the caller keeps its own fallback, which is the stored text.
+     *
+     * Every language of an option is indexed, so a record saved under one language renders in
+     * another: a value stored as `'Aktiv'` resolves to `'Active'` under `lang: 'en'`.
+     */
+    labelFor(listName, value, lang = 'en') {
+        if (!listName || value === null || value === undefined || value === '')
+            return undefined;
+        for (const text of this.candidateTexts(value, lang)) {
+            const hit = this.labels.get(this.labelKey(listName, lang, text));
+            if (hit)
+                return hit;
+        }
+        return undefined;
+    }
+    // ─── Field-level resolution — inline options win, else `listName` ────────────
+    /** True when this field's options have to come from the registry. */
+    needsResolve(field) {
+        return !!field?.listName && !field.options?.length;
+    }
+    /**
+     * The options to render right now, without awaiting: inline options, else whatever the
+     * registry already holds. Empty on a cold miss — pair with `resolveOptions`.
+     */
+    optionsFor(field, lang = 'en') {
+        if (!field)
+            return [];
+        if (field.options?.length)
+            return field.options;
+        if (!field.listName)
+            return [];
+        return this.peek(field.listName, lang) ?? [];
+    }
+    /** The options for a field, loading the named list if needed. */
+    resolveOptions(field, lang = 'en') {
+        if (!this.needsResolve(field))
+            return Promise.resolve(this.optionsFor(field, lang));
+        return this.load(field.listName, lang);
+    }
+    /** Drop everything cached for one list, leaving other lists intact. */
+    invalidate(listName) {
+        const prefix = `${listName}${SEP}`;
+        for (const map of [this.options, this.values, this.inFlight]) {
+            for (const key of [...map.keys()]) {
+                if (key.startsWith(prefix))
+                    map.delete(key);
+            }
+        }
+        for (const key of [...this.labels.keys()]) {
+            if (key.startsWith(prefix))
+                this.labels.delete(key);
+        }
+    }
+    clear() {
+        this.options.clear();
+        this.values.clear();
+        this.inFlight.clear();
+        this.labels.clear();
+    }
+    // ─── Internals ──────────────────────────────────────────────────────────────
+    cacheKey(listName, lang) {
+        return [listName, lang].join(SEP);
+    }
+    labelKey(listName, lang, text) {
+        return [listName, lang, text].join(SEP);
+    }
+    /** Index an option under every language it carries, so any stored spelling finds it. */
+    rememberLabels(listName, lang, options) {
+        for (const option of options) {
+            const display = resolveLabel(option, lang);
+            if (!display)
+                continue;
+            for (const text of Object.values(option)) {
+                if (typeof text === 'string' && text !== '') {
+                    this.labels.set(this.labelKey(listName, lang, text), display);
+                }
+            }
+        }
+    }
+    /** The texts a stored value could have been indexed under. */
+    candidateTexts(value, lang) {
+        if (typeof value === 'object') {
+            const texts = Object.values(value).filter((v) => typeof v === 'string' && v !== '');
+            const resolved = resolveLabel(value, lang);
+            return resolved ? [resolved, ...texts] : texts;
+        }
+        return [String(value)];
+    }
+    // ─── Source coercion (values | loader, array | Promise | Observable) ─────────
+    invoke(source, lang) {
+        let result;
+        try {
+            result = typeof source === 'function' ? source({ lang }) : source;
+        }
+        catch (err) {
+            // Reject rather than resolve empty: `load` must be able to tell failure from an empty
+            // list, or it would cache the failure.
+            return Promise.reject(err);
+        }
+        return this.toPromise(result);
+    }
+    toPromise(result) {
+        if (Array.isArray(result))
+            return Promise.resolve(result);
+        if (this.isSubscribable(result)) {
+            // First emission wins, so a stream that stays open still resolves the load.
+            return new Promise((resolve, reject) => {
+                let settled = false;
+                const settle = (fn) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    fn();
+                };
+                result.subscribe({
+                    next: value => settle(() => resolve(value ?? [])),
+                    error: err => settle(() => reject(err)),
+                    // Completing without emitting is a legitimate empty list, and is cached.
+                    complete: () => settle(() => resolve([])),
+                });
+            });
+        }
+        return Promise.resolve(result);
+    }
+    isSubscribable(value) {
+        return (typeof value === 'object' &&
+            value !== null &&
+            typeof value.subscribe === 'function');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LookupRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LookupRegistryService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LookupRegistryService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+const hostLastConfig = new WeakMap();
+/**
+ * Point a choice component's `options` signal at the right source (parity plan §6.3).
+ *
+ * Called from the `field` / `language` input setters of `dropdown`, `radio` and `multiSelect` —
+ * the wiring is theirs, the decision is the service's, which is what keeps the ADR-008
+ * five-input contract intact: options are never pushed in as a sixth input.
+ *
+ * Setters rather than `ngOnChanges` on purpose. `ngOnChanges` only fires for inputs Angular
+ * itself sets, so a component whose `field` is assigned directly — which the field specs do,
+ * and any consumer holding a `ComponentRef` may do — would render no options at all.
+ *
+ * Paints synchronously first (inline options, or a warm list), then fills in when a cold list
+ * lands. The late result is dropped if the field or language changed while it was in flight.
+ */
+export function refreshChoiceOptions(host, lookups) {
+    const last = hostLastConfig.get(host);
+    if (last && last.field === host.field && last.lang === host.language) {
+        return;
+    }
+    hostLastConfig.set(host, { field: host.field, lang: host.language });
+    host.options.set(lookups.optionsFor(host.field, host.language));
+    if (!lookups.needsResolve(host.field))
+        return;
+    const listName = host.field?.listName;
+    const lang = host.language;
+    void lookups.resolveOptions(host.field, host.language).then(options => {
+        if (host.field?.listName === listName && host.language === lang)
+            host.options.set(options);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lookup-registry.service.js","sourceRoot":"","sources":["../../../../src/lib/services/lookup-registry.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject, type WritableSignal } from '@angular/core';\nimport type {\n  DropdownOption,\n  LookupListLoader,\n  LookupListResult,\n  LookupListSource,\n  LookupListValue,\n  NestedFieldConfig,\n  RawLookupListValue,\n  Subscribable,\n} from '@dynamic-entity/core';\nimport { lookupValuesToOptions, normalizeLookupValues, resolveLabel } from '@dynamic-entity/core';\nimport { LOOKUP_REGISTRY } from '../tokens/injection-tokens';\n\n/** Cache-key field separator. Kept out of template literals so it stays visible in source. */\nconst SEP = '|';\n\n/**\n * LookupRegistryService — the cache in front of consumer-registered master lists.\n *\n * Three layers, deliberately the same shape as `EntityReferenceService`, because the problem is\n * the same: one list is typically used by many fields across many entities.\n *  1. **options** — resolved `DropdownOption[]` per (list name, lang).\n *  2. **in-flight** — the pending Promise, so N fields on one list trigger one load, not N.\n *  3. **labels** — synchronous value → text (parity plan §6.2). This is not a nicety: since\n *     `viewMode` defaults to true a record opens read-only, so rendering a stored value as\n *     text is the *first* thing a `listName` field has to do. An async-only registry would\n *     paint the raw stored value and then flip, on every record open.\n *\n * A failed load rejects and caches nothing, so one transient error does not serve an empty\n * list forever — the same fix made for entity references in phase 5.\n */\n@Injectable({ providedIn: 'root' })\nexport class LookupRegistryService {\n  private readonly registry =\n    inject(LOOKUP_REGISTRY, { optional: true }) ?? new Map<string, LookupListSource>();\n\n  /** `listName|lang` -> resolved options. */\n  private readonly options = new Map<string, DropdownOption[]>();\n  /** `listName|lang` -> normalised values, so a consumer can reach `code` / `isSystemDefined`. */\n  private readonly values = new Map<string, LookupListValue[]>();\n  /** Loads in progress, keyed as above. */\n  private readonly inFlight = new Map<string, Promise<DropdownOption[]>>();\n  /** `listName|lang|text` -> display text, for the synchronous read-only path. */\n  private readonly labels = new Map<string, string>();\n\n  has(listName: string): boolean {\n    return this.registry.has(listName);\n  }\n\n  /**\n   * Options for a named list, from cache when present.\n   * Concurrent callers with the same key share one load.\n   */\n  async load(listName: string, lang = 'en'): Promise<DropdownOption[]> {\n    const key = this.cacheKey(listName, lang);\n\n    const cached = this.options.get(key);\n    if (cached) return cached;\n\n    const pending = this.inFlight.get(key);\n    if (pending) return pending;\n\n    const source = this.registry.get(listName);\n    if (source === undefined) return [];\n\n    const load = this.invoke(source, lang).then(raw => {\n      const values = normalizeLookupValues(raw);\n      const options = lookupValuesToOptions(values);\n      this.values.set(key, values);\n      this.options.set(key, options);\n      this.rememberLabels(listName, lang, options);\n      return options;\n    });\n\n    // Only the `.then` above writes to the cache, and a rejection skips it: the caller still\n    // gets an empty list, but the next call retries instead of reading a poisoned entry.\n    const guarded = load\n      .catch(() => [] as DropdownOption[])\n      .finally(() => this.inFlight.delete(key));\n\n    this.inFlight.set(key, guarded);\n    return guarded;\n  }\n\n  /** Cached options without triggering a load. `undefined` when not loaded. */\n  peek(listName: string, lang = 'en'): DropdownOption[] | undefined {\n    return this.options.get(this.cacheKey(listName, lang));\n  }\n\n  /**\n   * Cached list values, carrying `_id`, `code`, `isSystemDefined` and `from`.\n   * The library never reads those; this is the seam for a consumer that needs them.\n   */\n  valuesFor(listName: string, lang = 'en'): LookupListValue[] | undefined {\n    return this.values.get(this.cacheKey(listName, lang));\n  }\n\n  /**\n   * Display text for a stored value, synchronously. `undefined` when the list has not loaded\n   * or holds no matching value — the caller keeps its own fallback, which is the stored text.\n   *\n   * Every language of an option is indexed, so a record saved under one language renders in\n   * another: a value stored as `'Aktiv'` resolves to `'Active'` under `lang: 'en'`.\n   */\n  labelFor(listName: string | undefined, value: unknown, lang = 'en'): string | undefined {\n    if (!listName || value === null || value === undefined || value === '') return undefined;\n    for (const text of this.candidateTexts(value, lang)) {\n      const hit = this.labels.get(this.labelKey(listName, lang, text));\n      if (hit) return hit;\n    }\n    return undefined;\n  }\n\n  // ─── Field-level resolution — inline options win, else `listName` ────────────\n\n  /** True when this field's options have to come from the registry. */\n  needsResolve(field: NestedFieldConfig | undefined): boolean {\n    return !!field?.listName && !field.options?.length;\n  }\n\n  /**\n   * The options to render right now, without awaiting: inline options, else whatever the\n   * registry already holds. Empty on a cold miss — pair with `resolveOptions`.\n   */\n  optionsFor(field: NestedFieldConfig | undefined, lang = 'en'): DropdownOption[] {\n    if (!field) return [];\n    if (field.options?.length) return field.options;\n    if (!field.listName) return [];\n    return this.peek(field.listName, lang) ?? [];\n  }\n\n  /** The options for a field, loading the named list if needed. */\n  resolveOptions(field: NestedFieldConfig | undefined, lang = 'en'): Promise<DropdownOption[]> {\n    if (!this.needsResolve(field)) return Promise.resolve(this.optionsFor(field, lang));\n    return this.load(field!.listName!, lang);\n  }\n\n  /** Drop everything cached for one list, leaving other lists intact. */\n  invalidate(listName: string): void {\n    const prefix = `${listName}${SEP}`;\n    for (const map of [this.options, this.values, this.inFlight]) {\n      for (const key of [...map.keys()]) {\n        if (key.startsWith(prefix)) map.delete(key);\n      }\n    }\n    for (const key of [...this.labels.keys()]) {\n      if (key.startsWith(prefix)) this.labels.delete(key);\n    }\n  }\n\n  clear(): void {\n    this.options.clear();\n    this.values.clear();\n    this.inFlight.clear();\n    this.labels.clear();\n  }\n\n  // ─── Internals ──────────────────────────────────────────────────────────────\n\n  private cacheKey(listName: string, lang: string): string {\n    return [listName, lang].join(SEP);\n  }\n\n  private labelKey(listName: string, lang: string, text: string): string {\n    return [listName, lang, text].join(SEP);\n  }\n\n  /** Index an option under every language it carries, so any stored spelling finds it. */\n  private rememberLabels(listName: string, lang: string, options: DropdownOption[]): void {\n    for (const option of options) {\n      const display = resolveLabel(option, lang);\n      if (!display) continue;\n      for (const text of Object.values(option)) {\n        if (typeof text === 'string' && text !== '') {\n          this.labels.set(this.labelKey(listName, lang, text), display);\n        }\n      }\n    }\n  }\n\n  /** The texts a stored value could have been indexed under. */\n  private candidateTexts(value: unknown, lang: string): string[] {\n    if (typeof value === 'object') {\n      const texts = Object.values(value as Record<string, unknown>).filter(\n        (v): v is string => typeof v === 'string' && v !== '',\n      );\n      const resolved = resolveLabel(value as Record<string, string>, lang);\n      return resolved ? [resolved, ...texts] : texts;\n    }\n    return [String(value)];\n  }\n\n  // ─── Source coercion (values | loader, array | Promise | Observable) ─────────\n\n  private invoke(source: LookupListSource, lang: string): Promise<RawLookupListValue[]> {\n    let result: LookupListResult;\n    try {\n      result = typeof source === 'function' ? (source as LookupListLoader)({ lang }) : source;\n    } catch (err) {\n      // Reject rather than resolve empty: `load` must be able to tell failure from an empty\n      // list, or it would cache the failure.\n      return Promise.reject(err);\n    }\n    return this.toPromise(result);\n  }\n\n  private toPromise(result: LookupListResult): Promise<RawLookupListValue[]> {\n    if (Array.isArray(result)) return Promise.resolve(result);\n    if (this.isSubscribable(result)) {\n      // First emission wins, so a stream that stays open still resolves the load.\n      return new Promise<RawLookupListValue[]>((resolve, reject) => {\n        let settled = false;\n        const settle = (fn: () => void) => {\n          if (settled) return;\n          settled = true;\n          fn();\n        };\n        result.subscribe({\n          next: value => settle(() => resolve(value ?? [])),\n          error: err => settle(() => reject(err)),\n          // Completing without emitting is a legitimate empty list, and is cached.\n          complete: () => settle(() => resolve([])),\n        });\n      });\n    }\n    return Promise.resolve(result as Promise<RawLookupListValue[]>);\n  }\n\n  private isSubscribable(value: unknown): value is Subscribable<RawLookupListValue[]> {\n    return (\n      typeof value === 'object' &&\n      value !== null &&\n      typeof (value as Subscribable<RawLookupListValue[]>).subscribe === 'function'\n    );\n  }\n}\n\n/** A choice field component, as far as option resolution is concerned. */\nexport interface ChoiceOptionHost {\n  readonly field: NestedFieldConfig | undefined;\n  readonly language: string;\n  readonly options: WritableSignal<DropdownOption[]>;\n}\n\nconst hostLastConfig = new WeakMap<ChoiceOptionHost, { field?: NestedFieldConfig; lang?: string }>();\n\n/**\n * Point a choice component's `options` signal at the right source (parity plan §6.3).\n *\n * Called from the `field` / `language` input setters of `dropdown`, `radio` and `multiSelect` —\n * the wiring is theirs, the decision is the service's, which is what keeps the ADR-008\n * five-input contract intact: options are never pushed in as a sixth input.\n *\n * Setters rather than `ngOnChanges` on purpose. `ngOnChanges` only fires for inputs Angular\n * itself sets, so a component whose `field` is assigned directly — which the field specs do,\n * and any consumer holding a `ComponentRef` may do — would render no options at all.\n *\n * Paints synchronously first (inline options, or a warm list), then fills in when a cold list\n * lands. The late result is dropped if the field or language changed while it was in flight.\n */\nexport function refreshChoiceOptions(host: ChoiceOptionHost, lookups: LookupRegistryService): void {\n  const last = hostLastConfig.get(host);\n  if (last && last.field === host.field && last.lang === host.language) {\n    return;\n  }\n  hostLastConfig.set(host, { field: host.field, lang: host.language });\n\n  host.options.set(lookups.optionsFor(host.field, host.language));\n  if (!lookups.needsResolve(host.field)) return;\n\n  const listName = host.field?.listName;\n  const lang = host.language;\n  void lookups.resolveOptions(host.field, host.language).then(options => {\n    if (host.field?.listName === listName && host.language === lang) host.options.set(options);\n  });\n}\n"]}

package/esm2022/lib/services/rbac.service.mjs

@@ -1,10 +1,9 @@
 import { Injectable, inject } from '@angular/core';
+import { shouldMaskField as coreShouldMaskField, resolveEffectiveMask as coreResolveEffectiveMask } from '@dynamic-entity/core';
 import { MASKED_ROLES } from '../tokens/injection-tokens';
 import * as i0 from "@angular/core";
 /**
  * RbacService — ALL permission checks and masking logic live here.
- * CRITICAL SYNC: resolveEffectiveMask() must be identical to rbac.utils.js in dynamic-entity-server.
- * Changing one without the other is a critical production bug (ADR-003).
  */
 export class RbacService {
     maskedRoles = inject(MASKED_ROLES, { optional: true }) ?? [];
@@ -17,12 +16,9 @@ export class RbacService {
             return true;
         return userRoles.some(r => requiredRoles.includes(r));
     }
-    /**
-     * ADR-003: 3-level OR resolution.
-     * MUST match rbac.utils.js resolveEffectiveMask() exactly.
-     */
+    /** 3-level OR resolution */
     resolveEffectiveMask(formMask, tabMask, fieldMask) {
-        return !!(formMask || tabMask || fieldMask);
+        return coreResolveEffectiveMask(formMask, tabMask, fieldMask);
     }
     /** Check if the user's roles include any masked role */
     isUserMaskedRole(userRoles) {
@@ -30,9 +26,7 @@ export class RbacService {
     }
     /** Determine if a specific field should be masked for this user */
     shouldMaskField(field, tab, config, userRoles) {
-        if (!this.isUserMaskedRole(userRoles))
-            return false;
-        return this.resolveEffectiveMask(config.maskData, tab?.maskData, field.maskData);
+        return coreShouldMaskField(field, tab, config, userRoles, this.maskedRoles);
     }
     /** Get view/edit/delete permissions for a config */
     getPermissions(config, userRoles) {
@@ -49,4 +43,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/rules-evaluation.service.mjs

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core';
+import { evaluateFormRules, filterRulesForTab } from '@dynamic-entity/core';
+import * as i0 from "@angular/core";
+/**
+ * RulesEvaluationService — evaluates dynamic form rules against active reactive form state.
+ */
+export class RulesEvaluationService {
+    /**
+     * Evaluate rules against form values and optional original baseline values.
+     */
+    evaluate(rules, values, originalValues) {
+        return evaluateFormRules(rules, values, originalValues);
+    }
+    /**
+     * Filter rules pertinent to a single tab.
+     */
+    filterForTab(rules, tabId, config) {
+        return filterRulesForTab(rules, tabId, config);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RulesEvaluationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RulesEvaluationService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RulesEvaluationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/validator-registry.service.mjs

@@ -3,22 +3,18 @@ import { Validators } from '@angular/forms';
 import { VALIDATOR_REGISTRY } from '../tokens/injection-tokens';
 import * as i0 from "@angular/core";
 /**
- * ValidatorRegistryService — resolves validator key strings to Angular ValidatorFns.
- * Built-in validators: 'required', 'email', 'min:N', 'max:N', 'minLength:N', 'maxLength:N'.
- * Consumers can register custom validators via provideNgxDynamicEntity({ validators: {...} }).
+ * ValidatorRegistryService — resolves validator configs / key strings to Angular ValidatorFns.
  */
 export class ValidatorRegistryService {
     consumerRegistry = inject(VALIDATOR_REGISTRY, { optional: true }) ?? new Map();
     /**
-     * Resolve a validator key to a ValidatorFn.
+     * Resolve a validator key string to a ValidatorFn.
      * Supports parameterized built-ins like 'min:0', 'maxLength:255'.
      */
     resolve(validatorKey) {
-        // Consumer validators take precedence
         if (this.consumerRegistry.has(validatorKey)) {
             return this.consumerRegistry.get(validatorKey);
         }
-        // Built-in validators
         if (validatorKey === 'required')
             return Validators.required;
         if (validatorKey === 'email')
@@ -39,6 +35,38 @@ export class ValidatorRegistryService {
     resolveAll(validatorKeys = []) {
         return validatorKeys.map(k => this.resolve(k)).filter((v) => v !== null);
     }
+    /** Resolve a FieldValidators object or string[] into ValidatorFn[] */
+    resolveFromConfig(config) {
+        if (!config)
+            return [];
+        if (Array.isArray(config))
+            return this.resolveAll(config);
+        const fnList = [];
+        if (config.required)
+            fnList.push(Validators.required);
+        if (config.min !== undefined)
+            fnList.push(Validators.min(config.min));
+        if (config.max !== undefined)
+            fnList.push(Validators.max(config.max));
+        if (config.minLength !== undefined)
+            fnList.push(Validators.minLength(config.minLength));
+        if (config.maxLength !== undefined)
+            fnList.push(Validators.maxLength(config.maxLength));
+        if (config.pattern)
+            fnList.push(Validators.pattern(config.pattern));
+        if (config.email)
+            fnList.push(Validators.email);
+        // Named validators from the consumer registry. This branch previously hardcoded the
+        // built-ins and consulted the registry only for the `string[]` form of this config, so
+        // a validator the consumer had registered could not be named from a typed schema
+        // without casting it to `any`.
+        for (const key of config.custom ?? []) {
+            const fn = this.resolve(key);
+            if (fn)
+                fnList.push(fn);
+        }
+        return fnList;
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ValidatorRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ValidatorRegistryService, providedIn: 'root' });
 }
@@ -46,4 +74,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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdG9yLXJlZ2lzdHJ5LnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL3ZhbGlkYXRvci1yZWdpc3RyeS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ25ELE9BQU8sRUFBZSxVQUFVLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUV6RCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQzs7QUFFaEU7O0dBRUc7QUFFSCxNQUFNLE9BQU8sd0JBQXdCO0lBQ2xCLGdCQUFnQixHQUFHLE1BQU0sQ0FBQyxrQkFBa0IsRUFBRSxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUUsQ0FBQyxJQUFJLElBQUksR0FBRyxFQUFFLENBQUM7SUFFaEc7OztPQUdHO0lBQ0gsT0FBTyxDQUFDLFlBQW9CO1FBQzFCLElBQUksSUFBSSxDQUFDLGdCQUFnQixDQUFDLEdBQUcsQ0FBQyxZQUFZLENBQUMsRUFBRSxDQUFDO1lBQzVDLE9BQU8sSUFBSSxDQUFDLGdCQUFnQixDQUFDLEdBQUcsQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUNqRCxDQUFDO1FBRUQsSUFBSSxZQUFZLEtBQUssVUFBVTtZQUFFLE9BQU8sVUFBVSxDQUFDLFFBQVEsQ0FBQztRQUM1RCxJQUFJLFlBQVksS0FBSyxPQUFPO1lBQUUsT0FBTyxVQUFVLENBQUMsS0FBSyxDQUFDO1FBRXRELE1BQU0sQ0FBQyxJQUFJLEVBQUUsS0FBSyxDQUFDLEdBQUcsWUFBWSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUM5QyxNQUFNLEtBQUssR0FBRyxVQUFVLENBQUMsS0FBSyxDQUFDLENBQUM7UUFFaEMsSUFBSSxJQUFJLEtBQUssS0FBSyxJQUFJLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQztZQUFFLE9BQU8sVUFBVSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNsRSxJQUFJLElBQUksS0FBSyxLQUFLLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDO1lBQUUsT0FBTyxVQUFVLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ2xFLElBQUksSUFBSSxLQUFLLFdBQVcsSUFBSSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUM7WUFBRSxPQUFPLFVBQVUsQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDOUUsSUFBSSxJQUFJLEtBQUssV0FBVyxJQUFJLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQztZQUFFLE9BQU8sVUFBVSxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUU5RSxPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7SUFFRCwyREFBMkQ7SUFDM0QsVUFBVSxDQUFDLGdCQUEwQixFQUFFO1FBQ3JDLE9BQU8sYUFBYSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQW9CLEVBQUUsQ0FBQyxDQUFDLEtBQUssSUFBSSxDQUFDLENBQUM7SUFDN0YsQ0FBQztJQUVELHNFQUFzRTtJQUN0RSxpQkFBaUIsQ0FBQyxNQUFtQztRQUNuRCxJQUFJLENBQUMsTUFBTTtZQUFFLE9BQU8sRUFBRSxDQUFDO1FBQ3ZCLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUM7WUFBRSxPQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLENBQUM7UUFFMUQsTUFBTSxNQUFNLEdBQWtCLEVBQUUsQ0FBQztRQUNqQyxJQUFJLE1BQU0sQ0FBQyxRQUFRO1lBQUUsTUFBTSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDdEQsSUFBSSxNQUFNLENBQUMsR0FBRyxLQUFLLFNBQVM7WUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7UUFDdEUsSUFBSSxNQUFNLENBQUMsR0FBRyxLQUFLLFNBQVM7WUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7UUFDdEUsSUFBSSxNQUFNLENBQUMsU0FBUyxLQUFLLFNBQVM7WUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUM7UUFDeEYsSUFBSSxNQUFNLENBQUMsU0FBUyxLQUFLLFNBQVM7WUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUM7UUFDeEYsSUFBSSxNQUFNLENBQUMsT0FBTztZQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQztRQUNwRSxJQUFJLE1BQU0sQ0FBQyxLQUFLO1lBQUUsTUFBTSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLENBQUM7UUFFaEQsb0ZBQW9GO1FBQ3BGLHVGQUF1RjtRQUN2RixpRkFBaUY7UUFDakYsK0JBQStCO1FBQy9CLEtBQUssTUFBTSxHQUFHLElBQUksTUFBTSxDQUFDLE1BQU0sSUFBSSxFQUFFLEVBQUUsQ0FBQztZQUN0QyxNQUFNLEVBQUUsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQzdCLElBQUksRUFBRTtnQkFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDO1FBQzFCLENBQUM7UUFFRCxPQUFPLE1BQU0sQ0FBQztJQUNoQixDQUFDO3dHQXZEVSx3QkFBd0I7NEdBQXhCLHdCQUF3QixjQURYLE1BQU07OzRGQUNuQix3QkFBd0I7a0JBRHBDLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSwgaW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBWYWxpZGF0b3JGbiwgVmFsaWRhdG9ycyB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcbmltcG9ydCB0eXBlIHsgRmllbGRWYWxpZGF0b3JzIH0gZnJvbSAnQGR5bmFtaWMtZW50aXR5L2NvcmUnO1xuaW1wb3J0IHsgVkFMSURBVE9SX1JFR0lTVFJZIH0gZnJvbSAnLi4vdG9rZW5zL2luamVjdGlvbi10b2tlbnMnO1xuXG4vKipcbiAqIFZhbGlkYXRvclJlZ2lzdHJ5U2VydmljZSDigJQgcmVzb2x2ZXMgdmFsaWRhdG9yIGNvbmZpZ3MgLyBrZXkgc3RyaW5ncyB0byBBbmd1bGFyIFZhbGlkYXRvckZucy5cbiAqL1xuQEluamVjdGFibGUoeyBwcm92aWRlZEluOiAncm9vdCcgfSlcbmV4cG9ydCBjbGFzcyBWYWxpZGF0b3JSZWdpc3RyeVNlcnZpY2Uge1xuICBwcml2YXRlIHJlYWRvbmx5IGNvbnN1bWVyUmVnaXN0cnkgPSBpbmplY3QoVkFMSURBVE9SX1JFR0lTVFJZLCB7IG9wdGlvbmFsOiB0cnVlIH0pID8/IG5ldyBNYXAoKTtcblxuICAvKipcbiAgICogUmVzb2x2ZSBhIHZhbGlkYXRvciBrZXkgc3RyaW5nIHRvIGEgVmFsaWRhdG9yRm4uXG4gICAqIFN1cHBvcnRzIHBhcmFtZXRlcml6ZWQgYnVpbHQtaW5zIGxpa2UgJ21pbjowJywgJ21heExlbmd0aDoyNTUnLlxuICAgKi9cbiAgcmVzb2x2ZSh2YWxpZGF0b3JLZXk6IHN0cmluZyk6IFZhbGlkYXRvckZuIHwgbnVsbCB7XG4gICAgaWYgKHRoaXMuY29uc3VtZXJSZWdpc3RyeS5oYXModmFsaWRhdG9yS2V5KSkge1xuICAgICAgcmV0dXJuIHRoaXMuY29uc3VtZXJSZWdpc3RyeS5nZXQodmFsaWRhdG9yS2V5KTtcbiAgICB9XG5cbiAgICBpZiAodmFsaWRhdG9yS2V5ID09PSAncmVxdWlyZWQnKSByZXR1cm4gVmFsaWRhdG9ycy5yZXF1aXJlZDtcbiAgICBpZiAodmFsaWRhdG9yS2V5ID09PSAnZW1haWwnKSByZXR1cm4gVmFsaWRhdG9ycy5lbWFpbDtcblxuICAgIGNvbnN0IFtuYW1lLCBwYXJhbV0gPSB2YWxpZGF0b3JLZXkuc3BsaXQoJzonKTtcbiAgICBjb25zdCB2YWx1ZSA9IHBhcnNlRmxvYXQocGFyYW0pO1xuXG4gICAgaWYgKG5hbWUgPT09ICdtaW4nICYmICFpc05hTih2YWx1ZSkpIHJldHVybiBWYWxpZGF0b3JzLm1pbih2YWx1ZSk7XG4gICAgaWYgKG5hbWUgPT09ICdtYXgnICYmICFpc05hTih2YWx1ZSkpIHJldHVybiBWYWxpZGF0b3JzLm1heCh2YWx1ZSk7XG4gICAgaWYgKG5hbWUgPT09ICdtaW5MZW5ndGgnICYmICFpc05hTih2YWx1ZSkpIHJldHVybiBWYWxpZGF0b3JzLm1pbkxlbmd0aCh2YWx1ZSk7XG4gICAgaWYgKG5hbWUgPT09ICdtYXhMZW5ndGgnICYmICFpc05hTih2YWx1ZSkpIHJldHVybiBWYWxpZGF0b3JzLm1heExlbmd0aCh2YWx1ZSk7XG5cbiAgICByZXR1cm4gbnVsbDtcbiAgfVxuXG4gIC8qKiBSZXNvbHZlIG11bHRpcGxlIHZhbGlkYXRvciBrZXlzIGludG8gYSBWYWxpZGF0b3JGbltdICovXG4gIHJlc29sdmVBbGwodmFsaWRhdG9yS2V5czogc3RyaW5nW10gPSBbXSk6IFZhbGlkYXRvckZuW10ge1xuICAgIHJldHVybiB2YWxpZGF0b3JLZXlzLm1hcChrID0+IHRoaXMucmVzb2x2ZShrKSkuZmlsdGVyKCh2KTogdiBpcyBWYWxpZGF0b3JGbiA9PiB2ICE9PSBudWxsKTtcbiAgfVxuXG4gIC8qKiBSZXNvbHZlIGEgRmllbGRWYWxpZGF0b3JzIG9iamVjdCBvciBzdHJpbmdbXSBpbnRvIFZhbGlkYXRvckZuW10gKi9cbiAgcmVzb2x2ZUZyb21Db25maWcoY29uZmlnPzogRmllbGRWYWxpZGF0b3JzIHwgc3RyaW5nW10pOiBWYWxpZGF0b3JGbltdIHtcbiAgICBpZiAoIWNvbmZpZykgcmV0dXJuIFtdO1xuICAgIGlmIChBcnJheS5pc0FycmF5KGNvbmZpZykpIHJldHVybiB0aGlzLnJlc29sdmVBbGwoY29uZmlnKTtcblxuICAgIGNvbnN0IGZuTGlzdDogVmFsaWRhdG9yRm5bXSA9IFtdO1xuICAgIGlmIChjb25maWcucmVxdWlyZWQpIGZuTGlzdC5wdXNoKFZhbGlkYXRvcnMucmVxdWlyZWQpO1xuICAgIGlmIChjb25maWcubWluICE9PSB1bmRlZmluZWQpIGZuTGlzdC5wdXNoKFZhbGlkYXRvcnMubWluKGNvbmZpZy5taW4pKTtcbiAgICBpZiAoY29uZmlnLm1heCAhPT0gdW5kZWZpbmVkKSBmbkxpc3QucHVzaChWYWxpZGF0b3JzLm1heChjb25maWcubWF4KSk7XG4gICAgaWYgKGNvbmZpZy5taW5MZW5ndGggIT09IHVuZGVmaW5lZCkgZm5MaXN0LnB1c2goVmFsaWRhdG9ycy5taW5MZW5ndGgoY29uZmlnLm1pbkxlbmd0aCkpO1xuICAgIGlmIChjb25maWcubWF4TGVuZ3RoICE9PSB1bmRlZmluZWQpIGZuTGlzdC5wdXNoKFZhbGlkYXRvcnMubWF4TGVuZ3RoKGNvbmZpZy5tYXhMZW5ndGgpKTtcbiAgICBpZiAoY29uZmlnLnBhdHRlcm4pIGZuTGlzdC5wdXNoKFZhbGlkYXRvcnMucGF0dGVybihjb25maWcucGF0dGVybikpO1xuICAgIGlmIChjb25maWcuZW1haWwpIGZuTGlzdC5wdXNoKFZhbGlkYXRvcnMuZW1haWwpO1xuXG4gICAgLy8gTmFtZWQgdmFsaWRhdG9ycyBmcm9tIHRoZSBjb25zdW1lciByZWdpc3RyeS4gVGhpcyBicmFuY2ggcHJldmlvdXNseSBoYXJkY29kZWQgdGhlXG4gICAgLy8gYnVpbHQtaW5zIGFuZCBjb25zdWx0ZWQgdGhlIHJlZ2lzdHJ5IG9ubHkgZm9yIHRoZSBgc3RyaW5nW11gIGZvcm0gb2YgdGhpcyBjb25maWcsIHNvXG4gICAgLy8gYSB2YWxpZGF0b3IgdGhlIGNvbnN1bWVyIGhhZCByZWdpc3RlcmVkIGNvdWxkIG5vdCBiZSBuYW1lZCBmcm9tIGEgdHlwZWQgc2NoZW1hXG4gICAgLy8gd2l0aG91dCBjYXN0aW5nIGl0IHRvIGBhbnlgLlxuICAgIGZvciAoY29uc3Qga2V5IG9mIGNvbmZpZy5jdXN0b20gPz8gW10pIHtcbiAgICAgIGNvbnN0IGZuID0gdGhpcy5yZXNvbHZlKGtleSk7XG4gICAgICBpZiAoZm4pIGZuTGlzdC5wdXNoKGZuKTtcbiAgICB9XG5cbiAgICByZXR1cm4gZm5MaXN0O1xuICB9XG59XG4iXX0=

package/esm2022/lib/tokens/injection-tokens.mjs

@@ -1,16 +1,113 @@
 import { InjectionToken } from '@angular/core';
-/** Base URL for the dynamic-entity-server API */
-export const DYNAMIC_ENTITY_API_URL = new InjectionToken('DYNAMIC_ENTITY_API_URL');
+import { InMemoryEntityRefCacheStore } from '../services/entity-ref-cache';
 /** Roles that see XXXXXXXXX for masked fields (ADR-003) */
 export const MASKED_ROLES = new InjectionToken('MASKED_ROLES');
-/** Migration strategy for the frontend — 'strict' | 'graceful' only (ADR-005, never 'auto') */
-export const MIGRATION_STRATEGY = new InjectionToken('MIGRATION_STRATEGY');
-/** Registry: fieldType string → Angular component class */
+/**
+ * Consumer **overrides**: fieldType string → Angular component class.
+ * Highest priority — beats anything registered through `provideFieldTypes()`.
+ */
 export const FIELD_TYPE_REGISTRY = new InjectionToken('FIELD_TYPE_REGISTRY');
-/** Registry: entity key → async () => options[] loader function */
+/**
+ * Multi-provider of field-type sets, contributed by `provideFieldTypes()` /
+ * `provideBuiltInFieldTypes()`. Multi so several calls compose instead of clobbering;
+ * later sets win on key collision. This is the seam that keeps unused field components
+ * out of the bundle — nothing is imported until a set names it.
+ */
+export const FIELD_TYPE_SETS = new InjectionToken('FIELD_TYPE_SETS');
+/**
+ * Registry: entity key → option loader.
+ *
+ * A loader receives a `ReferenceLoaderContext` (`parentValue`, `filters`, `lang`) and may
+ * return an array, a Promise, or an Observable of `ReferenceOption[]`. `ctx` is optional,
+ * so a zero-arg loader (`() => svc.list()`) is still a valid registration.
+ */
 export const ENTITY_REF_REGISTRY = new InjectionToken('ENTITY_REF_REGISTRY');
+/**
+ * Registry: list name → the values of a named master list (`field.listName`).
+ *
+ * A source may be the values themselves (array / Promise / Observable) or a **loader function**,
+ * which is what you want for anything fetched: a bare Promise is created when the provider is
+ * built, so every list would load whether or not a form uses it.
+ *
+ * Values are normalised by `normalizeLookupValues` — bare strings and `LocalizedText` are
+ * accepted alongside the full `{ code, name, sortOrder }` shape.
+ *
+ * @example
+ * provideNgxDynamicEntity({
+ *   lookups: {
+ *     employeeStatus: () => listService.getByName('employeeStatus'),
+ *     grades: ['Junior', 'Senior'],
+ *   },
+ * })
+ */
+export const LOOKUP_REGISTRY = new InjectionToken('LOOKUP_REGISTRY');
+/**
+ * Ordered steps that move a saved record forward when a config's `version` increases.
+ *
+ * Without these, `EntityFormConfig.version` and `VersionedRecord._configVersion` are
+ * declarations nothing acts on: a schema can be edited freely while records keep their old
+ * shape, and nothing reconciles the two. Registering migrations makes the version numbers
+ * mean something.
+ *
+ * @example
+ * provideNgxDynamicEntity({
+ *   migrations: [
+ *     { from: 1, to: 2, description: 'split name', migrate: r => ({ ...r, firstName: r['name'] }) },
+ *   ],
+ * })
+ */
+export const RECORD_MIGRATIONS = new InjectionToken('RECORD_MIGRATIONS');
 /** Registry: validator key → ValidatorFn */
 export const VALIDATOR_REGISTRY = new InjectionToken('VALIDATOR_REGISTRY');
 /** Registry: hook key → async (data, context) => data */
 export const HOOK_REGISTRY = new InjectionToken('HOOK_REGISTRY');
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5qZWN0aW9uLXRva2Vucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdG9rZW5zL2luamVjdGlvbi10b2tlbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUkvQyxpREFBaUQ7QUFDakQsTUFBTSxDQUFDLE1BQU0sc0JBQXNCLEdBQUcsSUFBSSxjQUFjLENBQVMsd0JBQXdCLENBQUMsQ0FBQztBQUUzRiwyREFBMkQ7QUFDM0QsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLElBQUksY0FBYyxDQUFXLGNBQWMsQ0FBQyxDQUFDO0FBRXpFLCtGQUErRjtBQUMvRixNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxJQUFJLGNBQWMsQ0FBd0Isb0JBQW9CLENBQUMsQ0FBQztBQUVsRywyREFBMkQ7QUFDM0QsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsSUFBSSxjQUFjLENBQXlCLHFCQUFxQixDQUFDLENBQUM7QUFFckcsbUVBQW1FO0FBQ25FLE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFHLElBQUksY0FBYyxDQUNuRCxxQkFBcUIsQ0FDdEIsQ0FBQztBQUVGLDRDQUE0QztBQUM1QyxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxJQUFJLGNBQWMsQ0FBbUIsb0JBQW9CLENBQUMsQ0FBQztBQUU3Rix5REFBeUQ7QUFDekQsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLElBQUksY0FBYyxDQUF3QixlQUFlLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgdHlwZSB7IEVudGl0eUNvbmZpZywgRmllbGRDb25maWcsIE1pZ3JhdGlvblN0cmF0ZWd5IH0gZnJvbSAnQGR5bmFtaWMtZW50aXR5L2NvcmUnO1xuaW1wb3J0IHR5cGUgeyBUeXBlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbi8qKiBCYXNlIFVSTCBmb3IgdGhlIGR5bmFtaWMtZW50aXR5LXNlcnZlciBBUEkgKi9cbmV4cG9ydCBjb25zdCBEWU5BTUlDX0VOVElUWV9BUElfVVJMID0gbmV3IEluamVjdGlvblRva2VuPHN0cmluZz4oJ0RZTkFNSUNfRU5USVRZX0FQSV9VUkwnKTtcblxuLyoqIFJvbGVzIHRoYXQgc2VlIFhYWFhYWFhYWCBmb3IgbWFza2VkIGZpZWxkcyAoQURSLTAwMykgKi9cbmV4cG9ydCBjb25zdCBNQVNLRURfUk9MRVMgPSBuZXcgSW5qZWN0aW9uVG9rZW48c3RyaW5nW10+KCdNQVNLRURfUk9MRVMnKTtcblxuLyoqIE1pZ3JhdGlvbiBzdHJhdGVneSBmb3IgdGhlIGZyb250ZW5kIOKAlCAnc3RyaWN0JyB8ICdncmFjZWZ1bCcgb25seSAoQURSLTAwNSwgbmV2ZXIgJ2F1dG8nKSAqL1xuZXhwb3J0IGNvbnN0IE1JR1JBVElPTl9TVFJBVEVHWSA9IG5ldyBJbmplY3Rpb25Ub2tlbjwnc3RyaWN0JyB8ICdncmFjZWZ1bCc+KCdNSUdSQVRJT05fU1RSQVRFR1knKTtcblxuLyoqIFJlZ2lzdHJ5OiBmaWVsZFR5cGUgc3RyaW5nIOKGkiBBbmd1bGFyIGNvbXBvbmVudCBjbGFzcyAqL1xuZXhwb3J0IGNvbnN0IEZJRUxEX1RZUEVfUkVHSVNUUlkgPSBuZXcgSW5qZWN0aW9uVG9rZW48TWFwPHN0cmluZywgVHlwZTxhbnk+Pj4oJ0ZJRUxEX1RZUEVfUkVHSVNUUlknKTtcblxuLyoqIFJlZ2lzdHJ5OiBlbnRpdHkga2V5IOKGkiBhc3luYyAoKSA9PiBvcHRpb25zW10gbG9hZGVyIGZ1bmN0aW9uICovXG5leHBvcnQgY29uc3QgRU5USVRZX1JFRl9SRUdJU1RSWSA9IG5ldyBJbmplY3Rpb25Ub2tlbjxNYXA8c3RyaW5nLCAoKSA9PiBQcm9taXNlPGFueVtdPj4+KFxuICAnRU5USVRZX1JFRl9SRUdJU1RSWScsXG4pO1xuXG4vKiogUmVnaXN0cnk6IHZhbGlkYXRvciBrZXkg4oaSIFZhbGlkYXRvckZuICovXG5leHBvcnQgY29uc3QgVkFMSURBVE9SX1JFR0lTVFJZID0gbmV3IEluamVjdGlvblRva2VuPE1hcDxzdHJpbmcsIGFueT4+KCdWQUxJREFUT1JfUkVHSVNUUlknKTtcblxuLyoqIFJlZ2lzdHJ5OiBob29rIGtleSDihpIgYXN5bmMgKGRhdGEsIGNvbnRleHQpID0+IGRhdGEgKi9cbmV4cG9ydCBjb25zdCBIT09LX1JFR0lTVFJZID0gbmV3IEluamVjdGlvblRva2VuPE1hcDxzdHJpbmcsIEZ1bmN0aW9uPj4oJ0hPT0tfUkVHSVNUUlknKTtcbiJdfQ==
+/**
+ * Consumer-registered list of common module tabs (documents, audit, tasks, etc.).
+ * The library ships no built-in implementations. Consumers provide their own list
+ * so the builder's module-picker and the renderer's tab switcher know what's available.
+ *
+ * @example
+ * providers: [
+ *   {
+ *     provide: COMMON_MODULES_REGISTRY,
+ *     useValue: [
+ *       { id: 'documents', label: { en: 'Documents' }, component: 'app-documents-view' },
+ *       { id: 'audit',     label: { en: 'Audit Log'  }, component: 'app-audit' },
+ *     ] satisfies CommonModuleEntry[]
+ *   }
+ * ]
+ */
+export const COMMON_MODULES_REGISTRY = new InjectionToken('COMMON_MODULES_REGISTRY');
+/**
+ * Consumer-provided file/image upload handler.
+ * When supplied, image-field and file-field call it to persist the File and receive a stable
+ * URL back. Without it the field stores `{ file, name, size, mimeType }` for the consumer to
+ * upload on submit. May return the result directly, as a Promise, or as an Observable.
+ *
+ * @example
+ * { provide: UPLOAD_HANDLER, useFactory: () => (file: File) => myUploadService.upload(file) }
+ */
+export const UPLOAD_HANDLER = new InjectionToken('UPLOAD_HANDLER');
+/**
+ * Backing store for the entity-reference options cache. Defaults to in-memory.
+ * Provide your own to make the cache outlive a page refresh.
+ *
+ * @example
+ * { provide: ENTITY_REF_CACHE_STORE, useClass: SessionStorageRefCache }
+ */
+export const ENTITY_REF_CACHE_STORE = new InjectionToken('ENTITY_REF_CACHE_STORE', { providedIn: 'root', factory: () => new InMemoryEntityRefCacheStore() });
+/**
+ * Consumer-provided predicate function to check whether user roles can edit system default tabs or fields.
+ * Defaults to allowing edits if not provided.
+ */
+/**
+ * Consumer-provided predicate function to check whether user roles can edit system default tabs or fields.
+ * Defaults to allowing edits if not provided.
+ */
+export const SYSTEM_DEFAULT_CAN_EDIT = new InjectionToken('SYSTEM_DEFAULT_CAN_EDIT');
+/**
+ * Registry/Resolver for resolving an EntityFormConfig by entity key across entities (Phase 8).
+ * Enables cross-entity field referencing (`isReferenced`, `referencedEntityKey`, `referencedFieldId`, `hasDrift`).
+ */
+export const CONFIG_SOURCE = new InjectionToken('CONFIG_SOURCE');
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"injection-tokens.js","sourceRoot":"","sources":["../../../../src/lib/tokens/injection-tokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAS/C,OAAO,EAAE,2BAA2B,EAA4B,MAAM,8BAA8B,CAAC;AAErG,2DAA2D;AAC3D,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,cAAc,CAAW,cAAc,CAAC,CAAC;AAEzE;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,IAAI,cAAc,CAAyB,qBAAqB,CAAC,CAAC;AAErG;;;;;GAKG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,cAAc,CAA8B,iBAAiB,CAAC,CAAC;AAElG;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,IAAI,cAAc,CACnD,qBAAqB,CACtB,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,cAAc,CAAgC,iBAAiB,CAAC,CAAC;AAEpG;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,cAAc,CAAoB,mBAAmB,CAAC,CAAC;AAE5F,4CAA4C;AAC5C,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,cAAc,CAAmB,oBAAoB,CAAC,CAAC;AAU7F,yDAAyD;AACzD,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,cAAc,CAAsB,eAAe,CAAC,CAAC;AAEtF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,IAAI,cAAc,CACvD,yBAAyB,CAC1B,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,IAAI,cAAc,CAAoB,gBAAgB,CAAC,CAAC;AAEtF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,IAAI,cAAc,CACtD,wBAAwB,EACxB,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,2BAA2B,EAAE,EAAE,CACzE,CAAC;AAEF;;;GAGG;AACH;;;GAGG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,IAAI,cAAc,CACvD,yBAAyB,CAC1B,CAAC;AAMF;;;GAGG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,cAAc,CAAsB,eAAe,CAAC,CAAC","sourcesContent":["import { InjectionToken } from '@angular/core';\nimport type { Type } from '@angular/core';\nimport type {\n  CommonModuleEntry,\n  EntityReferenceLoader,\n  FileUploadHandler,\n  LookupListSource,\n  RecordMigration,\n} from '@dynamic-entity/core';\nimport { InMemoryEntityRefCacheStore, type EntityRefCacheStore } from '../services/entity-ref-cache';\n\n/** Roles that see XXXXXXXXX for masked fields (ADR-003) */\nexport const MASKED_ROLES = new InjectionToken<string[]>('MASKED_ROLES');\n\n/**\n * Consumer **overrides**: fieldType string → Angular component class.\n * Highest priority — beats anything registered through `provideFieldTypes()`.\n */\nexport const FIELD_TYPE_REGISTRY = new InjectionToken<Map<string, Type<any>>>('FIELD_TYPE_REGISTRY');\n\n/**\n * Multi-provider of field-type sets, contributed by `provideFieldTypes()` /\n * `provideBuiltInFieldTypes()`. Multi so several calls compose instead of clobbering;\n * later sets win on key collision. This is the seam that keeps unused field components\n * out of the bundle — nothing is imported until a set names it.\n */\nexport const FIELD_TYPE_SETS = new InjectionToken<Record<string, Type<any>>[]>('FIELD_TYPE_SETS');\n\n/**\n * Registry: entity key → option loader.\n *\n * A loader receives a `ReferenceLoaderContext` (`parentValue`, `filters`, `lang`) and may\n * return an array, a Promise, or an Observable of `ReferenceOption[]`. `ctx` is optional,\n * so a zero-arg loader (`() => svc.list()`) is still a valid registration.\n */\nexport const ENTITY_REF_REGISTRY = new InjectionToken<Map<string, EntityReferenceLoader>>(\n  'ENTITY_REF_REGISTRY',\n);\n\n/**\n * Registry: list name → the values of a named master list (`field.listName`).\n *\n * A source may be the values themselves (array / Promise / Observable) or a **loader function**,\n * which is what you want for anything fetched: a bare Promise is created when the provider is\n * built, so every list would load whether or not a form uses it.\n *\n * Values are normalised by `normalizeLookupValues` — bare strings and `LocalizedText` are\n * accepted alongside the full `{ code, name, sortOrder }` shape.\n *\n * @example\n * provideNgxDynamicEntity({\n *   lookups: {\n *     employeeStatus: () => listService.getByName('employeeStatus'),\n *     grades: ['Junior', 'Senior'],\n *   },\n * })\n */\nexport const LOOKUP_REGISTRY = new InjectionToken<Map<string, LookupListSource>>('LOOKUP_REGISTRY');\n\n/**\n * Ordered steps that move a saved record forward when a config's `version` increases.\n *\n * Without these, `EntityFormConfig.version` and `VersionedRecord._configVersion` are\n * declarations nothing acts on: a schema can be edited freely while records keep their old\n * shape, and nothing reconciles the two. Registering migrations makes the version numbers\n * mean something.\n *\n * @example\n * provideNgxDynamicEntity({\n *   migrations: [\n *     { from: 1, to: 2, description: 'split name', migrate: r => ({ ...r, firstName: r['name'] }) },\n *   ],\n * })\n */\nexport const RECORD_MIGRATIONS = new InjectionToken<RecordMigration[]>('RECORD_MIGRATIONS');\n\n/** Registry: validator key → ValidatorFn */\nexport const VALIDATOR_REGISTRY = new InjectionToken<Map<string, any>>('VALIDATOR_REGISTRY');\n\n/**\n * A registered hook: receives the payload, returns it (or a replacement), sync or async.\n *\n * Spelled out rather than typed as `Function`, which accepts class declarations and any\n * arity and gives a consumer no signature to write against.\n */\nexport type HookFn = (data: any, context?: unknown) => unknown | Promise<unknown>;\n\n/** Registry: hook key → async (data, context) => data */\nexport const HOOK_REGISTRY = new InjectionToken<Map<string, HookFn>>('HOOK_REGISTRY');\n\n/**\n * Consumer-registered list of common module tabs (documents, audit, tasks, etc.).\n * The library ships no built-in implementations. Consumers provide their own list\n * so the builder's module-picker and the renderer's tab switcher know what's available.\n *\n * @example\n * providers: [\n *   {\n *     provide: COMMON_MODULES_REGISTRY,\n *     useValue: [\n *       { id: 'documents', label: { en: 'Documents' }, component: 'app-documents-view' },\n *       { id: 'audit',     label: { en: 'Audit Log'  }, component: 'app-audit' },\n *     ] satisfies CommonModuleEntry[]\n *   }\n * ]\n */\nexport const COMMON_MODULES_REGISTRY = new InjectionToken<CommonModuleEntry[]>(\n  'COMMON_MODULES_REGISTRY',\n);\n\n/**\n * Consumer-provided file/image upload handler.\n * When supplied, image-field and file-field call it to persist the File and receive a stable\n * URL back. Without it the field stores `{ file, name, size, mimeType }` for the consumer to\n * upload on submit. May return the result directly, as a Promise, or as an Observable.\n *\n * @example\n * { provide: UPLOAD_HANDLER, useFactory: () => (file: File) => myUploadService.upload(file) }\n */\nexport const UPLOAD_HANDLER = new InjectionToken<FileUploadHandler>('UPLOAD_HANDLER');\n\n/**\n * Backing store for the entity-reference options cache. Defaults to in-memory.\n * Provide your own to make the cache outlive a page refresh.\n *\n * @example\n * { provide: ENTITY_REF_CACHE_STORE, useClass: SessionStorageRefCache }\n */\nexport const ENTITY_REF_CACHE_STORE = new InjectionToken<EntityRefCacheStore>(\n  'ENTITY_REF_CACHE_STORE',\n  { providedIn: 'root', factory: () => new InMemoryEntityRefCacheStore() },\n);\n\n/**\n * Consumer-provided predicate function to check whether user roles can edit system default tabs or fields.\n * Defaults to allowing edits if not provided.\n */\n/**\n * Consumer-provided predicate function to check whether user roles can edit system default tabs or fields.\n * Defaults to allowing edits if not provided.\n */\nexport const SYSTEM_DEFAULT_CAN_EDIT = new InjectionToken<(roles: string[]) => boolean>(\n  'SYSTEM_DEFAULT_CAN_EDIT',\n);\n\nexport type ConfigSourceHandler = (\n  entityKey: string,\n) => any;\n\n/**\n * Registry/Resolver for resolving an EntityFormConfig by entity key across entities (Phase 8).\n * Enables cross-entity field referencing (`isReferenced`, `referencedEntityKey`, `referencedFieldId`, `hasDrift`).\n */\nexport const CONFIG_SOURCE = new InjectionToken<ConfigSourceHandler>('CONFIG_SOURCE');\n\n\n"]}