ngx-dynamic-entity 0.0.1 → 1.1.0

package/lib/services/entity-reference.service.d.ts

@@ -0,0 +1,49 @@
+import type { ReferenceLoaderContext, ReferenceOption } from '@dynamic-entity/core';
+import * as i0 from "@angular/core";
+/**
+ * EntityReferenceService — the cache in front of consumer-registered option loaders.
+ *
+ * Three layers, matching the reference implementation:
+ *  1. **options** — resolved `ReferenceOption[]` per (entity, lang, displayFields, filters).
+ *  2. **in-flight** — the pending Promise, so N fields referencing one entity trigger one
+ *     load rather than N. This is the layer that actually removes duplicate HTTP calls;
+ *     an options cache alone does nothing for concurrent first loads.
+ *  3. **labels** — synchronous value → text, for rendering a stored reference without
+ *     waiting on a load.
+ *
+ * Invalidation is per entity, not global. The reference could only `clearCache()` everything
+ * (issue #16), so saving one record re-fetched every entity's options.
+ */
+export declare class EntityReferenceService {
+    private readonly registry;
+    private readonly store;
+    /** Loads in progress, keyed the same way as the options cache. */
+    private readonly inFlight;
+    /** `entityKey|lang|canonicalValue` -> display text. */
+    private readonly labels;
+    /**
+     * Options for an entity, from cache when present.
+     * Concurrent callers with the same key share one load.
+     */
+    load(entityKey: string, ctx?: ReferenceLoaderContext): Promise<ReferenceOption[]>;
+    /** Cached options without triggering a load. `undefined` when not cached. */
+    peek(entityKey: string, ctx?: ReferenceLoaderContext): ReferenceOption[] | undefined;
+    /**
+     * Display text for a stored reference value, synchronously.
+     * Returns `undefined` when the entity's options have never been loaded.
+     */
+    labelFor(entityKey: string, value: unknown, lang?: string): string | undefined;
+    /** Drop everything cached for one entity, leaving other entities intact. */
+    invalidate(entityKey: string): void;
+    clear(): void;
+    private rememberLabels;
+    /** Label-cache key. An object value collapses to its resolved text for the active language. */
+    private labelKey;
+    private invoke;
+    private toPromise;
+    private isSubscribable;
+    /** Exposed for cascade filtering, which matches a parent value against option values. */
+    matches(a: unknown, b: unknown, lang?: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityReferenceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityReferenceService>;
+}

package/lib/services/field-registry.service.d.ts

@@ -2,21 +2,31 @@ import { Type } from '@angular/core';
 import * as i0 from "@angular/core";
 /**
  * FieldRegistryService — resolves field type strings to Angular component classes.
- * Open/Closed: open for extension via consumer fieldTypes config, closed for modification.
- * DynamicFieldComponent uses this to mount the right component via createComponent().
+ *
+ * **Tree-shaking contract:** this service holds *no* static imports of field components.
+ * Nothing is bundled until something registers it, which is what makes the built-ins
+ * opt-in. Register them with `provideBuiltInFieldTypes()` (all 19 keys) or a narrower
+ * subset via `provideFieldTypes({ ... })` — see `providers/provide-field-types.ts`.
+ *
+ * Resolution order: consumer token registry → runtime registrations → nothing.
  */
 export declare class FieldRegistryService {
     private readonly consumerRegistry;
-    /** Built-in field type → component map. Never remove an entry. */
-    private readonly builtInRegistry;
+    private readonly dynamicRegistry;
+    constructor();
+    /** Register a field type component mapping at runtime. */
+    register(type: string, component: Type<any>): void;
+    /** Register multiple field type component mappings at runtime. */
+    registerAll(map: Record<string, Type<any>>): void;
     /**
      * Resolve a field type string to a component class.
-     * Consumer registry takes precedence over built-ins (open for extension).
-     * Returns null if type is unknown — caller must handle gracefully.
+     * Consumer token registry takes priority over runtime registrations.
      */
     resolve(fieldType: string): Type<any> | null;
-    /** Check if a field type has a registered component */
+    /** Check if a field type has a registered component. */
     has(fieldType: string): boolean;
+    /** Every registered field type key. Consumer overrides and runtime registrations combined. */
+    registeredTypes(): string[];
     static ɵfac: i0.ɵɵFactoryDeclaration<FieldRegistryService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FieldRegistryService>;
 }

package/lib/services/file-upload.service.d.ts

@@ -0,0 +1,27 @@
+import type { FileRef } from '@dynamic-entity/core';
+import * as i0 from "@angular/core";
+/**
+ * FileUploadService — the single place image-field and file-field agree on how a
+ * selected `File` becomes a `FileRef`.
+ *
+ * With `UPLOAD_HANDLER` registered the file is persisted and stored as `{ url }`;
+ * without one it is stored as `{ file }` for the consumer to upload at submit time.
+ */
+export declare class FileUploadService {
+    private readonly handler;
+    get hasHandler(): boolean;
+    /** Metadata common to both persisted and unpersisted refs. */
+    private describe;
+    /**
+     * Turn a selected File into the value to store on the control.
+     * @throws when a registered handler rejects — callers surface it as a field error.
+     */
+    toFileRef(file: File): Promise<FileRef>;
+    /** Object URL for previewing an unpersisted File. Callers must revoke it. */
+    previewUrlFor(ref: FileRef | null | undefined): string | null;
+    revokePreviewUrl(url: string | null): void;
+    private normalize;
+    private isSubscribable;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FileUploadService>;
+}

package/lib/services/lookup-registry.service.d.ts

@@ -0,0 +1,94 @@
+import { type WritableSignal } from '@angular/core';
+import type { DropdownOption, LookupListValue, NestedFieldConfig } from '@dynamic-entity/core';
+import * as i0 from "@angular/core";
+/**
+ * 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 declare class LookupRegistryService {
+    private readonly registry;
+    /** `listName|lang` -> resolved options. */
+    private readonly options;
+    /** `listName|lang` -> normalised values, so a consumer can reach `code` / `isSystemDefined`. */
+    private readonly values;
+    /** Loads in progress, keyed as above. */
+    private readonly inFlight;
+    /** `listName|lang|text` -> display text, for the synchronous read-only path. */
+    private readonly labels;
+    has(listName: string): boolean;
+    /**
+     * Options for a named list, from cache when present.
+     * Concurrent callers with the same key share one load.
+     */
+    load(listName: string, lang?: string): Promise<DropdownOption[]>;
+    /** Cached options without triggering a load. `undefined` when not loaded. */
+    peek(listName: string, lang?: string): DropdownOption[] | undefined;
+    /**
+     * 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: string, lang?: string): LookupListValue[] | undefined;
+    /**
+     * 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: string | undefined, value: unknown, lang?: string): string | undefined;
+    /** True when this field's options have to come from the registry. */
+    needsResolve(field: NestedFieldConfig | undefined): boolean;
+    /**
+     * 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: NestedFieldConfig | undefined, lang?: string): DropdownOption[];
+    /** The options for a field, loading the named list if needed. */
+    resolveOptions(field: NestedFieldConfig | undefined, lang?: string): Promise<DropdownOption[]>;
+    /** Drop everything cached for one list, leaving other lists intact. */
+    invalidate(listName: string): void;
+    clear(): void;
+    private cacheKey;
+    private labelKey;
+    /** Index an option under every language it carries, so any stored spelling finds it. */
+    private rememberLabels;
+    /** The texts a stored value could have been indexed under. */
+    private candidateTexts;
+    private invoke;
+    private toPromise;
+    private isSubscribable;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LookupRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LookupRegistryService>;
+}
+/** A choice field component, as far as option resolution is concerned. */
+export interface ChoiceOptionHost {
+    readonly field: NestedFieldConfig | undefined;
+    readonly language: string;
+    readonly options: WritableSignal<DropdownOption[]>;
+}
+/**
+ * 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 declare function refreshChoiceOptions(host: ChoiceOptionHost, lookups: LookupRegistryService): void;

package/lib/services/rbac.service.d.ts

@@ -1,9 +1,7 @@
-import type { EntityConfig, FieldConfig, TabConfig } from '@dynamic-entity/core';
+import type { EntityFormConfig, NestedFieldConfig, NestedTabConfig } from '@dynamic-entity/core';
 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 declare class RbacService {
     private readonly maskedRoles;
@@ -12,17 +10,14 @@ export declare class RbacService {
      * hasPermission(roles, undefined) → true (no restriction).
      */
     hasPermission(userRoles: string[], requiredRoles?: string[]): boolean;
