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