ngx-dynamic-entity 0.0.1 → 1.0.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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