-    /**
-     * ADR-003: 3-level OR resolution.
-     * MUST match rbac.utils.js resolveEffectiveMask() exactly.
-     */
+    /** 3-level OR resolution */
     resolveEffectiveMask(formMask?: boolean, tabMask?: boolean, fieldMask?: boolean): boolean;
     /** Check if the user's roles include any masked role */
     isUserMaskedRole(userRoles: string[]): boolean;
     /** Determine if a specific field should be masked for this user */
-    shouldMaskField(field: FieldConfig, tab: TabConfig | undefined, config: EntityConfig, userRoles: string[]): boolean;
+    shouldMaskField(field: NestedFieldConfig, tab: NestedTabConfig | undefined, config: EntityFormConfig, userRoles: string[]): boolean;
     /** Get view/edit/delete permissions for a config */
-    getPermissions(config: EntityConfig, userRoles: string[]): {
+    getPermissions(config: EntityFormConfig, userRoles: string[]): {
         canView: boolean;
         canEdit: boolean;
         canDelete: boolean;

package/lib/services/rules-evaluation.service.d.ts

@@ -0,0 +1,17 @@
+import type { EntityFormConfig, FormRule, RuleEvaluationResult } from '@dynamic-entity/core';
+import * as i0 from "@angular/core";
+/**
+ * RulesEvaluationService — evaluates dynamic form rules against active reactive form state.
+ */
+export declare class RulesEvaluationService {
+    /**
+     * Evaluate rules against form values and optional original baseline values.
+     */
+    evaluate(rules: FormRule[] | undefined | null, values: Record<string, unknown>, originalValues?: Record<string, unknown>): RuleEvaluationResult;
+    /**
+     * Filter rules pertinent to a single tab.
+     */
+    filterForTab(rules: FormRule[] | undefined | null, tabId: string, config: EntityFormConfig): FormRule[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<RulesEvaluationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RulesEvaluationService>;
+}

package/lib/services/validator-registry.service.d.ts

@@ -1,19 +1,20 @@
 import { ValidatorFn } from '@angular/forms';
+import type { FieldValidators } from '@dynamic-entity/core';
 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 declare class ValidatorRegistryService {
     private readonly consumerRegistry;
     /**
-     * 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: string): ValidatorFn | null;
     /** Resolve multiple validator keys into a ValidatorFn[] */
     resolveAll(validatorKeys?: string[]): ValidatorFn[];
+    /** Resolve a FieldValidators object or string[] into ValidatorFn[] */
+    resolveFromConfig(config?: FieldValidators | string[]): ValidatorFn[];
     static ɵfac: i0.ɵɵFactoryDeclaration<ValidatorRegistryService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ValidatorRegistryService>;
 }

package/lib/tokens/injection-tokens.d.ts

@@ -1,16 +1,121 @@
 import { InjectionToken } from '@angular/core';
 import type { Type } from '@angular/core';
-/** Base URL for the dynamic-entity-server API */
-export declare const DYNAMIC_ENTITY_API_URL: InjectionToken<string>;
+import { type EntityRefCacheStore } from '../services/entity-ref-cache';
 /** Roles that see XXXXXXXXX for masked fields (ADR-003) */
 export declare const MASKED_ROLES: InjectionToken<string[]>;
-/** Migration strategy for the frontend — 'strict' | 'graceful' only (ADR-005, never 'auto') */
-export declare const MIGRATION_STRATEGY: InjectionToken<"strict" | "graceful">;
-/** Registry: fieldType string → Angular component class */
+/**
+ * Consumer **overrides**: fieldType string → Angular component class.
+ * Highest priority — beats anything registered through `provideFieldTypes()`.
+ */
 export declare const FIELD_TYPE_REGISTRY: InjectionToken<Map<string, Type<any>>>;
-/** Registry: entity key → async () => options[] loader function */
-export declare const ENTITY_REF_REGISTRY: InjectionToken<Map<string, () => Promise<any[]>>>;
+/**
+ * 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 declare const FIELD_TYPE_SETS: InjectionToken<Record<string, Type<any>>[]>;
+/**
+ * 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 declare const ENTITY_REF_REGISTRY: InjectionToken<Map<string, EntityReferenceLoader>>;
+/**
+ * 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 declare const LOOKUP_REGISTRY: InjectionToken<Map<string, LookupListSource>>;
+/**
+ * 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 declare const RECORD_MIGRATIONS: InjectionToken<RecordMigration[]>;
 /** Registry: validator key → ValidatorFn */
 export declare const VALIDATOR_REGISTRY: InjectionToken<Map<string, any>>;
+/**
+ * A registered hook: receives the payload, returns it (or a replacement), sync or async.
+ *
+ * Spelled out rather than typed as `Function`, which accepts class declarations and any
+ * arity and gives a consumer no signature to write against.
+ */
+export type HookFn = (data: any, context?: unknown) => unknown | Promise<unknown>;
 /** Registry: hook key → async (data, context) => data */
-export declare const HOOK_REGISTRY: InjectionToken<Map<string, Function>>;
+export declare const HOOK_REGISTRY: InjectionToken<Map<string, HookFn>>;
+/**
+ * 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 declare const COMMON_MODULES_REGISTRY: InjectionToken<CommonModuleEntry[]>;
+/**
+ * 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 declare const UPLOAD_HANDLER: InjectionToken<FileUploadHandler>;
+/**
+ * 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 declare const ENTITY_REF_CACHE_STORE: InjectionToken<EntityRefCacheStore>;
+/**
+ * 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 declare const SYSTEM_DEFAULT_CAN_EDIT: InjectionToken<(roles: string[]) => boolean>;
+export type ConfigSourceHandler = (entityKey: string) => any;
+/**
+ * Registry/Resolver for resolving an EntityFormConfig by entity key across entities (Phase 8).
+ * Enables cross-entity field referencing (`isReferenced`, `referencedEntityKey`, `referencedFieldId`, `hasDrift`).
+ */
+export declare const CONFIG_SOURCE: InjectionToken<ConfigSourceHandler>;

package/package.json

@@ -1,25 +1,35 @@
 {
   "name": "ngx-dynamic-entity",
-  "version": "0.0.1",
-  "description": "Angular 17 standalone UI library for dynamic entity forms and tables.",
+  "version": "1.1.0",
+  "description": "Angular standalone UI library for rendering dynamic entity forms.",
+  "//typings": "Local workspace resolution only: ng-packagr overwrites this with the correct in-tarball path ('index.d.ts') when generating dist/package.json. Do NOT add a 'main' field here — ng-packagr does not generate one, so it would be copied verbatim and resolve to dist/dist/... in the published package.",
+  "typings": "index.d.ts",
   "peerDependencies": {
-    "@angular/common": "^17.0.0",
-    "@angular/core": "^17.0.0",
-    "@angular/forms": "^17.0.0",
-    "@dynamic-entity/core": "0.0.1",
+    "@angular/common": "^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0 || ^22.0.0",
+    "@angular/core": "^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0 || ^22.0.0",
+    "@angular/forms": "^17.0.0 || ^18.0.0 || ^19.0.0 || ^20.0.0 || ^21.0.0 || ^22.0.0",
+    "@dynamic-entity/core": "^1.1.0",
     "rxjs": "^7.0.0"
   },
   "keywords": [
     "angular",
     "dynamic-entity",
     "dynamic-forms",
-    "dynamic-table",
     "rbac"
   ],
   "license": "MIT",
   "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/berserker5619/Dynamic-Entity.git",
+    "directory": "packages/ngx-dynamic-entity"
+  },
+  "homepage": "https://github.com/berserker5619/Dynamic-Entity/tree/main/packages/ngx-dynamic-entity#readme",
+  "bugs": {
+    "url": "https://github.com/berserker5619/Dynamic-Entity/issues"
+  },
+  "author": "Nizamudeen",
   "module": "fesm2022/ngx-dynamic-entity.mjs",
-  "typings": "index.d.ts",
   "exports": {
     "./package.json": {
       "default": "./package.json"

package/public-api.d.ts

@@ -1,21 +1,38 @@
 export * from './lib/tokens/injection-tokens';
 export * from './lib/providers/provide-ngx-dynamic-entity';
-export * from './lib/services/config.service';
+export * from './lib/providers/provide-field-types';
 export * from './lib/services/field-registry.service';
 export * from './lib/services/hook-registry.service';
 export * from './lib/services/validator-registry.service';
 export * from './lib/services/entity-ref-registry.service';
-export * from './lib/services/version.service';
+export * from './lib/services/entity-ref-selection.service';
+export * from './lib/services/cascade-data.service';
+export * from './lib/services/entity-reference.service';
+export * from './lib/services/entity-ref-cache';
+export * from './lib/services/lookup-registry.service';
 export * from './lib/services/rbac.service';
+export * from './lib/services/rules-evaluation.service';
+export * from './lib/services/config-source.service';
 export * from './lib/form/dynamic-form.component';
+export * from './lib/form/dynamic-record-form.component';
 export * from './lib/form/dynamic-field/dynamic-field.component';
-export * from './lib/table/dynamic-table.component';
 export * from './lib/field-types/text-field.component';
 export * from './lib/field-types/textarea-field.component';
 export * from './lib/field-types/number-field.component';
+export * from './lib/field-types/currency-field.component';
+export * from './lib/field-types/email-field.component';
+export * from './lib/field-types/password-field.component';
 export * from './lib/field-types/checkbox-field.component';
+export * from './lib/field-types/boolean-field.component';
 export * from './lib/field-types/date-field.component';
+export * from './lib/field-types/month-year-field.component';
 export * from './lib/field-types/dropdown-field.component';
+export * from './lib/field-types/radio-field.component';
 export * from './lib/field-types/multi-select-field.component';
 export * from './lib/field-types/entity-ref-field.component';
-export type { EntityConfig, FieldConfig, TabConfig, DropdownOption, FieldDependency, EntityHooks, VersionedRecord, EntityPermissions, RbacContext, MigrationStrategy, QueryOptions, PaginatedResult, } from '@dynamic-entity/core';
+export * from './lib/field-types/group-field.component';
+export * from './lib/field-types/array-field.component';
+export * from './lib/field-types/image-field.component';
+export * from './lib/field-types/file-field.component';
+export { resolveLabel, resolveOptionLabel, resolveOptionValue, formatDisplayValue, valuesMatch, normalizeOption, normalizeConfig, } from '@dynamic-entity/core';
+export type { EntityFormConfig, NestedTabConfig, NestedFieldConfig, FieldTableConfig, RichFieldType, LocalizedText, DropdownOption, VersionedRecord, EntityPermissions, RbacContext, FieldValidators, EntityReferenceConfig, EntityReferenceLoader, ReferenceOption, ReferenceLoaderContext, AutoPatchConfig, PatchOnTrueMapping, FileRef, FormRule, RuleCondition, RuleAction, RuleEvaluationResult, CommonModuleEntry, } from '@dynamic-entity/core';

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

@@ -1,58 +0,0 @@
-import { Injectable, inject } from '@angular/core';
-import { HttpClient } from '@angular/common/http';
-import { map, shareReplay } from 'rxjs/operators';
-import { DYNAMIC_ENTITY_API_URL } from '../tokens/injection-tokens';
-import * as i0 from "@angular/core";
-/**
- * ConfigService — fetches entity configs from the dynamic-entity-server API.
- * Uses shareReplay(1) to cache per config key — avoids duplicate HTTP requests.
- * Following ONEHERMES smart service pattern: Observable$ + shareReplay.
- */
-export class ConfigService {
-    http = inject(HttpClient);
-    apiUrl = inject(DYNAMIC_ENTITY_API_URL, { optional: true }) ?? '';
-    cache = new Map();
-    /** Get a config by entity key. Cached via shareReplay(1). */
-    getConfig(entity) {
-        if (!this.cache.has(entity)) {
-            const config$ = this.http
-                .get(`${this.apiUrl}/config/${entity}`)
-                .pipe(map(res => res.data), // ADR-004: Success guarantees data
-            shareReplay(1));
-            this.cache.set(entity, config$);
-        }
-        return this.cache.get(entity);
-    }
-    /** List all configs */
-    listConfigs() {
-        return this.http
-            .get(`${this.apiUrl}/config`)
-            .pipe(map(res => res.data)); // ADR-004: Success guarantees data
-    }
-    /** Create a new config */
-    saveConfig(config) {
-        return this.http
-            .post(`${this.apiUrl}/config`, config)
-            .pipe(map(res => res.data));
-    }
-    /** Update an existing config */
-    updateConfig(entity, updates) {
-        return this.http
-            .put(`${this.apiUrl}/config/${entity}`, updates)
-            .pipe(map(res => {
-            this.invalidate(entity);
-            return res.data;
-        }));
-    }
-    /** Invalidate cache for an entity (call after config update) */
-    invalidate(entity) {
-        this.cache.delete(entity);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConfigService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConfigService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,40 +0,0 @@
-import { Injectable, inject } from '@angular/core';
-import { MIGRATION_STRATEGY } from '../tokens/injection-tokens';
-import * as i0 from "@angular/core";
-/**
- * VersionService — checks config version staleness and migration strategy.
- * ADR-005: Frontend strategy is 'strict' | 'graceful' only. Never 'auto'.
- */
-export class VersionService {
-    strategy = inject(MIGRATION_STRATEGY, { optional: true }) ?? 'graceful';
-    /**
-     * Check if a record is stale compared to the current config version.
-     * Returns true if the record needs migration.
-     */
-    needsMigration(record, config) {
-        if (!record._configVersion)
-            return false;
-        return record._configVersion < config.version || !!record._needsMigration;
-    }
-    /**
-     * Get the effective migration strategy for frontend use.
-     * Only 'strict' or 'graceful' — never 'auto' (ADR-005).
-     */
-    getStrategy() {
-        return this.strategy === 'strict' ? 'strict' : 'graceful';
-    }
-    /**
-     * Determine if form submission should be blocked for a stale record.
-     * 'strict' → block; 'graceful' → allow with warning.
-     */
-    shouldBlockSubmit(record, config) {
-        return this.getStrategy() === 'strict' && this.needsMigration(record, config);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: VersionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: VersionService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: VersionService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9zZXJ2aWNlcy92ZXJzaW9uLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFbkQsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7O0FBRWhFOzs7R0FHRztBQUVILE1BQU0sT0FBTyxjQUFjO0lBQ1IsUUFBUSxHQUFHLE1BQU0sQ0FBQyxrQkFBa0IsRUFBRSxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUUsQ0FBQyxJQUFJLFVBQVUsQ0FBQztJQUV6Rjs7O09BR0c7SUFDSCxjQUFjLENBQUMsTUFBZ0MsRUFBRSxNQUFvQjtRQUNuRSxJQUFJLENBQUMsTUFBTSxDQUFDLGNBQWM7WUFBRSxPQUFPLEtBQUssQ0FBQztRQUN6QyxPQUFPLE1BQU0sQ0FBQyxjQUFjLEdBQUcsTUFBTSxDQUFDLE9BQU8sSUFBSSxDQUFDLENBQUMsTUFBTSxDQUFDLGVBQWUsQ0FBQztJQUM1RSxDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsV0FBVztRQUNULE9BQU8sSUFBSSxDQUFDLFFBQVEsS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDO0lBQzVELENBQUM7SUFFRDs7O09BR0c7SUFDSCxpQkFBaUIsQ0FBQyxNQUFnQyxFQUFFLE1BQW9CO1FBQ3RFLE9BQU8sSUFBSSxDQUFDLFdBQVcsRUFBRSxLQUFLLFFBQVEsSUFBSSxJQUFJLENBQUMsY0FBYyxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsQ0FBQztJQUNoRixDQUFDO3dHQTFCVSxjQUFjOzRHQUFkLGNBQWMsY0FERCxNQUFNOzs0RkFDbkIsY0FBYztrQkFEMUIsVUFBVTttQkFBQyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlLCBpbmplY3QgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB0eXBlIHsgVmVyc2lvbmVkUmVjb3JkLCBFbnRpdHlDb25maWcsIE1pZ3JhdGlvblN0cmF0ZWd5IH0gZnJvbSAnQGR5bmFtaWMtZW50aXR5L2NvcmUnO1xuaW1wb3J0IHsgTUlHUkFUSU9OX1NUUkFURUdZIH0gZnJvbSAnLi4vdG9rZW5zL2luamVjdGlvbi10b2tlbnMnO1xuXG4vKipcbiAqIFZlcnNpb25TZXJ2aWNlIOKAlCBjaGVja3MgY29uZmlnIHZlcnNpb24gc3RhbGVuZXNzIGFuZCBtaWdyYXRpb24gc3RyYXRlZ3kuXG4gKiBBRFItMDA1OiBGcm9udGVuZCBzdHJhdGVneSBpcyAnc3RyaWN0JyB8ICdncmFjZWZ1bCcgb25seS4gTmV2ZXIgJ2F1dG8nLlxuICovXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdyb290JyB9KVxuZXhwb3J0IGNsYXNzIFZlcnNpb25TZXJ2aWNlIHtcbiAgcHJpdmF0ZSByZWFkb25seSBzdHJhdGVneSA9IGluamVjdChNSUdSQVRJT05fU1RSQVRFR1ksIHsgb3B0aW9uYWw6IHRydWUgfSkgPz8gJ2dyYWNlZnVsJztcblxuICAvKipcbiAgICogQ2hlY2sgaWYgYSByZWNvcmQgaXMgc3RhbGUgY29tcGFyZWQgdG8gdGhlIGN1cnJlbnQgY29uZmlnIHZlcnNpb24uXG4gICAqIFJldHVybnMgdHJ1ZSBpZiB0aGUgcmVjb3JkIG5lZWRzIG1pZ3JhdGlvbi5cbiAgICovXG4gIG5lZWRzTWlncmF0aW9uKHJlY29yZDogUGFydGlhbDxWZXJzaW9uZWRSZWNvcmQ+LCBjb25maWc6IEVudGl0eUNvbmZpZyk6IGJvb2xlYW4ge1xuICAgIGlmICghcmVjb3JkLl9jb25maWdWZXJzaW9uKSByZXR1cm4gZmFsc2U7XG4gICAgcmV0dXJuIHJlY29yZC5fY29uZmlnVmVyc2lvbiA8IGNvbmZpZy52ZXJzaW9uIHx8ICEhcmVjb3JkLl9uZWVkc01pZ3JhdGlvbjtcbiAgfVxuXG4gIC8qKlxuICAgKiBHZXQgdGhlIGVmZmVjdGl2ZSBtaWdyYXRpb24gc3RyYXRlZ3kgZm9yIGZyb250ZW5kIHVzZS5cbiAgICogT25seSAnc3RyaWN0JyBvciAnZ3JhY2VmdWwnIOKAlCBuZXZlciAnYXV0bycgKEFEUi0wMDUpLlxuICAgKi9cbiAgZ2V0U3RyYXRlZ3koKTogJ3N0cmljdCcgfCAnZ3JhY2VmdWwnIHtcbiAgICByZXR1cm4gdGhpcy5zdHJhdGVneSA9PT0gJ3N0cmljdCcgPyAnc3RyaWN0JyA6ICdncmFjZWZ1bCc7XG4gIH1cblxuICAvKipcbiAgICogRGV0ZXJtaW5lIGlmIGZvcm0gc3VibWlzc2lvbiBzaG91bGQgYmUgYmxvY2tlZCBmb3IgYSBzdGFsZSByZWNvcmQuXG4gICAqICdzdHJpY3QnIOKGkiBibG9jazsgJ2dyYWNlZnVsJyDihpIgYWxsb3cgd2l0aCB3YXJuaW5nLlxuICAgKi9cbiAgc2hvdWxkQmxvY2tTdWJtaXQocmVjb3JkOiBQYXJ0aWFsPFZlcnNpb25lZFJlY29yZD4sIGNvbmZpZzogRW50aXR5Q29uZmlnKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIHRoaXMuZ2V0U3RyYXRlZ3koKSA9PT0gJ3N0cmljdCcgJiYgdGhpcy5uZWVkc01pZ3JhdGlvbihyZWNvcmQsIGNvbmZpZyk7XG4gIH1cbn1cbiJdfQ==