ngx-dynamic-entity 0.0.1 → 1.0.0

package/esm2022/lib/services/entity-reference.service.mjs

@@ -0,0 +1,168 @@
+import { Injectable, inject } from '@angular/core';
+import { buildReferenceCacheKey, entityKeyFromCacheKey, normalizeReferenceOptions, resolveLabel, valuesMatch, } from '@dynamic-entity/core';
+import { ENTITY_REF_CACHE_STORE } from '../tokens/injection-tokens';
+import { EntityRefRegistryService } from './entity-ref-registry.service';
+import * as i0 from "@angular/core";
+/** Label-cache field separator. Kept out of template literals so it stays visible in source. */
+const LABEL_SEP = '|';
+/**
+ * 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 class EntityReferenceService {
+    registry = inject(EntityRefRegistryService);
+    store = inject(ENTITY_REF_CACHE_STORE);
+    /** Loads in progress, keyed the same way as the options cache. */
+    inFlight = new Map();
+    /** `entityKey|lang|canonicalValue` -> display text. */
+    labels = new Map();
+    /**
+     * Options for an entity, from cache when present.
+     * Concurrent callers with the same key share one load.
+     */
+    async load(entityKey, ctx = {}) {
+        const key = buildReferenceCacheKey(entityKey, {
+            lang: ctx.lang,
+            filters: ctx.filters,
+            displayFields: ctx.displayFields,
+            parentValue: ctx.parentValue,
+        });
+        const cached = this.store.get(key);
+        if (cached)
+            return cached;
+        const pending = this.inFlight.get(key);
+        if (pending)
+            return pending;
+        const loader = this.registry.resolve(entityKey);
+        if (!loader)
+            return [];
+        const load = this.invoke(loader, ctx)
+            .then(raw => {
+            // displayFields drive label building, which is why they are part of the cache key.
+            const options = normalizeReferenceOptions(raw, ctx.displayFields ? { enabled: true, displayFields: ctx.displayFields } : undefined, ctx.lang ?? 'en');
+            this.store.set(key, options);
+            this.rememberLabels(entityKey, ctx.lang ?? 'en', options);
+            return options;
+        });
+        // A failed load resolves to [] for the caller but is never written to the store, so a
+        // transient error is retried on the next call instead of poisoning the cache. Only the
+        // `.then` above caches, and a rejection skips it.
+        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 cached. */
+    peek(entityKey, ctx = {}) {
+        return this.store.get(buildReferenceCacheKey(entityKey, {
+            lang: ctx.lang,
+            filters: ctx.filters,
+            displayFields: ctx.displayFields,
+            parentValue: ctx.parentValue,
+        }));
+    }
+    /**
+     * Display text for a stored reference value, synchronously.
+     * Returns `undefined` when the entity's options have never been loaded.
+     */
+    labelFor(entityKey, value, lang = 'en') {
+        return this.labels.get(this.labelKey(entityKey, lang, value));
+    }
+    /** Drop everything cached for one entity, leaving other entities intact. */
+    invalidate(entityKey) {
+        for (const key of this.store.keys()) {
+            if (entityKeyFromCacheKey(key) === entityKey)
+                this.store.delete(key);
+        }
+        for (const key of [...this.inFlight.keys()]) {
+            if (entityKeyFromCacheKey(key) === entityKey)
+                this.inFlight.delete(key);
+        }
+        const prefix = `${entityKey}${LABEL_SEP}`;
+        for (const key of [...this.labels.keys()]) {
+            if (key.startsWith(prefix))
+                this.labels.delete(key);
+        }
+    }
+    clear() {
+        this.store.clear();
+        this.inFlight.clear();
+        this.labels.clear();
+    }
+    rememberLabels(entityKey, lang, options) {
+        for (const option of options) {
+            this.labels.set(this.labelKey(entityKey, lang, option.value), option.label);
+        }
+    }
+    /** Label-cache key. An object value collapses to its resolved text for the active language. */
+    labelKey(entityKey, lang, value) {
+        const canonical = value !== null && typeof value === 'object'
+            ? resolveLabel(value, lang)
+            : String(value ?? '');
+        return [entityKey, lang, canonical].join(LABEL_SEP);
+    }
+    // ─── Loader result coercion (array | Promise | Observable) ──────────────────
+    invoke(loader, ctx) {
+        let result;
+        try {
+            result = loader(ctx);
+        }
+        catch (err) {
+            // Reject rather than resolve empty: `load` must be able to tell failure from
+            // "no matches", 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 an Observable 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 ?? [])),
+                    // An erroring stream is a failed load, not an empty one — see `invoke`.
+                    error: err => settle(() => reject(err)),
+                    // Completing without emitting is a legitimate empty result, and is cached.
+                    complete: () => settle(() => resolve([])),
+                });
+            });
+        }
+        return Promise.resolve(result);
+    }
+    isSubscribable(value) {
+        return (typeof value === 'object' &&
+            value !== null &&
+            typeof value.subscribe === 'function');
+    }
+    /** Exposed for cascade filtering, which matches a parent value against option values. */
+    matches(a, b, lang = 'en') {
+        return valuesMatch(a, b, lang);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EntityReferenceService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EntityReferenceService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EntityReferenceService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-reference.service.js","sourceRoot":"","sources":["../../../../src/lib/services/entity-reference.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\r\nimport type {\r\n  EntityReferenceLoader,\r\n  RawReferenceItem,\r\n  ReferenceLoaderContext,\r\n  ReferenceLoaderResult,\r\n  ReferenceOption,\r\n  Subscribable,\r\n} from '@dynamic-entity/core';\r\nimport {\r\n  buildReferenceCacheKey,\r\n  entityKeyFromCacheKey,\r\n  normalizeReferenceOptions,\r\n  resolveLabel,\r\n  valuesMatch,\r\n} from '@dynamic-entity/core';\r\nimport { ENTITY_REF_CACHE_STORE } from '../tokens/injection-tokens';\r\nimport { EntityRefRegistryService } from './entity-ref-registry.service';\r\n\r\n/** Label-cache field separator. Kept out of template literals so it stays visible in source. */\r\nconst LABEL_SEP = '|';\r\n\r\n/**\r\n * EntityReferenceService — the cache in front of consumer-registered option loaders.\r\n *\r\n * Three layers, matching the reference implementation:\r\n *  1. **options** — resolved `ReferenceOption[]` per (entity, lang, displayFields, filters).\r\n *  2. **in-flight** — the pending Promise, so N fields referencing one entity trigger one\r\n *     load rather than N. This is the layer that actually removes duplicate HTTP calls;\r\n *     an options cache alone does nothing for concurrent first loads.\r\n *  3. **labels** — synchronous value → text, for rendering a stored reference without\r\n *     waiting on a load.\r\n *\r\n * Invalidation is per entity, not global. The reference could only `clearCache()` everything\r\n * (issue #16), so saving one record re-fetched every entity's options.\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class EntityReferenceService {\r\n  private readonly registry = inject(EntityRefRegistryService);\r\n  private readonly store = inject(ENTITY_REF_CACHE_STORE);\r\n\r\n  /** Loads in progress, keyed the same way as the options cache. */\r\n  private readonly inFlight = new Map<string, Promise<ReferenceOption[]>>();\r\n  /** `entityKey|lang|canonicalValue` -> display text. */\r\n  private readonly labels = new Map<string, string>();\r\n\r\n  /**\r\n   * Options for an entity, from cache when present.\r\n   * Concurrent callers with the same key share one load.\r\n   */\r\n  async load(entityKey: string, ctx: ReferenceLoaderContext = {}): Promise<ReferenceOption[]> {\r\n    const key = buildReferenceCacheKey(entityKey, {\r\n      lang: ctx.lang,\r\n      filters: ctx.filters,\r\n      displayFields: ctx.displayFields,\r\n      parentValue: ctx.parentValue,\r\n    });\r\n\r\n    const cached = this.store.get(key);\r\n    if (cached) return cached;\r\n\r\n    const pending = this.inFlight.get(key);\r\n    if (pending) return pending;\r\n\r\n    const loader = this.registry.resolve(entityKey);\r\n    if (!loader) return [];\r\n\r\n    const load = this.invoke(loader, ctx)\r\n      .then(raw => {\r\n        // displayFields drive label building, which is why they are part of the cache key.\r\n        const options = normalizeReferenceOptions(\r\n          raw as RawReferenceItem[],\r\n          ctx.displayFields ? { enabled: true, displayFields: ctx.displayFields } : undefined,\r\n          ctx.lang ?? 'en',\r\n        );\r\n        this.store.set(key, options);\r\n        this.rememberLabels(entityKey, ctx.lang ?? 'en', options);\r\n        return options;\r\n      });\r\n\r\n    // A failed load resolves to [] for the caller but is never written to the store, so a\r\n    // transient error is retried on the next call instead of poisoning the cache. Only the\r\n    // `.then` above caches, and a rejection skips it.\r\n    const guarded = load\r\n      .catch(() => [] as ReferenceOption[])\r\n      .finally(() => this.inFlight.delete(key));\r\n\r\n    this.inFlight.set(key, guarded);\r\n    return guarded;\r\n  }\r\n\r\n  /** Cached options without triggering a load. `undefined` when not cached. */\r\n  peek(entityKey: string, ctx: ReferenceLoaderContext = {}): ReferenceOption[] | undefined {\r\n    return this.store.get(\r\n      buildReferenceCacheKey(entityKey, {\r\n        lang: ctx.lang,\r\n        filters: ctx.filters,\r\n        displayFields: ctx.displayFields,\r\n        parentValue: ctx.parentValue,\r\n      }),\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Display text for a stored reference value, synchronously.\r\n   * Returns `undefined` when the entity's options have never been loaded.\r\n   */\r\n  labelFor(entityKey: string, value: unknown, lang = 'en'): string | undefined {\r\n    return this.labels.get(this.labelKey(entityKey, lang, value));\r\n  }\r\n\r\n  /** Drop everything cached for one entity, leaving other entities intact. */\r\n  invalidate(entityKey: string): void {\r\n    for (const key of this.store.keys()) {\r\n      if (entityKeyFromCacheKey(key) === entityKey) this.store.delete(key);\r\n    }\r\n    for (const key of [...this.inFlight.keys()]) {\r\n      if (entityKeyFromCacheKey(key) === entityKey) this.inFlight.delete(key);\r\n    }\r\n    const prefix = `${entityKey}${LABEL_SEP}`;\r\n    for (const key of [...this.labels.keys()]) {\r\n      if (key.startsWith(prefix)) this.labels.delete(key);\r\n    }\r\n  }\r\n\r\n  clear(): void {\r\n    this.store.clear();\r\n    this.inFlight.clear();\r\n    this.labels.clear();\r\n  }\r\n\r\n  private rememberLabels(entityKey: string, lang: string, options: ReferenceOption[]): void {\r\n    for (const option of options) {\r\n      this.labels.set(this.labelKey(entityKey, lang, option.value), option.label);\r\n    }\r\n  }\r\n\r\n  /** Label-cache key. An object value collapses to its resolved text for the active language. */\r\n  private labelKey(entityKey: string, lang: string, value: unknown): string {\r\n    const canonical =\r\n      value !== null && typeof value === 'object'\r\n        ? resolveLabel(value as Record<string, string>, lang)\r\n        : String(value ?? '');\r\n    return [entityKey, lang, canonical].join(LABEL_SEP);\r\n  }\r\n\r\n  // ─── Loader result coercion (array | Promise | Observable) ──────────────────\r\n\r\n  private invoke(\r\n    loader: EntityReferenceLoader,\r\n    ctx: ReferenceLoaderContext,\r\n  ): Promise<ReferenceOption[]> {\r\n    let result: ReferenceLoaderResult;\r\n    try {\r\n      result = loader(ctx);\r\n    } catch (err) {\r\n      // Reject rather than resolve empty: `load` must be able to tell failure from\r\n      // \"no matches\", or it would cache the failure.\r\n      return Promise.reject(err);\r\n    }\r\n    return this.toPromise(result);\r\n  }\r\n\r\n  private toPromise(result: ReferenceLoaderResult): Promise<ReferenceOption[]> {\r\n    if (Array.isArray(result)) return Promise.resolve(result);\r\n    if (this.isSubscribable(result)) {\r\n      // First emission wins, so an Observable that stays open still resolves the load.\r\n      return new Promise<ReferenceOption[]>((resolve, reject) => {\r\n        let settled = false;\r\n        const settle = (fn: () => void) => {\r\n          if (settled) return;\r\n          settled = true;\r\n          fn();\r\n        };\r\n        result.subscribe({\r\n          next: value => settle(() => resolve(value ?? [])),\r\n          // An erroring stream is a failed load, not an empty one — see `invoke`.\r\n          error: err => settle(() => reject(err)),\r\n          // Completing without emitting is a legitimate empty result, and is cached.\r\n          complete: () => settle(() => resolve([])),\r\n        });\r\n      });\r\n    }\r\n    return Promise.resolve(result as Promise<ReferenceOption[]>);\r\n  }\r\n\r\n  private isSubscribable(value: unknown): value is Subscribable<ReferenceOption[]> {\r\n    return (\r\n      typeof value === 'object' &&\r\n      value !== null &&\r\n      typeof (value as Subscribable<ReferenceOption[]>).subscribe === 'function'\r\n    );\r\n  }\r\n\r\n  /** Exposed for cascade filtering, which matches a parent value against option values. */\r\n  matches(a: unknown, b: unknown, lang = 'en'): boolean {\r\n    return valuesMatch(a, b, lang);\r\n  }\r\n}\r\n"]}

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

@@ -1,44 +1,49 @@
 import { Injectable, inject } from '@angular/core';
-import { FIELD_TYPE_REGISTRY } from '../tokens/injection-tokens';
-// Built-in field components — pre-registered in this service
-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 { CheckboxFieldComponent } from '../field-types/checkbox-field.component';
-import { DateFieldComponent } from '../field-types/date-field.component';
-import { DropdownFieldComponent } from '../field-types/dropdown-field.component';
-import { MultiSelectFieldComponent } from '../field-types/multi-select-field.component';
-import { EntityRefFieldComponent } from '../field-types/entity-ref-field.component';
+import { FIELD_TYPE_REGISTRY, FIELD_TYPE_SETS } from '../tokens/injection-tokens';
 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 class FieldRegistryService {
     consumerRegistry = inject(FIELD_TYPE_REGISTRY, { optional: true }) ?? new Map();
-    /** Built-in field type → component map. Never remove an entry. */
-    builtInRegistry = new Map([
-        ['text', TextFieldComponent],
-        ['textarea', TextareaFieldComponent],
-        ['number', NumberFieldComponent],
-        ['checkbox', CheckboxFieldComponent],
-        ['date', DateFieldComponent],
-        ['dropdown', DropdownFieldComponent],
-        ['multiSelect', MultiSelectFieldComponent],
-        ['entity-ref', EntityRefFieldComponent],
-    ]);
+    dynamicRegistry = new Map();
+    constructor() {
+        // Sets contributed by provideFieldTypes()/provideBuiltInFieldTypes(), in declaration order.
+        for (const set of inject(FIELD_TYPE_SETS, { optional: true }) ?? []) {
+            this.registerAll(set);
+        }
+    }
+    /** Register a field type component mapping at runtime. */
+    register(type, component) {
+        this.dynamicRegistry.set(type, component);
+    }
+    /** Register multiple field type component mappings at runtime. */
+    registerAll(map) {
+        for (const [type, comp] of Object.entries(map)) {
+            this.dynamicRegistry.set(type, comp);
+        }
+    }
     /**
      * 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) {
-        return this.consumerRegistry.get(fieldType) ?? this.builtInRegistry.get(fieldType) ?? null;
+        return this.consumerRegistry.get(fieldType) ?? this.dynamicRegistry.get(fieldType) ?? null;
     }
-    /** Check if a field type has a registered component */
+    /** Check if a field type has a registered component. */
     has(fieldType) {
-        return this.consumerRegistry.has(fieldType) || this.builtInRegistry.has(fieldType);
+        return this.consumerRegistry.has(fieldType) || this.dynamicRegistry.has(fieldType);
+    }
+    /** Every registered field type key. Consumer overrides and runtime registrations combined. */
+    registeredTypes() {
+        return [...new Set([...this.dynamicRegistry.keys(), ...this.consumerRegistry.keys()])].sort();
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FieldRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FieldRegistryService, providedIn: 'root' });
@@ -46,5 +51,5 @@ export class FieldRegistryService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FieldRegistryService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,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
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/file-upload.service.mjs

@@ -0,0 +1,89 @@
+import { Injectable, inject } from '@angular/core';
+import { UPLOAD_HANDLER } from '../tokens/injection-tokens';
+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 class FileUploadService {
+    handler = inject(UPLOAD_HANDLER, { optional: true });
+    get hasHandler() {
+        return !!this.handler;
+    }
+    /** Metadata common to both persisted and unpersisted refs. */
+    describe(file) {
+        return { name: file.name, size: file.size, mimeType: file.type };
+    }
+    /**
+     * 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.
+     */
+    async toFileRef(file) {
+        const meta = this.describe(file);
+        if (!this.handler)
+            return { ...meta, file };
+        const result = await this.normalize(this.handler(file));
+        return { ...meta, url: result.url, name: result.name ?? meta.name };
+    }
+    /** Object URL for previewing an unpersisted File. Callers must revoke it. */
+    previewUrlFor(ref) {
+        if (!ref)
+            return null;
+        if (ref.url)
+            return ref.url;
+        if (ref.file && typeof URL !== 'undefined' && typeof URL.createObjectURL === 'function') {
+            return URL.createObjectURL(ref.file);
+        }
+        return null;
+    }
+    revokePreviewUrl(url) {
+        if (!url || !url.startsWith('blob:'))
+            return;
+        if (typeof URL !== 'undefined' && typeof URL.revokeObjectURL === 'function') {
+            URL.revokeObjectURL(url);
+        }
+    }
+    normalize(result) {
+        if (this.isSubscribable(result)) {
+            return new Promise((resolve, reject) => {
+                let settled = false;
+                result.subscribe({
+                    next: value => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        resolve(value);
+                    },
+                    error: err => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        reject(err);
+                    },
+                    complete: () => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        reject(new Error('Upload handler completed without emitting a result.'));
+                    },
+                });
+            });
+        }
+        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: FileUploadService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FileUploadService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FileUploadService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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