@dereekb/dbx-core 14.9.0 → 14.10.0

package/fesm2022/dereekb-dbx-core.mjs

@@ -1,9 +1,9 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, inject, Injectable, makeEnvironmentProviders, DestroyRef, input, Directive, computed, signal, forwardRef, effect, TemplateRef, ViewContainerRef, Injector, runInInjectionContext, NgModule, Service, Input, output, model, booleanAttribute, Pipe, LOCALE_ID, viewChild, Component, Inject, Optional } from '@angular/core';
 import { HttpClient } from '@angular/common/http';
-import { defer, switchMap, first, distinctUntilChanged, filter, EMPTY, debounce, interval, throttle, exhaustMap, mergeMap, map, shareReplay, combineLatest, startWith, of, delay, BehaviorSubject, tap, combineLatestWith, catchError, withLatestFrom, firstValueFrom, takeUntil, Subject, Observable } from 'rxjs';
-import { AssetLoader, SubscriptionObject, LockSet, loadingStateContext, listLoadingStateContext, filterMaybe, LoadingStateType, beginLoading, idleLoadingState, errorResult, successResult, scanCount, workFactory, asObservable, combineLatestFromMapValuesObsFn, emitDelayObs, makeIsModifiedFunctionObservable, returnIfIs, timeoutStartWith, onFalseToTrue, onTrueToFalse, setContainsAllValuesFrom, setContainsNoValueFrom, maybeValueFromObservableOrValueGetter, switchMapToDefault, asObservableFromGetter, maybeValueFromObservableOrValue, distinctUntilKeysChange, FilterSource, FilterSourceConnector, FilterSourceInstance, FilterMap, skipAllInitialMaybe, switchMapObject } from '@dereekb/rxjs';
-import { getValueFromGetter, DestroyFunctionObject, isNotFalse, isDefinedAndNotFalse, BooleanStringKeyArrayUtility, reduceBooleansWithOrFn, asGetter, toReadableError, hasValueOrNotEmpty, isGetter, asArray, setIncludes, isAllowed, maybeSet, iterableToSet, IMPERSONATION_URL_QUERY_PARAM, expandTreeFunction, flattenTreeToArrayFunction, expandFlattenTreeFunction, mailToUrlString, telUrlString, mergeObjects, KeyValueTypleValueFilter, filterMaybeArrayValues, defaultForwardFunctionFactory, MINUTES_IN_DAY, MINUTES_IN_HOUR, millisecondsToMinutes, cutString, dollarAmountString, objectHasKey, objectHasKeys, safeEqualityComparatorFunction, mergeArrays, flattenArrayOrValueArray, promiseReference, DataIsExpiredError, DataDoesNotExistError, hasNonNullValue, unixDateTimeSecondsNumberForNow, isThrottled, splitJoinRemainder, StorageObjectUtility, SHARED_MEMORY_STORAGE } from '@dereekb/util';
+import { defer, switchMap, first, distinctUntilChanged, filter, EMPTY, debounce, interval, throttle, exhaustMap, mergeMap, map, shareReplay, combineLatest, startWith, of, delay, BehaviorSubject, tap, combineLatestWith, catchError, withLatestFrom, firstValueFrom, takeUntil, Subject, Observable, skip } from 'rxjs';
+import { AssetLoader, SubscriptionObject, LockSet, loadingStateContext, listLoadingStateContext, filterMaybe, LoadingStateType, beginLoading, idleLoadingState, errorResult, successResult, scanCount, workFactory, asObservable, combineLatestFromMapValuesObsFn, emitDelayObs, makeIsModifiedFunctionObservable, returnIfIs, timeoutStartWith, onFalseToTrue, onTrueToFalse, setContainsAllValuesFrom, setContainsNoValueFrom, maybeValueFromObservableOrValueGetter, switchMapToDefault, asObservableFromGetter, maybeValueFromObservableOrValue, distinctUntilKeysChange, FilterSource, FilterSourceConnector, FilterSourceInstance, FilterMap, distinctUntilObjectValuesChanged, skipAllInitialMaybe, switchMapObject } from '@dereekb/rxjs';
+import { getValueFromGetter, DestroyFunctionObject, isNotFalse, isDefinedAndNotFalse, BooleanStringKeyArrayUtility, reduceBooleansWithOrFn, asGetter, toReadableError, hasValueOrNotEmpty, isGetter, asArray, setIncludes, isAllowed, maybeSet, iterableToSet, IMPERSONATION_URL_QUERY_PARAM, expandTreeFunction, flattenTreeToArrayFunction, expandFlattenTreeFunction, mailToUrlString, telUrlString, mergeObjects, KeyValueTypleValueFilter, filterMaybeArrayValues, defaultForwardFunctionFactory, MINUTES_IN_DAY, MINUTES_IN_HOUR, millisecondsToMinutes, cutString, dollarAmountString, DataIsExpiredError, DataDoesNotExistError, hasNonNullValue, unixDateTimeSecondsNumberForNow, isThrottled, splitJoinRemainder, StorageObjectUtility, objectHasKey, objectHasKeys, safeEqualityComparatorFunction, mergeArrays, flattenArrayOrValueArray, promiseReference, SHARED_MEMORY_STORAGE } from '@dereekb/util';
 import { toObservable, toSignal, outputToObservable } from '@angular/core/rxjs-interop';
 import { ComponentStore } from '@ngrx/component-store';
 import { Actions, ofType, createEffect, provideEffects } from '@ngrx/effects';
@@ -8225,1196 +8225,1410 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImpor
         }] });
 
 /**
- * Type guard that checks if an object is a {@link ClickableFilterPreset}.
- *
- * @param preset - The object to check.
- * @returns `true` if the object has a `presetValue` property.
- */
-function isClickableFilterPreset(preset) {
-    return objectHasKey(preset, 'presetValue');
-}
-/**
- * Type guard that checks if an object is a {@link ClickablePartialFilterPreset}.
+ * Provides a read-only {@link FilterSource} that merges the filters of several keys in an ancestor {@link FilterMap} into one filter. Lets separate filter controls (e.g. a date popover and an attributes popover) each own a key while children consume a single combined filter.
  *
- * @param preset - The object to check.
- * @returns `true` if the object has `partialPresetValue` and `isActive` properties.
- */
-function isClickablePartialFilterPreset(preset) {
-    return objectHasKeys(preset, ['partialPresetValue', 'isActive']);
-}
-
-/**
- * Provides a {@link FilterSource} in DI so child components can inject and consume the current filter value. Use this on a wrapper element when the child is the canonical owner of the filter (a filter form, a chip group).
+ * Keys later in the array win when two keys set the same field, and the merged filter has no `preset`. Every key needs a value (e.g. a default filter) before the merged filter emits.
  *
  * @dbxFilter
- * @dbxFilterSlug source
- * @dbxFilterRelated connect-source, source-connector, map-source
+ * @dbxFilterSlug map-merge-source
+ * @dbxFilterRelated map, map-source, map-source-connector
  * @dbxFilterSkillRefs dbx__ref__dbx-component-patterns
  *
  * @example
  * ```html
- * <div dbxFilterSource>
- *   <my-filter-form></my-filter-form>
+ * <div dbxFilterMap>
+ *   <my-date-filter-button [dbxFilterMapSourceConnector]="'date'"></my-date-filter-button>
+ *   <my-attributes-filter-button [dbxFilterMapSourceConnector]="'attributes'"></my-attributes-filter-button>
+ *   <div [dbxFilterMapMergeSource]="['date', 'attributes']">
+ *     <my-filtered-list></my-filtered-list>
+ *   </div>
  * </div>
  * ```
  */
-class DbxFilterSourceDirective extends AbstractFilterSourceDirective {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxFilterSourceDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.4", type: DbxFilterSourceDirective, isStandalone: true, selector: "[dbxFilterSource]", providers: provideFilterSourceDirective(DbxFilterSourceDirective), usesInheritance: true, ngImport: i0 });
+class DbxFilterMapMergeSourceDirective {
+    dbxFilterMap = inject((FilterMap));
+    /**
+     * The map keys to merge, in priority order.
+     */
+    dbxFilterMapMergeSource = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "dbxFilterMapMergeSource" }] : /* istanbul ignore next */ []));
+    filterMapKeys$ = toObservable(this.dbxFilterMapMergeSource).pipe(filterMaybe(), distinctUntilObjectValuesChanged());
+    filter$ = this.filterMapKeys$.pipe(switchMap((keys) => this.dbxFilterMap.mergedFilterForKeys(keys)), shareReplay(1));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxFilterMapMergeSourceDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.4", type: DbxFilterMapMergeSourceDirective, isStandalone: true, selector: "[dbxFilterMapMergeSource]", inputs: { dbxFilterMapMergeSource: { classPropertyName: "dbxFilterMapMergeSource", publicName: "dbxFilterMapMergeSource", isSignal: true, isRequired: false, transformFunction: null } }, providers: [provideFilterSource(DbxFilterMapMergeSourceDirective)], exportAs: ["dbxFilterMapMergeSource"], ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxFilterSourceDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxFilterMapMergeSourceDirective, decorators: [{
             type: Directive,
             args: [{
-                    selector: '[dbxFilterSource]',
-                    providers: provideFilterSourceDirective(DbxFilterSourceDirective)
-                }]
-        }] });
-
-const importsAndExports = [DbxFilterSourceDirective, DbxFilterMapSourceConnectorDirective, DbxFilterConnectSourceDirective, DbxFilterSourceConnectorDirective, DbxFilterMapDirective, DbxFilterMapSourceDirective];
-class DbxCoreFilterModule {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxCoreFilterModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.1.4", ngImport: i0, type: DbxCoreFilterModule, imports: [DbxFilterSourceDirective, DbxFilterMapSourceConnectorDirective, DbxFilterConnectSourceDirective, DbxFilterSourceConnectorDirective, DbxFilterMapDirective, DbxFilterMapSourceDirective], exports: [DbxFilterSourceDirective, DbxFilterMapSourceConnectorDirective, DbxFilterConnectSourceDirective, DbxFilterSourceConnectorDirective, DbxFilterMapDirective, DbxFilterMapSourceDirective] });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxCoreFilterModule });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxCoreFilterModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: importsAndExports,
-                    exports: importsAndExports
+                    selector: '[dbxFilterMapMergeSource]',
+                    exportAs: 'dbxFilterMapMergeSource',
+                    providers: [provideFilterSource(DbxFilterMapMergeSourceDirective)]
                 }]
-        }] });
+        }], propDecorators: { dbxFilterMapMergeSource: [{ type: i0.Input, args: [{ isSignal: true, alias: "dbxFilterMapMergeSource", required: false }] }] } });
 
 /**
- * Injection token used to provide arbitrary data to dynamically created components.
- *
- * Components created via {@link DbxInjectionComponentConfig} can inject this token
- * to access the `data` property from their configuration.
+ * Default {@link SimpleStorageAccessorConverter} that uses `JSON.stringify`/`JSON.parse` for conversion.
  *
- * @example
- * ```typescript
- * // In a dynamically injected component:
- * readonly data = inject(DBX_INJECTION_COMPONENT_DATA);
- * ```
+ * @typeParam T - The type of value being converted.
  */
-const DBX_INJECTION_COMPONENT_DATA = new InjectionToken('DbxInjectionComponentConfigData');
+class StringifySimpleStorageAccessorConverter {
+    stringifyValue(value) {
+        return JSON.stringify(value);
+    }
+    parseValue(data) {
+        return JSON.parse(data);
+    }
+}
 /**
- * Compares two {@link DbxInjectionComponentConfig} values for structural equality, safely handling nullish values.
- *
- * Compares `componentClass`, `data`, `init`, and `injector` by reference. Does NOT compare
- * `providers` or `ngModuleRef`, as provider arrays typically change on every list data update
- * (e.g., with new `DBX_VALUE_LIST_VIEW_ITEM` values) without requiring component recreation.
+ * Composes a {@link StorageAccessor} and a {@link SimpleStorageAccessorConverter} into a single
+ * {@link SimpleStorageAccessorDelegate} implementation.
  *
- * When both values are nullish, uses strict equality (`null === null` is `true`,
- * `null === undefined` is `false`). The comparator is only invoked when both are non-nullish.
+ * @typeParam T - The type of value being stored.
  */
-const dbxInjectionComponentConfigIsEqual = safeEqualityComparatorFunction((a, b) => a.componentClass === b.componentClass && a.data === b.data && a.init === b.init && a.injector === b.injector);
+class WrapperSimpleStorageAccessorDelegate {
+    _delegate;
+    _converter;
+    constructor(delegate, converter) {
+        this._delegate = delegate;
+        this._converter = converter;
+    }
+    get(key) {
+        return this._delegate.get(key);
+    }
+    set(key, value) {
+        return this._delegate.set(key, value);
+    }
+    remove(key) {
+        return this._delegate.remove(key);
+    }
+    clear() {
+        return this._delegate.clear();
+    }
+    all(prefix) {
+        return this._delegate.all(prefix);
+    }
+    allKeys(prefix) {
+        return this._delegate.allKeys(prefix);
+    }
+    stringifyValue(value) {
+        return this._converter.stringifyValue(value);
+    }
+    parseValue(data) {
+        return this._converter.parseValue(data);
+    }
+}
 /**
- * Merges multiple partial {@link DbxInjectionComponentConfig} objects into a single configuration.
- *
- * Provider arrays are concatenated so that all providers from all configs are preserved.
- * All other properties are merged with later values taking precedence.
+ * Validates that a storage key prefix is non-empty and does not contain the prefix splitter character.
  *
- * @param configs - The partial configs to merge. May contain `undefined`/`null` entries which are filtered out.
- * @returns A single merged partial configuration.
+ * @param prefix - The prefix string to validate.
+ * @param prefixSplitter - The splitter string that separates the prefix from the key.
+ * @throws {Error} If the prefix is invalid or the splitter is empty.
  */
-function mergeDbxInjectionComponentConfigs(configs) {
-    const providers = mergeArrays(filterMaybeArrayValues(configs).map((x) => x.providers));
-    const result = mergeObjects(configs);
-    result.providers = providers;
-    return result;
+function assertValidStorageKeyPrefix(prefix, prefixSplitter) {
+    if (!prefixSplitter) {
+        throw new Error('Invalid storage key prefix splitter. Must be defined and not empty.'); // TODO(FUTURE): Consider changing to a concrete error type
+    }
+    if (!isValidStorageKeyPrefix(prefix, prefixSplitter)) {
+        throw new Error('Invalid storage key prefix.');
+    }
 }
-
 /**
- * Flattens and merges multiple provider sources into a single `StaticProvider[]` array.
- *
- * Each argument can be a single `StaticProvider`, an array of providers, or `undefined`/`null`.
- * All values are flattened into a single array with nullish entries removed.
- *
- * @param providers - Any number of provider values or arrays to merge.
- * @returns A flat array of all non-nullish static providers.
+ * Checks whether a storage key prefix is valid (non-empty and does not contain the splitter).
  *
- * @example
- * ```typescript
- * const providers = mergeStaticProviders(
- *   { provide: TOKEN_A, useValue: 'a' },
- *   undefined,
- *   [{ provide: TOKEN_B, useValue: 'b' }]
- * );
- * // Result: [{ provide: TOKEN_A, useValue: 'a' }, { provide: TOKEN_B, useValue: 'b' }]
- * ```
+ * @param prefix - The prefix string to validate.
+ * @param prefixSpltter - The splitter string that separates the prefix from the key.
+ * @returns `true` if the prefix is valid.
  */
-function mergeStaticProviders(...providers) {
-    return flattenArrayOrValueArray(providers);
+function isValidStorageKeyPrefix(prefix, prefixSpltter) {
+    return Boolean(prefix?.indexOf(prefixSpltter) === -1);
 }
 /**
- * Builds an element injector from a {@link DbxInjectionComponentConfig},
- * merging the config's providers and {@link DBX_INJECTION_COMPONENT_DATA} into a child injector.
+ * Full-featured {@link StorageAccessor} that adds key namespacing, JSON serialization,
+ * and optional time-based expiration on top of a raw string storage backend.
  *
- * Returns the config's injector (or parent) unchanged if no providers or data are specified.
+ * Values are stored as JSON with metadata (timestamp) and automatically checked
+ * for expiration on read.
  *
- * @param params - The config and parent injector to build from.
- * @returns A child {@link Injector} with the config's providers and data, or the parent injector if none are specified.
+ * @typeParam T - The type of values stored.
+ *
+ * @throws {DataDoesNotExistError} When reading a key that does not exist.
+ * @throws {DataIsExpiredError} When reading a key whose stored data has expired.
  *
  * @example
  * ```typescript
- * const injector = createInjectorForInjectionComponentConfig({
- *   config: { componentClass: MyComponent, data: { id: 1 }, providers: [myProvider] },
- *   parentInjector: this._injector
+ * const accessor = factory.createStorageAccessor<UserSettings>({
+ *   prefix: 'user_prefs',
+ *   expiresIn: 3600000,
  * });
+ *
+ * accessor.set('theme', { dark: true }).subscribe();
+ * accessor.get('theme').subscribe(settings => console.log(settings));
  * ```
- * @__NO_SIDE_EFFECTS__
  */
-function createInjectorForInjectionComponentConfig(params) {
-    const { config, parentInjector } = params;
-    const { injector: inputInjector, providers, data } = config;
-    const parent = inputInjector ?? parentInjector;
-    let result;
-    if (!providers && data == null) {
-        result = parent;
+class SimpleStorageAccessor {
+    static PREFIX_SPLITTER = '::';
+    _delegate;
+    _config;
+    constructor(delegate, config) {
+        const prefix = config.prefix;
+        const prefixSplitter = config.prefixSplitter ?? SimpleStorageAccessor.PREFIX_SPLITTER;
+        assertValidStorageKeyPrefix(prefix, prefixSplitter);
+        const fullPrefix = `${prefix}${prefixSplitter}`;
+        this._delegate = delegate;
+        this._config = {
+            ...config,
+            prefixSplitter,
+            fullPrefix
+        };
     }
-    else {
-        result = Injector.create({
-            parent,
-            providers: mergeStaticProviders({ provide: DBX_INJECTION_COMPONENT_DATA, useValue: data }, providers)
-        });
+    get delegate() {
+        return this._delegate;
     }
-    return result;
-}
-/**
- * Runs the init callback from a {@link DbxInjectionComponentConfig} on the given component ref,
- * executing within the component's injection context so that `inject()` is available inside the callback.
- *
- * @param componentRef - The component reference whose instance will be passed to the init callback.
- * @param config - The injection component config containing the optional init callback.
- *
- * @example
- * ```typescript
- * const ref = viewContainerRef.createComponent(config.componentClass, { injector });
- * initInjectionComponent(ref, config);
- * ```
- */
-function initInjectionComponent(componentRef, config) {
-    const { init } = config;
-    if (init) {
-        runInInjectionContext(componentRef.injector, () => init(componentRef.instance));
+    get config() {
+        return this._config;
     }
-}
-
-/**
- * Core runtime engine for the dbx-injection system. Manages the lifecycle of dynamically injected
- * components and templates within an Angular `ViewContainerRef`.
- *
- * This class reactively listens to configuration and template observables. When a new
- * {@link DbxInjectionComponentConfig} or {@link DbxInjectionTemplateConfig} is emitted, it tears
- * down the previous content and creates the new component or template in the target view container.
- *
- * Component configs take precedence over template configs when both are provided.
- *
- * Typically used internally by {@link AbstractDbxInjectionDirective} and {@link DbxInjectionComponent}
- * rather than consumed directly.
- *
- * @typeParam T - The type of the dynamically created component.
- *
- * @see {@link DbxInjectionComponentConfig}
- * @see {@link DbxInjectionTemplateConfig}
- * @see {@link AbstractDbxInjectionDirective}
- */
-class DbxInjectionInstance {
-    _subscriptionObject = new SubscriptionObject();
-    _config = new BehaviorSubject(undefined);
-    _template = new BehaviorSubject(undefined);
-    _content = new BehaviorSubject(undefined);
-    _componentRef = new BehaviorSubject(undefined);
-    _injector;
-    config$ = this._config.pipe(maybeValueFromObservableOrValueGetter(), distinctUntilChanged(dbxInjectionComponentConfigIsEqual), shareReplay(1));
-    template$ = this._template.pipe(maybeValueFromObservableOrValueGetter(), distinctUntilChanged(), shareReplay(1));
-    content$ = this._content.pipe(filterMaybe(), distinctUntilChanged(), shareReplay(1));
-    get config() {
-        return this._config.value;
-    }
-    set config(config) {
-        this._config.next(config);
+    // MARK: LimitedStorageAccessor
+    get(inputKey) {
+        const storeKey = this.makeStorageKey(inputKey);
+        return this._delegate.get(storeKey).pipe(map((storedData) => {
+            let result;
+            if (storedData) {
+                const readStoredData = this.readStoredData(storedData);
+                if (readStoredData.expired) {
+                    throw new DataIsExpiredError(readStoredData);
+                }
+                else {
+                    result = readStoredData.convertedData;
+                }
+            }
+            else {
+                throw new DataDoesNotExistError();
+            }
+            return result;
+        }));
     }
-    get template() {
-        return this._template.value;
+    set(inputKey, inputValue) {
+        const storeKey = this.makeStorageKey(inputKey);
+        const storeData = this.buildStoredData(inputValue);
+        const data = JSON.stringify(storeData);
+        return this._delegate.set(storeKey, data);
     }
-    set template(template) {
-        this._template.next(template);
+    remove(key) {
+        const storeKey = this.makeStorageKey(key);
+        return this._delegate.remove(storeKey);
     }
-    get content() {
-        return this._content.value;
+    all() {
+        return this._delegate.all(this._config.fullPrefix).pipe(map((allStoredData) => {
+            return allStoredData
+                .map((storedData) => {
+                const readStoredData = this.readStoredData(storedData);
+                return readStoredData.expired ? null : readStoredData.convertedData;
+            })
+                .filter(hasNonNullValue);
+        }));
     }
-    set content(content) {
-        this._content.next(content);
+    allKeys() {
+        return this._delegate.allKeys(this._config.fullPrefix).pipe(map((keys) => keys.map((x) => this.decodeStorageKey(x))));
     }
-    get componentRef() {
-        return this._componentRef.value;
+    clear() {
+        return this._delegate.clear();
     }
-    set componentRef(componentRef) {
-        this._componentRef.next(componentRef);
+    // MARK: Stored Values
+    readStoredData(storedDataString) {
+        const storedData = JSON.parse(storedDataString);
+        const expired = this.isExpiredStoredData(storedData);
+        const convertedData = this._delegate.parseValue(storedData.data);
+        return {
+            ...storedData,
+            expired,
+            convertedData
+        };
     }
-    constructor(injector) {
-        this._injector = injector;
+    buildStoredData(value) {
+        return {
+            storedAt: unixDateTimeSecondsNumberForNow(),
+            data: this.stringifyValue(value)
+        };
     }
-    init() {
-        // Wait until the first of either of the two inputs comes in as not defined, and then emit.
-        // We filter the first maybe here between the two items.
-        const configTemplateObs = combineLatest([this.config$, this.template$]).pipe(map(([config, template]) => {
-            return config || template ? { config, template } : undefined;
-        }), skipAllInitialMaybe());
-        this._subscriptionObject.subscription = combineLatest([configTemplateObs, this.content$]).subscribe(([inputConfig, content]) => {
-            const { config, template } = inputConfig ?? {};
-            this._reset(content);
-            if (config) {
-                this._initComponent(config, content);
+    isExpiredStoredData(storeData) {
+        const expiresIn = this._config.expiresIn;
+        let result;
+        if (expiresIn) {
+            if (storeData.storedAt) {
+                result = isThrottled(expiresIn, storeData.storedAt);
             }
-            else if (template) {
-                this._initTemplate(template, content);
+            else {
+                result = true;
             }
-        });
+        }
+        else {
+            result = false;
+        }
+        return result;
     }
-    destroy() {
-        this._subscriptionObject.destroy();
-        this._config.complete();
-        this._template.complete();
-        this._content.complete();
-        this._componentRef.complete();
+    // MARK: Internal
+    makeStorageKey(key) {
+        return `${this._config.prefix}${this._config.prefixSplitter}${String(key)}`;
     }
-    _initComponent(config, content) {
-        content.clear();
-        const { componentClass, ngModuleRef } = config;
-        if (!componentClass) {
-            throw new Error('DbxInjectionInstance: componentClass was expected in the config but it was unavailable.');
-        }
-        const injector = createInjectorForInjectionComponentConfig({ config, parentInjector: this._injector });
-        const componentRef = content.createComponent(componentClass, { injector, ngModuleRef });
-        initInjectionComponent(componentRef, config);
-        this.componentRef = componentRef;
+    isKeyOfAccessor(storageKey) {
+        return storageKey.startsWith(this._config.fullPrefix);
     }
-    _initTemplate(config, content) {
-        content.clear();
-        const { templateRef, viewRef } = config;
-        if (templateRef) {
-            content.createEmbeddedView(templateRef);
-            // TODO: Figure out if these items need to be destroyed or not when this item is destroyed. If so, we need a reference to destroy.
-        }
-        else if (viewRef) {
-            content.insert(viewRef);
-        }
+    decodeStorageKey(storageKey) {
+        const split = splitJoinRemainder(storageKey, this._config.prefixSplitter, 2);
+        return split[1];
     }
-    _reset(content) {
-        if (this.componentRef) {
-            content.clear();
-            this.componentRef = undefined;
-        }
+    stringifyValue(value) {
+        return this._delegate.stringifyValue(value);
     }
 }
 
 /**
- * Abstract base directive for dynamically injecting components or templates into a view.
- *
- * Manages a {@link DbxInjectionInstance} lifecycle, initializing it on `ngOnInit` and
- * destroying it on `ngOnDestroy`. Subclasses are responsible for wiring their inputs
- * (config, template, content) to the corresponding setter methods.
+ * {@link StorageAccessor} implementation that wraps a {@link FullStorageObject} and stores raw strings.
  *
- * @typeParam T - The type of the dynamically created component.
+ * Each operation completes synchronously within an observable wrapper.
  *
- * @see {@link DbxInjectionComponent} - The concrete standalone component implementation.
- * @see {@link DbxInjectionInstance}
+ * @example
+ * ```typescript
+ * const accessor = new StringStorageAccessor(localStorage);
+ * accessor.set('key', 'value').subscribe();
+ * accessor.get('key').subscribe(value => console.log(value)); // 'value'
+ * ```
  */
-class AbstractDbxInjectionDirective {
-    _instance = new DbxInjectionInstance(inject(Injector));
-    ngOnInit() {
-        this._instance.init();
+class StringStorageAccessor {
+    _storage;
+    constructor(storage) {
+        this._storage = storage;
     }
-    ngOnDestroy() {
-        this._instance.destroy();
+    get(key) {
+        return new Observable((x) => {
+            const value = this._storage.getItem(key);
+            x.next(value);
+            x.complete();
+        });
     }
-    /**
-     * Sets the component injection configuration on the underlying {@link DbxInjectionInstance}.
-     *
-     * @param config - The component config, observable, or getter to use.
-     */
-    setConfig(config) {
-        this._instance.config = config;
+    set(key, value) {
+        return new Observable((x) => {
+            this._storage.setItem(key, value);
+            x.next();
+            x.complete();
+        });
     }
-    /**
-     * Sets the template injection configuration on the underlying {@link DbxInjectionInstance}.
-     *
-     * @param template - The template config, observable, or getter to use.
-     */
-    setTemplate(template) {
-        this._instance.template = template;
+    remove(key) {
+        return new Observable((x) => {
+            this._storage.removeItem(key);
+            x.next();
+            x.complete();
+        });
     }
-    /**
-     * Sets the target `ViewContainerRef` where dynamic content will be inserted.
-     *
-     * @param content - The view container reference for content projection.
-     */
-    setContent(content) {
-        this._instance.content = content;
+    clear() {
+        const removed = this._storage.removeAll();
+        return new Observable((x) => {
+            x.next(removed);
+            x.complete();
+        });
+    }
+    all() {
+        return this.allKeys().pipe(map((x) => filterMaybeArrayValues(x.map((y) => this._storage.getItem(y)))), shareReplay(1));
+    }
+    allKeys() {
+        return new Observable((x) => {
+            const result = StorageObjectUtility.allKeysFromStorageObject(this._storage);
+            x.next(result);
+            x.complete();
+        });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: AbstractDbxInjectionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.4", type: AbstractDbxInjectionDirective, isStandalone: true, ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: AbstractDbxInjectionDirective, decorators: [{
-            type: Directive
-        }] });
 
 /**
- * Standalone component for dynamically injecting a component or template into the DOM.
- *
- * Accepts a {@link DbxInjectionComponentConfig} (to create a component) or a
- * {@link DbxInjectionTemplateConfig} (to embed a template/view). When the config changes,
- * the previous content is destroyed and the new content is created in its place.
+ * DI token for the application's default {@link FullStorageObject} instance.
  *
- * Can be used as an element (`<dbx-injection>`) or as an attribute directive
- * (`[dbxInjection]` / `[dbx-injection]`).
+ * Provided by {@link provideDbxStorage}.
+ */
+const DEFAULT_STORAGE_OBJECT_TOKEN = new InjectionToken('DBX_CORE_DEFAULT_STORAGE_OBJECT');
+/**
+ * DI token for the application's default {@link SimpleStorageAccessorFactory} instance.
  *
- * @typeParam T - The type of the dynamically created component.
+ * Provided by {@link provideDbxStorage}.
+ */
+const DEFAULT_STORAGE_ACCESSOR_FACTORY_TOKEN = new InjectionToken('DBX_CORE_DEFAULT_STORAGE_ACCESSOR_FACTORY');
+
+/**
+ * Injectable factory for creating namespaced {@link SimpleStorageAccessor} instances
+ * backed by the application's default storage object.
  *
  * @example
- * ```html
- * <!-- Element usage with a component config -->
- * <dbx-injection [config]="myComponentConfig"></dbx-injection>
- *
- * <!-- Element usage with a template config -->
- * <dbx-injection [template]="myTemplateConfig"></dbx-injection>
+ * ```typescript
+ * @Injectable()
+ * export class UserPrefsService {
+ *   private readonly storage = inject(SimpleStorageAccessorFactory)
+ *     .createStorageAccessor<UserPrefs>({ prefix: 'user_prefs' });
  *
- * <!-- Attribute usage -->
- * <div dbxInjection [config]="myComponentConfig"></div>
+ *   save(prefs: UserPrefs) { return this.storage.set('current', prefs); }
+ *   load() { return this.storage.get('current'); }
+ * }
  * ```
+ */
+class SimpleStorageAccessorFactory {
+    storageObject = inject(DEFAULT_STORAGE_OBJECT_TOKEN);
+    createStorageAccessor(config) {
+        const storage = config.storage ?? new StringStorageAccessor(this.storageObject);
+        const converter = config.converter ?? new StringifySimpleStorageAccessorConverter();
+        const delegate = new WrapperSimpleStorageAccessorDelegate(storage, converter);
+        const accessorConfig = {
+            prefix: config.prefix
+        };
+        return new SimpleStorageAccessor(delegate, accessorConfig);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: SimpleStorageAccessorFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: SimpleStorageAccessorFactory });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: SimpleStorageAccessorFactory, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Default storage key prefix used by {@link DbxFilterStorageService}.
+ */
+const DEFAULT_DBX_FILTER_STORAGE_PREFIX = 'dbxf';
+/**
+ * Optional injection token for the {@link DbxFilterStorageServiceConfig}.
+ */
+const DBX_FILTER_STORAGE_SERVICE_CONFIG_TOKEN = new InjectionToken('DbxFilterStorageServiceConfig');
+/**
+ * Saves and loads filters to storage (localStorage by default, via {@link SimpleStorageAccessorFactory}).
  *
- * @see {@link DbxInjectionComponentConfig}
- * @see {@link DbxInjectionTemplateConfig}
- * @see {@link AbstractDbxInjectionDirective}
+ * Filters are saved as JSON. Filters with fields that JSON cannot represent, such as Date or Set fields, pass a {@link FilterJsonConverter}.
+ *
+ * To save and load the filter of a {@link FilterMap} key, use the {@link DbxFilterMapStorageDirective} in the template instead of calling this service directly.
+ *
+ * Provided by {@link provideDbxFilterStorage}, which requires {@link provideDbxStorage}.
  */
-class DbxInjectionComponent extends AbstractDbxInjectionDirective {
+class DbxFilterStorageService {
+    storageAccessorFactory = inject(SimpleStorageAccessorFactory);
+    config = inject(DBX_FILTER_STORAGE_SERVICE_CONFIG_TOKEN, { optional: true });
+    prefix = this.config?.prefix ?? DEFAULT_DBX_FILTER_STORAGE_PREFIX;
+    storageAccessor = this.storageAccessorFactory.createStorageAccessor({
+        prefix: this.prefix
+    });
     /**
-     * Reference to the internal view container where dynamic content is projected.
+     * Loads the saved filter for the given storage key.
+     *
+     * @param storageKey - Key the filter was saved under.
+     * @param jsonConverter - Converts the saved JSON value back to the filter. Without one, the saved value is returned as-is.
+     * @returns Observable of the saved filter, or undefined if nothing is saved or the saved value cannot be read.
      */
-    content = viewChild('content', { ...(ngDevMode ? { debugName: "content" } : /* istanbul ignore next */ {}), read: ViewContainerRef });
+    loadFilter(storageKey, jsonConverter) {
+        return this.storageAccessor.get(storageKey).pipe(map((json) => {
+            let result;
+            if (json != null) {
+                result = jsonConverter ? jsonConverter.fromJson(json) : json;
+            }
+            return result;
+        }), catchError(() => of(undefined)));
+    }
     /**
-     * The component injection configuration. Accepts an observable, getter, or static value.
+     * Saves the filter under the given storage key.
+     *
+     * @param storageKey - Key to save the filter under.
+     * @param filter - Filter to save.
+     * @param jsonConverter - Converts the filter to the JSON value that is saved. Without one, the filter is saved as-is.
+     * @returns Observable that emits once the filter is saved.
      */
-    config = input(/* @ts-ignore */
-    ...(ngDevMode ? [undefined, { debugName: "config" }] : /* istanbul ignore next */ []));
+    saveFilter(storageKey, filter, jsonConverter) {
+        return this.storageAccessor.set(storageKey, jsonConverter ? jsonConverter.toJson(filter) : filter);
+    }
     /**
-     * The template injection configuration. Accepts an observable, getter, or static value.
-     * Only used when `config` is not provided.
+     * Removes the saved filter for the given storage key.
+     *
+     * @param storageKey - Key the filter was saved under.
+     * @returns Observable that emits once the filter is removed.
      */
-    template = input(/* @ts-ignore */
-    ...(ngDevMode ? [undefined, { debugName: "template" }] : /* istanbul ignore next */ []));
-    // allow signal writes for each as during their initialization they may write to a signal in some cases when initializing
-    _contentEffect = effect(() => this.setContent(this.content()), /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "_contentEffect" }] : /* istanbul ignore next */ []));
-    _configEffect = effect(() => this.setConfig(this.config()), /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "_configEffect" }] : /* istanbul ignore next */ []));
-    _templateEffect = effect(() => this.setTemplate(this.template()), /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "_templateEffect" }] : /* istanbul ignore next */ []));
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxInjectionComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "22.1.4", type: DbxInjectionComponent, isStandalone: true, selector: "dbx-injection, [dbxInjection], [dbx-injection]", inputs: { config: { classPropertyName: "config", publicName: "config", isSignal: true, isRequired: false, transformFunction: null }, template: { classPropertyName: "template", publicName: "template", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "content", first: true, predicate: ["content"], descendants: true, read: ViewContainerRef, isSignal: true }], usesInheritance: true, ngImport: i0, template: `
-    <ng-template #content></ng-template>
-  `, isInline: true });
+    clearFilter(storageKey) {
+        return this.storageAccessor.remove(storageKey);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxFilterStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxFilterStorageService });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxInjectionComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'dbx-injection, [dbxInjection], [dbx-injection]',
-                    template: `
-    <ng-template #content></ng-template>
-  `,
-                    imports: []
-                }]
-        }], propDecorators: { content: [{ type: i0.ViewChild, args: ['content', { ...{ read: ViewContainerRef }, isSignal: true }] }], config: [{ type: i0.Input, args: [{ isSignal: true, alias: "config", required: false }] }], template: [{ type: i0.Input, args: [{ isSignal: true, alias: "template", required: false }] }] } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxFilterStorageService, decorators: [{
+            type: Injectable
+        }] });
 
 /**
- * Renders a list of dynamically injected components from an array of {@link DbxInjectionArrayEntry} items.
+ * Saves the filter of a keyed entry in an ancestor {@link FilterMap} to storage (localStorage by default), and loads it again when the page loads. The saved filter becomes the key's default filter, and every later change to the key is saved.
  *
- * Each entry is tracked by its `key` property for efficient change detection, and rendered
- * using a nested {@link DbxInjectionComponent}.
+ * Use {@link reset} to set the key back to its default filter and remove the saved filter.
  *
- * @example
- * ```html
- * <dbx-injection-array [entries]="myEntries" />
- * ```
+ * Requires {@link provideDbxFilterStorage}.
+ *
+ * @dbxFilter
+ * @dbxFilterSlug map-storage
+ * @dbxFilterRelated map, map-source-connector, map-merge-source
+ * @dbxFilterSkillRefs dbx__ref__dbx-component-patterns
  *
  * @example
- * ```typescript
- * // In the host component:
- * myEntries: DbxInjectionArrayEntry[] = [
- *   { key: 'chart', injectionConfig: { componentClass: ChartComponent } },
- *   { key: 'table', injectionConfig: { componentClass: TableComponent } }
- * ];
+ * ```html
+ * <div dbxFilterMap>
+ *   <my-filter-button [dbxFilterMapSourceConnector]="'list'" [dbxFilterMapStorage]="{ key: 'list', storageKey: 'my.list.filter', defaultFilter: {} }"></my-filter-button>
+ * </div>
  * ```
- *
- * @see {@link DbxInjectionArrayEntry}
- * @see {@link DbxInjectionComponent}
  */
-class DbxInjectionArrayComponent {
+class DbxFilterMapStorageDirective {
+    dbxFilterMap = inject((FilterMap));
+    dbxFilterStorageService = inject(DbxFilterStorageService);
     /**
-     * The array of keyed injection entries to render. Each entry produces a `<dbx-injection>` component.
+     * The key to save and how to save it.
      */
-    entries = input(undefined, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "entries" }] : /* istanbul ignore next */ []));
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxInjectionArrayComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.1.4", type: DbxInjectionArrayComponent, isStandalone: true, selector: "dbx-injection-array", inputs: { entries: { classPropertyName: "entries", publicName: "entries", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
-    @for (entry of entries(); track entry.key) {
-      <dbx-injection [config]="entry.injectionConfig"></dbx-injection>
+    dbxFilterMapStorage = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "dbxFilterMapStorage" }] : /* istanbul ignore next */ []));
+    config$ = toObservable(this.dbxFilterMapStorage).pipe(filterMaybe(), distinctUntilChanged(), shareReplay(1));
+    /**
+     * Set while reset() sets the key back to the default filter, so the default filter is not saved.
+     */
+    _resetting = false;
+    constructor() {
+        cleanSubscription(this.config$.pipe(switchMap((config) => this._loadAndSaveFilter(config))).subscribe());
     }
-  `, isInline: true, dependencies: [{ kind: "component", type: DbxInjectionComponent, selector: "dbx-injection, [dbxInjection], [dbx-injection]", inputs: ["config", "template"] }] });
+    /**
+     * Sets the key back to the default filter and removes the saved filter.
+     *
+     * The default filter is not saved, so the next page load also starts from the default filter.
+     *
+     * @returns Observable that emits once the key is reset and the saved filter is removed.
+     */
+    reset() {
+        return this.config$.pipe(first(), switchMap((config) => asObservable(config.defaultFilter).pipe(first(), tap((defaultFilter) => {
+            if (defaultFilter != null) {
+                this._resetting = true;
+                this.dbxFilterMap.setFilterForKey(config.key, defaultFilter);
+                this._resetting = false;
+            }
+        }), switchMap(() => this.dbxFilterStorageService.clearFilter(storageKeyForConfig(config))))));
+    }
+    /**
+     * Loads the saved filter as the key's default filter, then returns an observable that saves every later change to the key.
+     *
+     * @param config - The key to save and how to save it.
+     * @returns Observable that saves the key's filter while subscribed.
+     */
+    _loadAndSaveFilter(config) {
+        const { key, defaultFilter, mapLoadedFilter, jsonConverter } = config;
+        const storageKey = storageKeyForConfig(config);
+        const loadedFilter$ = this.dbxFilterStorageService.loadFilter(storageKey, jsonConverter).pipe(map((savedFilter) => (savedFilter != null && mapLoadedFilter ? mapLoadedFilter(savedFilter) : savedFilter)), switchMap((savedFilter) => (savedFilter == null ? asObservable(defaultFilter) : of(savedFilter))), filterMaybe());
+        this.dbxFilterMap.addDefaultFilterObs(key, loadedFilter$);
+        return this.dbxFilterMap.filterForKey(key).pipe(distinctUntilObjectValuesChanged(), skip(1), // the first value is the loaded/default filter
+        filter(() => !this._resetting), switchMap((nextFilter) => this.dbxFilterStorageService.saveFilter(storageKey, nextFilter, jsonConverter)));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxFilterMapStorageDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.4", type: DbxFilterMapStorageDirective, isStandalone: true, selector: "[dbxFilterMapStorage]", inputs: { dbxFilterMapStorage: { classPropertyName: "dbxFilterMapStorage", publicName: "dbxFilterMapStorage", isSignal: true, isRequired: false, transformFunction: null } }, exportAs: ["dbxFilterMapStorage"], ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxInjectionArrayComponent, decorators: [{
-            type: Component,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxFilterMapStorageDirective, decorators: [{
+            type: Directive,
             args: [{
-                    selector: 'dbx-injection-array',
-                    template: `
-    @for (entry of entries(); track entry.key) {
-      <dbx-injection [config]="entry.injectionConfig"></dbx-injection>
-    }
-  `,
-                    imports: [DbxInjectionComponent]
+                    selector: '[dbxFilterMapStorage]',
+                    exportAs: 'dbxFilterMapStorage'
                 }]
-        }], propDecorators: { entries: [{ type: i0.Input, args: [{ isSignal: true, alias: "entries", required: false }] }] } });
+        }], ctorParameters: () => [], propDecorators: { dbxFilterMapStorage: [{ type: i0.Input, args: [{ isSignal: true, alias: "dbxFilterMapStorage", required: false }] }] } });
+function storageKeyForConfig(config) {
+    return config.storageKey ?? config.key;
+}
 
 /**
- * Abstract service for temporarily replacing a view's content with a dynamically injected component,
- * then restoring the original content when done.
- *
- * Unlike `*ngIf` or `*ngSwitch`, the original child content is **hidden** rather than destroyed,
- * preserving component state. Once the injected context's promise resolves (or is reset), the
- * original content is re-displayed.
- *
- * This is useful for overlay-like workflows such as inline editors, confirmation dialogs,
- * or multi-step flows where destroying and recreating the underlying view would lose state.
+ * Type guard that checks if an object is a {@link ClickableFilterPreset}.
  *
- * @see {@link DbxInjectionContextConfig}
- * @see {@link DbxInjectionContextDirective} - The concrete structural directive implementation.
+ * @param preset - The object to check.
+ * @returns `true` if the object has a `presetValue` property.
  */
-class DbxInjectionContext {
+function isClickableFilterPreset(preset) {
+    return objectHasKey(preset, 'presetValue');
 }
 /**
- * Creates Angular providers that register a concrete {@link DbxInjectionContext} implementation
- * under the abstract `DbxInjectionContext` token via `useExisting`.
- *
- * This enables dependency injection consumers to request `DbxInjectionContext` and receive
- * the specific directive or service implementation.
- *
- * @param type - The concrete class to register as the existing provider.
- * @returns Array of Angular providers.
+ * Type guard that checks if an object is a {@link ClickablePartialFilterPreset}.
  *
- * @typeParam T - The concrete type that extends {@link DbxInjectionContext}.
+ * @param preset - The object to check.
+ * @returns `true` if the object has `partialPresetValue` and `isActive` properties.
  */
-function provideDbxInjectionContext(type) {
-    return [
-        {
-            provide: DbxInjectionContext,
-            useExisting: type
-        }
-    ];
+function isClickablePartialFilterPreset(preset) {
+    return objectHasKeys(preset, ['partialPresetValue', 'isActive']);
 }
 
 /**
- * Structural directive that implements {@link DbxInjectionContext}, allowing its host content
- * to be temporarily replaced with a dynamically injected component and then restored.
- *
- * Unlike `*ngIf` or `*ngSwitch`, the original child content is **detached** (hidden) rather than
- * destroyed, so component state is preserved while the injected context is active. When the
- * context's promise resolves or {@link resetContext} is called, the original view is re-attached.
- *
- * The directive also accepts an optional `[dbxInjectionContext]` input to set a static component
- * config directly, which replaces the default content until cleared.
+ * Provides a {@link FilterSource} in DI so child components can inject and consume the current filter value. Use this on a wrapper element when the child is the canonical owner of the filter (a filter form, a chip group).
  *
- * @typeParam O - The output type produced by {@link showContext}.
+ * @dbxFilter
+ * @dbxFilterSlug source
+ * @dbxFilterRelated connect-source, source-connector, map-source
+ * @dbxFilterSkillRefs dbx__ref__dbx-component-patterns
  *
  * @example
  * ```html
- * <!-- Wrap content that should be temporarily replaceable -->
- * <div *dbxInjectionContext>
- *   <p>Original content preserved while context is active</p>
+ * <div dbxFilterSource>
+ *   <my-filter-form></my-filter-form>
  * </div>
  * ```
+ */
+class DbxFilterSourceDirective extends AbstractFilterSourceDirective {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxFilterSourceDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.4", type: DbxFilterSourceDirective, isStandalone: true, selector: "[dbxFilterSource]", providers: provideFilterSourceDirective(DbxFilterSourceDirective), usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxFilterSourceDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxFilterSource]',
+                    providers: provideFilterSourceDirective(DbxFilterSourceDirective)
+                }]
+        }] });
+
+const importsAndExports = [DbxFilterSourceDirective, DbxFilterMapSourceConnectorDirective, DbxFilterConnectSourceDirective, DbxFilterSourceConnectorDirective, DbxFilterMapDirective, DbxFilterMapSourceDirective, DbxFilterMapMergeSourceDirective, DbxFilterMapStorageDirective];
+class DbxCoreFilterModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxCoreFilterModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.1.4", ngImport: i0, type: DbxCoreFilterModule, imports: [DbxFilterSourceDirective, DbxFilterMapSourceConnectorDirective, DbxFilterConnectSourceDirective, DbxFilterSourceConnectorDirective, DbxFilterMapDirective, DbxFilterMapSourceDirective, DbxFilterMapMergeSourceDirective, DbxFilterMapStorageDirective], exports: [DbxFilterSourceDirective, DbxFilterMapSourceConnectorDirective, DbxFilterConnectSourceDirective, DbxFilterSourceConnectorDirective, DbxFilterMapDirective, DbxFilterMapSourceDirective, DbxFilterMapMergeSourceDirective, DbxFilterMapStorageDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxCoreFilterModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxCoreFilterModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: importsAndExports,
+                    exports: importsAndExports
+                }]
+        }] });
+
+/**
+ * Registers {@link DbxFilterStorageService} as an environment-level provider.
+ *
+ * Requires {@link provideDbxStorage} to also be provided.
+ *
+ * @param config - Optional service configuration.
+ * @returns The environment providers for filter storage.
  *
  * @example
  * ```typescript
- * // Programmatically show a temporary editor overlay:
- * const result = await injectionContext.showContext({
- *   config: { componentClass: InlineEditorComponent },
- *   use: (editor) => editor.waitForSave()
- * });
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [provideDbxStorage(), provideDbxFilterStorage()],
+ * };
  * ```
- *
- * @see {@link DbxInjectionContext}
- * @see {@link DbxInjectionContextConfig}
  */
-class DbxInjectionContextDirective {
-    _injector = inject(Injector);
-    _templateRef = inject((TemplateRef));
-    _viewContainer = inject(ViewContainerRef);
-    _instance = new DbxInjectionInstance(this._injector);
-    _currentPromise;
-    _embeddedView;
-    _isDetached = false;
-    /**
-     * Optional static component config input. When set, the directive replaces its content
-     * with the specified component. When cleared (`undefined`), the original content is restored.
-     */
-    config = input(/* @ts-ignore */
-    ...(ngDevMode ? [undefined, { debugName: "config" }] : /* istanbul ignore next */ []));
-    _configEffect = effect(() => {
-        this.setConfig(this.config());
-        // NOTE: we have/call setConfig() because the effect() may not respond to all value changes,
-        // especially when setConfig() ends up being called twice quickly in quick succession.
-    }, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "_configEffect" }] : /* istanbul ignore next */ []));
-    ngOnInit() {
-        this._instance.content = this._viewContainer;
-        this._instance.init();
-        this._embeddedView = this._viewContainer.createEmbeddedView(this._templateRef);
-        // detach the embedded view
-        this._viewContainer.detach();
-        // reattach it through the template configuration.
-        // the template configuration acts as the default.
-        this._instance.template = {
-            viewRef: this._embeddedView
-        };
-    }
-    ngOnDestroy() {
-        this._instance.destroy();
-        this._embeddedView?.destroy(); // destroy our embedded view too if it is set.
-    }
-    /**
-     * {@inheritDoc DbxInjectionContext.showContext}
-     *
-     * @param config - The injection context configuration describing the component and its usage.
-     * @returns Resolves to the output of the injected component's usage.
-     */
-    async showContext(config) {
-        // clear the current context before showing something new.
-        this.resetContext();
-        let promiseRef;
-        let result;
-        let error;
-        // wait for the promise to resolve and use to finish using that instance.
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-misused-promises
-            promiseRef = promiseReference(async (resolve, reject) => {
-                const injectionConfig = {
-                    ...config.config,
-                    // eslint-disable-next-line @typescript-eslint/no-misused-promises
-                    init: async (instance) => {
-                        // init if available in the base config.
-                        if (config.config.init) {
-                            config.config.init(instance);
-                        }
-                        try {
-                            const result = (await config.use(instance));
-                            resolve(result);
-                        }
-                        catch (e) {
-                            reject(e);
-                        }
-                    }
-                };
-                this.setConfig(injectionConfig);
-            });
-            this._currentPromise = promiseRef;
-            // await the promise
-            result = await promiseRef.promise;
-        }
-        catch (e) {
-            error = e;
-        }
-        // if we're still using the same promiseRef
-        if (promiseRef && promiseRef === this._currentPromise) {
-            // clear the config to reshow the view
-            this.setConfig(undefined);
-            // clear the current promise
-            this._currentPromise = undefined;
-        }
-        if (error != null) {
-            if (error instanceof Error) {
-                throw error;
-            }
-            let message;
-            if (error == null) {
-                message = String(error);
-            }
-            else if (typeof error === 'object') {
-                message = JSON.stringify(error);
-            }
-            else {
-                message = String(error);
-            }
-            throw new Error(message);
-        }
-        return result;
-    }
-    /**
-     * {@inheritDoc DbxInjectionContext.resetContext}
-     *
-     * @returns `true` if an active context was cleared, `false` otherwise.
-     */
-    resetContext() {
-        let clearedValue = false;
-        if (this._currentPromise) {
-            const promise = this._currentPromise;
-            // clear the current promise too
-            this._currentPromise = undefined;
-            // clear the config.
-            this.setConfig(undefined);
-            // send a rejection signal to bail out.
-            promise.reject(new Error('dbxInjectionContext bailout'));
-            clearedValue = true;
-        }
-        return clearedValue;
-    }
-    /**
-     * Sets or clears the active component configuration.
-     *
-     * When a config is provided, the original embedded view is detached and the component is injected.
-     * When `undefined` is provided, the injected component is removed and the original view is re-attached.
-     *
-     * @param config - The component config to display, or `undefined` to restore the original content.
-     */
-    setConfig(config) {
-        let reattach = false;
-        if (config) {
-            if (!this._isDetached) {
-                // detach the original view before setting config.
-                this._viewContainer.detach();
-                this._isDetached = true;
-            }
-        }
-        else if (this._isDetached) {
-            reattach = true;
-        }
-        this._instance.config = config;
-        if (reattach) {
-            this._viewContainer.insert(this._embeddedView);
-            this._isDetached = false;
-        }
+function provideDbxFilterStorage(config) {
+    const providers = [DbxFilterStorageService];
+    if (config) {
+        providers.push({
+            provide: DBX_FILTER_STORAGE_SERVICE_CONFIG_TOKEN,
+            useValue: config
+        });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxInjectionContextDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.4", type: DbxInjectionContextDirective, isStandalone: true, selector: "[dbxInjectionContext]", inputs: { config: { classPropertyName: "config", publicName: "config", isSignal: true, isRequired: false, transformFunction: null } }, providers: provideDbxInjectionContext(DbxInjectionContextDirective), ngImport: i0 });
+    return makeEnvironmentProviders(providers);
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxInjectionContextDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[dbxInjectionContext]',
-                    providers: provideDbxInjectionContext(DbxInjectionContextDirective)
-                }]
-        }], propDecorators: { config: [{ type: i0.Input, args: [{ isSignal: true, alias: "config", required: false }] }] } });
 
 /**
- * Abstract directive that delegates {@link DbxInjectionContext} operations to a host-level
- * `DbxInjectionContext` obtained via Angular's dependency injection (`{ host: true }`).
+ * Injection token used to provide arbitrary data to dynamically created components.
  *
- * This is useful for creating specialized injection context subtypes that can be injected
- * by their own token while still forwarding the actual show/reset behavior to a parent
- * {@link DbxInjectionContextDirective}.
+ * Components created via {@link DbxInjectionComponentConfig} can inject this token
+ * to access the `data` property from their configuration.
  *
  * @example
  * ```typescript
- * @Directive({ providers: [{ provide: MySpecialContext, useExisting: MyForwardDirective }] })
- * class MyForwardDirective extends AbstractForwardDbxInjectionContextDirective {}
+ * // In a dynamically injected component:
+ * readonly data = inject(DBX_INJECTION_COMPONENT_DATA);
  * ```
- *
- * @see {@link DbxInjectionContext}
- * @see {@link DbxInjectionContextDirective}
  */
-class AbstractForwardDbxInjectionContextDirective {
-    /**
-     * The host-level {@link DbxInjectionContext} that all operations are forwarded to.
-     */
-    dbxInjectionContext = inject(DbxInjectionContext, { host: true });
-    // MARK: DbxInjectionContext
-    /**
-     * {@inheritDoc DbxInjectionContext.showContext}
-     *
-     * @param config - The injection context configuration to forward to the host context.
-     * @returns Resolves to the output of the injected component's usage.
-     */
-    showContext(config) {
-        return this.dbxInjectionContext.showContext(config);
-    }
-    /**
-     * {@inheritDoc DbxInjectionContext.resetContext}
-     *
-     * @returns `true` if an active context was cleared, `false` otherwise.
-     */
-    resetContext() {
-        return this.dbxInjectionContext.resetContext();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: AbstractForwardDbxInjectionContextDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.4", type: AbstractForwardDbxInjectionContextDirective, isStandalone: true, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: AbstractForwardDbxInjectionContextDirective, decorators: [{
-            type: Directive
-        }] });
-
+const DBX_INJECTION_COMPONENT_DATA = new InjectionToken('DbxInjectionComponentConfigData');
 /**
- * Creates an RxJS operator that switches between injection component configs, falling back to a
- * default config when the source emits `null`, `undefined`, or `true`.
- *
- * If the `defaultConfig` resolves to a class (function), it is automatically wrapped into a
- * `{ componentClass }` config object.
+ * Compares two {@link DbxInjectionComponentConfig} values for structural equality, safely handling nullish values.
  *
- * This is useful for reactive streams where an upstream value may indicate "use the default component"
- * rather than providing an explicit configuration.
+ * Compares `componentClass`, `data`, `init`, and `injector` by reference. Does NOT compare
+ * `providers` or `ngModuleRef`, as provider arrays typically change on every list data update
+ * (e.g., with new `DBX_VALUE_LIST_VIEW_ITEM` values) without requiring component recreation.
  *
- * @param defaultConfig - A static value, getter, or component class to use as the fallback config.
- * @returns An RxJS operator compatible with `pipe()`.
+ * When both values are nullish, uses strict equality (`null === null` is `true`,
+ * `null === undefined` is `false`). The comparator is only invoked when both are non-nullish.
+ */
+const dbxInjectionComponentConfigIsEqual = safeEqualityComparatorFunction((a, b) => a.componentClass === b.componentClass && a.data === b.data && a.init === b.init && a.injector === b.injector);
+/**
+ * Merges multiple partial {@link DbxInjectionComponentConfig} objects into a single configuration.
  *
- * @see {@link DbxInjectionComponentConfig}
- * @typeParam T - The specific {@link DbxInjectionComponentConfig} subtype.
- * @typeParam X - The component type.
+ * Provider arrays are concatenated so that all providers from all configs are preserved.
+ * All other properties are merged with later values taking precedence.
  *
- * @example
- * ```typescript
- * config$.pipe(
- *   switchMapDbxInjectionComponentConfig(MyDefaultComponent)
- * ).subscribe(config => {
- *   // config is always a DbxInjectionComponentConfig or undefined
- * });
- * ```
+ * @param configs - The partial configs to merge. May contain `undefined`/`null` entries which are filtered out.
+ * @returns A single merged partial configuration.
  */
-function switchMapDbxInjectionComponentConfig(defaultConfig) {
-    const defaultAsGetter = asGetter(defaultConfig);
-    return switchMapObject({
-        defaultGetter: () => {
-            const value = defaultAsGetter();
-            // if value is a function, it is a component class
-            return typeof value === 'function' ? { componentClass: value } : value;
-        }
-    });
+function mergeDbxInjectionComponentConfigs(configs) {
+    const providers = mergeArrays(filterMaybeArrayValues(configs).map((x) => x.providers));
+    const result = mergeObjects(configs);
+    result.providers = providers;
+    return result;
 }
 
 /**
- * Creates a child injector with the given `type` as its sole provider and immediately
- * resolves an instance of that type.
- *
- * This is a convenience for one-off instantiation of an injectable class using a specific
- * parent injector, without needing to manually configure `Injector.create()`.
+ * Flattens and merges multiple provider sources into a single `StaticProvider[]` array.
  *
- * @param type - The injectable class to provide and resolve.
- * @param parent - The parent injector that supplies the type's dependencies.
- * @returns A new instance of `T`.
+ * Each argument can be a single `StaticProvider`, an array of providers, or `undefined`/`null`.
+ * All values are flattened into a single array with nullish entries removed.
  *
- * @typeParam T - The type to instantiate.
+ * @param providers - Any number of provider values or arrays to merge.
+ * @returns A flat array of all non-nullish static providers.
  *
  * @example
  * ```typescript
- * const service = newWithInjector(MyService, parentInjector);
- * ```
- */
-function newWithInjector(type, parent) {
-    const injector = Injector.create({ providers: [type], parent });
-    return injector.get(type);
+ * const providers = mergeStaticProviders(
+ *   { provide: TOKEN_A, useValue: 'a' },
+ *   undefined,
+ *   [{ provide: TOKEN_B, useValue: 'b' }]
+ * );
+ * // Result: [{ provide: TOKEN_A, useValue: 'a' }, { provide: TOKEN_B, useValue: 'b' }]
+ * ```
+ */
+function mergeStaticProviders(...providers) {
+    return flattenArrayOrValueArray(providers);
 }
-
 /**
- * Abstract NgRx `ComponentStore` extension that integrates a {@link LockSet} for coordinating
- * async operations and delays destruction until all locks are released.
+ * Builds an element injector from a {@link DbxInjectionComponentConfig},
+ * merging the config's providers and {@link DBX_INJECTION_COMPONENT_DATA} into a child injector.
  *
- * Subclasses call {@link setupLockSet} to register parent lock sets and named locks.
- * On destroy, the store waits for all locks to unlock before completing cleanup,
- * preventing premature teardown of in-flight operations.
+ * Returns the config's injector (or parent) unchanged if no providers or data are specified.
  *
- * @typeParam S - The shape of the component store's state object.
+ * @param params - The config and parent injector to build from.
+ * @returns A child {@link Injector} with the config's providers and data, or the parent injector if none are specified.
  *
  * @example
  * ```typescript
- * interface MyState { items: string[]; }
- *
- * @Injectable()
- * export class MyStore extends LockSetComponentStore<MyState> {
- *   constructor() {
- *     super({ items: [] });
- *   }
- * }
+ * const injector = createInjectorForInjectionComponentConfig({
+ *   config: { componentClass: MyComponent, data: { id: 1 }, providers: [myProvider] },
+ *   parentInjector: this._injector
+ * });
  * ```
+ * @__NO_SIDE_EFFECTS__
  */
-class LockSetComponentStore extends ComponentStore {
-    initialState;
-    lockSet = new LockSet();
-    lockSetDestroyDelayMs = 2000;
-    lockSetDestroyTimeoutMs;
-    // NOTE: Injection does not occur here, but we need @Injectable to compile properly for Angular usage
-    // eslint-disable-next-line @angular-eslint/prefer-inject
-    constructor(initialState) {
-        super(initialState);
-        this.initialState = initialState;
-    }
-    // MARK: State Changes
-    resetStore = this.updater(() => ({ ...this.initialState }));
-    // MARK: Locks
-    setupLockSet({ parent, locks }) {
-        if (parent) {
-            this.setParentLockSet(parent);
-        }
-        if (locks) {
-            for (const key in locks) {
-                if (locks[key]) {
-                    this.addLock(key, locks[key]);
-                }
-            }
-        }
-    }
-    setParentLockSet(obs) {
-        this.lockSet.setParentLockSet(asObservable(obs).pipe(map((x) => x?.lockSet)));
-    }
-    addLock(key, obs) {
-        this.lockSet.addLock(key, obs);
-    }
-    // MARK: Cleanup
-    ngOnDestroy() {
-        // Wait for any actions to complete before destroying.
-        this.lockSet.destroyOnNextUnlock({
-            fn: () => {
-                this._destroyNow();
-            },
-            timeout: this.lockSetDestroyTimeoutMs
-        }, this.lockSetDestroyDelayMs);
+function createInjectorForInjectionComponentConfig(params) {
+    const { config, parentInjector } = params;
+    const { injector: inputInjector, providers, data } = config;
+    const parent = inputInjector ?? parentInjector;
+    let result;
+    if (!providers && data == null) {
+        result = parent;
     }
-    /**
-     * Immediately completes cleanup by destroying the lock set.
-     * Called after all locks are released during the deferred destruction process.
-     */
-    _destroyNow() {
-        this.lockSet.destroy();
+    else {
+        result = Injector.create({
+            parent,
+            providers: mergeStaticProviders({ provide: DBX_INJECTION_COMPONENT_DATA, useValue: data }, providers)
+        });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: LockSetComponentStore, deps: [{ token: null, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: LockSetComponentStore });
+    return result;
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: LockSetComponentStore, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: [null]
-                }, {
-                    type: Optional
-                }] }] });
-
 /**
- * Default {@link SimpleStorageAccessorConverter} that uses `JSON.stringify`/`JSON.parse` for conversion.
+ * Runs the init callback from a {@link DbxInjectionComponentConfig} on the given component ref,
+ * executing within the component's injection context so that `inject()` is available inside the callback.
  *
- * @typeParam T - The type of value being converted.
+ * @param componentRef - The component reference whose instance will be passed to the init callback.
+ * @param config - The injection component config containing the optional init callback.
+ *
+ * @example
+ * ```typescript
+ * const ref = viewContainerRef.createComponent(config.componentClass, { injector });
+ * initInjectionComponent(ref, config);
+ * ```
  */
-class StringifySimpleStorageAccessorConverter {
-    stringifyValue(value) {
-        return JSON.stringify(value);
-    }
-    parseValue(data) {
-        return JSON.parse(data);
+function initInjectionComponent(componentRef, config) {
+    const { init } = config;
+    if (init) {
+        runInInjectionContext(componentRef.injector, () => init(componentRef.instance));
     }
 }
+
 /**
- * Composes a {@link StorageAccessor} and a {@link SimpleStorageAccessorConverter} into a single
- * {@link SimpleStorageAccessorDelegate} implementation.
+ * Core runtime engine for the dbx-injection system. Manages the lifecycle of dynamically injected
+ * components and templates within an Angular `ViewContainerRef`.
  *
- * @typeParam T - The type of value being stored.
+ * This class reactively listens to configuration and template observables. When a new
+ * {@link DbxInjectionComponentConfig} or {@link DbxInjectionTemplateConfig} is emitted, it tears
+ * down the previous content and creates the new component or template in the target view container.
+ *
+ * Component configs take precedence over template configs when both are provided.
+ *
+ * Typically used internally by {@link AbstractDbxInjectionDirective} and {@link DbxInjectionComponent}
+ * rather than consumed directly.
+ *
+ * @typeParam T - The type of the dynamically created component.
+ *
+ * @see {@link DbxInjectionComponentConfig}
+ * @see {@link DbxInjectionTemplateConfig}
+ * @see {@link AbstractDbxInjectionDirective}
  */
-class WrapperSimpleStorageAccessorDelegate {
-    _delegate;
-    _converter;
-    constructor(delegate, converter) {
-        this._delegate = delegate;
-        this._converter = converter;
+class DbxInjectionInstance {
+    _subscriptionObject = new SubscriptionObject();
+    _config = new BehaviorSubject(undefined);
+    _template = new BehaviorSubject(undefined);
+    _content = new BehaviorSubject(undefined);
+    _componentRef = new BehaviorSubject(undefined);
+    _injector;
+    config$ = this._config.pipe(maybeValueFromObservableOrValueGetter(), distinctUntilChanged(dbxInjectionComponentConfigIsEqual), shareReplay(1));
+    template$ = this._template.pipe(maybeValueFromObservableOrValueGetter(), distinctUntilChanged(), shareReplay(1));
+    content$ = this._content.pipe(filterMaybe(), distinctUntilChanged(), shareReplay(1));
+    get config() {
+        return this._config.value;
     }
-    get(key) {
-        return this._delegate.get(key);
+    set config(config) {
+        this._config.next(config);
     }
-    set(key, value) {
-        return this._delegate.set(key, value);
+    get template() {
+        return this._template.value;
     }
-    remove(key) {
-        return this._delegate.remove(key);
+    set template(template) {
+        this._template.next(template);
     }
-    clear() {
-        return this._delegate.clear();
+    get content() {
+        return this._content.value;
     }
-    all(prefix) {
-        return this._delegate.all(prefix);
+    set content(content) {
+        this._content.next(content);
     }
-    allKeys(prefix) {
-        return this._delegate.allKeys(prefix);
+    get componentRef() {
+        return this._componentRef.value;
     }
-    stringifyValue(value) {
-        return this._converter.stringifyValue(value);
+    set componentRef(componentRef) {
+        this._componentRef.next(componentRef);
     }
-    parseValue(data) {
-        return this._converter.parseValue(data);
+    constructor(injector) {
+        this._injector = injector;
+    }
+    init() {
+        // Wait until the first of either of the two inputs comes in as not defined, and then emit.
+        // We filter the first maybe here between the two items.
+        const configTemplateObs = combineLatest([this.config$, this.template$]).pipe(map(([config, template]) => {
+            return config || template ? { config, template } : undefined;
+        }), skipAllInitialMaybe());
+        this._subscriptionObject.subscription = combineLatest([configTemplateObs, this.content$]).subscribe(([inputConfig, content]) => {
+            const { config, template } = inputConfig ?? {};
+            this._reset(content);
+            if (config) {
+                this._initComponent(config, content);
+            }
+            else if (template) {
+                this._initTemplate(template, content);
+            }
+        });
+    }
+    destroy() {
+        this._subscriptionObject.destroy();
+        this._config.complete();
+        this._template.complete();
+        this._content.complete();
+        this._componentRef.complete();
+    }
+    _initComponent(config, content) {
+        content.clear();
+        const { componentClass, ngModuleRef } = config;
+        if (!componentClass) {
+            throw new Error('DbxInjectionInstance: componentClass was expected in the config but it was unavailable.');
+        }
+        const injector = createInjectorForInjectionComponentConfig({ config, parentInjector: this._injector });
+        const componentRef = content.createComponent(componentClass, { injector, ngModuleRef });
+        initInjectionComponent(componentRef, config);
+        this.componentRef = componentRef;
+    }
+    _initTemplate(config, content) {
+        content.clear();
+        const { templateRef, viewRef } = config;
+        if (templateRef) {
+            content.createEmbeddedView(templateRef);
+            // TODO: Figure out if these items need to be destroyed or not when this item is destroyed. If so, we need a reference to destroy.
+        }
+        else if (viewRef) {
+            content.insert(viewRef);
+        }
+    }
+    _reset(content) {
+        if (this.componentRef) {
+            content.clear();
+            this.componentRef = undefined;
+        }
     }
 }
+
 /**
- * Validates that a storage key prefix is non-empty and does not contain the prefix splitter character.
+ * Abstract base directive for dynamically injecting components or templates into a view.
  *
- * @param prefix - The prefix string to validate.
- * @param prefixSplitter - The splitter string that separates the prefix from the key.
- * @throws {Error} If the prefix is invalid or the splitter is empty.
+ * Manages a {@link DbxInjectionInstance} lifecycle, initializing it on `ngOnInit` and
+ * destroying it on `ngOnDestroy`. Subclasses are responsible for wiring their inputs
+ * (config, template, content) to the corresponding setter methods.
+ *
+ * @typeParam T - The type of the dynamically created component.
+ *
+ * @see {@link DbxInjectionComponent} - The concrete standalone component implementation.
+ * @see {@link DbxInjectionInstance}
  */
-function assertValidStorageKeyPrefix(prefix, prefixSplitter) {
-    if (!prefixSplitter) {
-        throw new Error('Invalid storage key prefix splitter. Must be defined and not empty.'); // TODO(FUTURE): Consider changing to a concrete error type
+class AbstractDbxInjectionDirective {
+    _instance = new DbxInjectionInstance(inject(Injector));
+    ngOnInit() {
+        this._instance.init();
     }
-    if (!isValidStorageKeyPrefix(prefix, prefixSplitter)) {
-        throw new Error('Invalid storage key prefix.');
+    ngOnDestroy() {
+        this._instance.destroy();
     }
+    /**
+     * Sets the component injection configuration on the underlying {@link DbxInjectionInstance}.
+     *
+     * @param config - The component config, observable, or getter to use.
+     */
+    setConfig(config) {
+        this._instance.config = config;
+    }
+    /**
+     * Sets the template injection configuration on the underlying {@link DbxInjectionInstance}.
+     *
+     * @param template - The template config, observable, or getter to use.
+     */
+    setTemplate(template) {
+        this._instance.template = template;
+    }
+    /**
+     * Sets the target `ViewContainerRef` where dynamic content will be inserted.
+     *
+     * @param content - The view container reference for content projection.
+     */
+    setContent(content) {
+        this._instance.content = content;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: AbstractDbxInjectionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.4", type: AbstractDbxInjectionDirective, isStandalone: true, ngImport: i0 });
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: AbstractDbxInjectionDirective, decorators: [{
+            type: Directive
+        }] });
+
 /**
- * Checks whether a storage key prefix is valid (non-empty and does not contain the splitter).
+ * Standalone component for dynamically injecting a component or template into the DOM.
  *
- * @param prefix - The prefix string to validate.
- * @param prefixSpltter - The splitter string that separates the prefix from the key.
- * @returns `true` if the prefix is valid.
+ * Accepts a {@link DbxInjectionComponentConfig} (to create a component) or a
+ * {@link DbxInjectionTemplateConfig} (to embed a template/view). When the config changes,
+ * the previous content is destroyed and the new content is created in its place.
+ *
+ * Can be used as an element (`<dbx-injection>`) or as an attribute directive
+ * (`[dbxInjection]` / `[dbx-injection]`).
+ *
+ * @typeParam T - The type of the dynamically created component.
+ *
+ * @example
+ * ```html
+ * <!-- Element usage with a component config -->
+ * <dbx-injection [config]="myComponentConfig"></dbx-injection>
+ *
+ * <!-- Element usage with a template config -->
+ * <dbx-injection [template]="myTemplateConfig"></dbx-injection>
+ *
+ * <!-- Attribute usage -->
+ * <div dbxInjection [config]="myComponentConfig"></div>
+ * ```
+ *
+ * @see {@link DbxInjectionComponentConfig}
+ * @see {@link DbxInjectionTemplateConfig}
+ * @see {@link AbstractDbxInjectionDirective}
  */
-function isValidStorageKeyPrefix(prefix, prefixSpltter) {
-    return Boolean(prefix?.indexOf(prefixSpltter) === -1);
+class DbxInjectionComponent extends AbstractDbxInjectionDirective {
+    /**
+     * Reference to the internal view container where dynamic content is projected.
+     */
+    content = viewChild('content', { ...(ngDevMode ? { debugName: "content" } : /* istanbul ignore next */ {}), read: ViewContainerRef });
+    /**
+     * The component injection configuration. Accepts an observable, getter, or static value.
+     */
+    config = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "config" }] : /* istanbul ignore next */ []));
+    /**
+     * The template injection configuration. Accepts an observable, getter, or static value.
+     * Only used when `config` is not provided.
+     */
+    template = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "template" }] : /* istanbul ignore next */ []));
+    // allow signal writes for each as during their initialization they may write to a signal in some cases when initializing
+    _contentEffect = effect(() => this.setContent(this.content()), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_contentEffect" }] : /* istanbul ignore next */ []));
+    _configEffect = effect(() => this.setConfig(this.config()), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_configEffect" }] : /* istanbul ignore next */ []));
+    _templateEffect = effect(() => this.setTemplate(this.template()), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_templateEffect" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxInjectionComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "22.1.4", type: DbxInjectionComponent, isStandalone: true, selector: "dbx-injection, [dbxInjection], [dbx-injection]", inputs: { config: { classPropertyName: "config", publicName: "config", isSignal: true, isRequired: false, transformFunction: null }, template: { classPropertyName: "template", publicName: "template", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "content", first: true, predicate: ["content"], descendants: true, read: ViewContainerRef, isSignal: true }], usesInheritance: true, ngImport: i0, template: `
+    <ng-template #content></ng-template>
+  `, isInline: true });
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxInjectionComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-injection, [dbxInjection], [dbx-injection]',
+                    template: `
+    <ng-template #content></ng-template>
+  `,
+                    imports: []
+                }]
+        }], propDecorators: { content: [{ type: i0.ViewChild, args: ['content', { ...{ read: ViewContainerRef }, isSignal: true }] }], config: [{ type: i0.Input, args: [{ isSignal: true, alias: "config", required: false }] }], template: [{ type: i0.Input, args: [{ isSignal: true, alias: "template", required: false }] }] } });
+
 /**
- * Full-featured {@link StorageAccessor} that adds key namespacing, JSON serialization,
- * and optional time-based expiration on top of a raw string storage backend.
+ * Renders a list of dynamically injected components from an array of {@link DbxInjectionArrayEntry} items.
  *
- * Values are stored as JSON with metadata (timestamp) and automatically checked
- * for expiration on read.
+ * Each entry is tracked by its `key` property for efficient change detection, and rendered
+ * using a nested {@link DbxInjectionComponent}.
  *
- * @typeParam T - The type of values stored.
+ * @example
+ * ```html
+ * <dbx-injection-array [entries]="myEntries" />
+ * ```
  *
- * @throws {DataDoesNotExistError} When reading a key that does not exist.
- * @throws {DataIsExpiredError} When reading a key whose stored data has expired.
+ * @example
+ * ```typescript
+ * // In the host component:
+ * myEntries: DbxInjectionArrayEntry[] = [
+ *   { key: 'chart', injectionConfig: { componentClass: ChartComponent } },
+ *   { key: 'table', injectionConfig: { componentClass: TableComponent } }
+ * ];
+ * ```
+ *
+ * @see {@link DbxInjectionArrayEntry}
+ * @see {@link DbxInjectionComponent}
+ */
+class DbxInjectionArrayComponent {
+    /**
+     * The array of keyed injection entries to render. Each entry produces a `<dbx-injection>` component.
+     */
+    entries = input(undefined, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "entries" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxInjectionArrayComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.1.4", type: DbxInjectionArrayComponent, isStandalone: true, selector: "dbx-injection-array", inputs: { entries: { classPropertyName: "entries", publicName: "entries", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+    @for (entry of entries(); track entry.key) {
+      <dbx-injection [config]="entry.injectionConfig"></dbx-injection>
+    }
+  `, isInline: true, dependencies: [{ kind: "component", type: DbxInjectionComponent, selector: "dbx-injection, [dbxInjection], [dbx-injection]", inputs: ["config", "template"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxInjectionArrayComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-injection-array',
+                    template: `
+    @for (entry of entries(); track entry.key) {
+      <dbx-injection [config]="entry.injectionConfig"></dbx-injection>
+    }
+  `,
+                    imports: [DbxInjectionComponent]
+                }]
+        }], propDecorators: { entries: [{ type: i0.Input, args: [{ isSignal: true, alias: "entries", required: false }] }] } });
+
+/**
+ * Abstract service for temporarily replacing a view's content with a dynamically injected component,
+ * then restoring the original content when done.
+ *
+ * Unlike `*ngIf` or `*ngSwitch`, the original child content is **hidden** rather than destroyed,
+ * preserving component state. Once the injected context's promise resolves (or is reset), the
+ * original content is re-displayed.
+ *
+ * This is useful for overlay-like workflows such as inline editors, confirmation dialogs,
+ * or multi-step flows where destroying and recreating the underlying view would lose state.
+ *
+ * @see {@link DbxInjectionContextConfig}
+ * @see {@link DbxInjectionContextDirective} - The concrete structural directive implementation.
+ */
+class DbxInjectionContext {
+}
+/**
+ * Creates Angular providers that register a concrete {@link DbxInjectionContext} implementation
+ * under the abstract `DbxInjectionContext` token via `useExisting`.
+ *
+ * This enables dependency injection consumers to request `DbxInjectionContext` and receive
+ * the specific directive or service implementation.
+ *
+ * @param type - The concrete class to register as the existing provider.
+ * @returns Array of Angular providers.
+ *
+ * @typeParam T - The concrete type that extends {@link DbxInjectionContext}.
+ */
+function provideDbxInjectionContext(type) {
+    return [
+        {
+            provide: DbxInjectionContext,
+            useExisting: type
+        }
+    ];
+}
+
+/**
+ * Structural directive that implements {@link DbxInjectionContext}, allowing its host content
+ * to be temporarily replaced with a dynamically injected component and then restored.
+ *
+ * Unlike `*ngIf` or `*ngSwitch`, the original child content is **detached** (hidden) rather than
+ * destroyed, so component state is preserved while the injected context is active. When the
+ * context's promise resolves or {@link resetContext} is called, the original view is re-attached.
+ *
+ * The directive also accepts an optional `[dbxInjectionContext]` input to set a static component
+ * config directly, which replaces the default content until cleared.
+ *
+ * @typeParam O - The output type produced by {@link showContext}.
+ *
+ * @example
+ * ```html
+ * <!-- Wrap content that should be temporarily replaceable -->
+ * <div *dbxInjectionContext>
+ *   <p>Original content preserved while context is active</p>
+ * </div>
+ * ```
  *
  * @example
  * ```typescript
- * const accessor = factory.createStorageAccessor<UserSettings>({
- *   prefix: 'user_prefs',
- *   expiresIn: 3600000,
+ * // Programmatically show a temporary editor overlay:
+ * const result = await injectionContext.showContext({
+ *   config: { componentClass: InlineEditorComponent },
+ *   use: (editor) => editor.waitForSave()
  * });
- *
- * accessor.set('theme', { dark: true }).subscribe();
- * accessor.get('theme').subscribe(settings => console.log(settings));
  * ```
+ *
+ * @see {@link DbxInjectionContext}
+ * @see {@link DbxInjectionContextConfig}
  */
-class SimpleStorageAccessor {
-    static PREFIX_SPLITTER = '::';
-    _delegate;
-    _config;
-    constructor(delegate, config) {
-        const prefix = config.prefix;
-        const prefixSplitter = config.prefixSplitter ?? SimpleStorageAccessor.PREFIX_SPLITTER;
-        assertValidStorageKeyPrefix(prefix, prefixSplitter);
-        const fullPrefix = `${prefix}${prefixSplitter}`;
-        this._delegate = delegate;
-        this._config = {
-            ...config,
-            prefixSplitter,
-            fullPrefix
+class DbxInjectionContextDirective {
+    _injector = inject(Injector);
+    _templateRef = inject((TemplateRef));
+    _viewContainer = inject(ViewContainerRef);
+    _instance = new DbxInjectionInstance(this._injector);
+    _currentPromise;
+    _embeddedView;
+    _isDetached = false;
+    /**
+     * Optional static component config input. When set, the directive replaces its content
+     * with the specified component. When cleared (`undefined`), the original content is restored.
+     */
+    config = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "config" }] : /* istanbul ignore next */ []));
+    _configEffect = effect(() => {
+        this.setConfig(this.config());
+        // NOTE: we have/call setConfig() because the effect() may not respond to all value changes,
+        // especially when setConfig() ends up being called twice quickly in quick succession.
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_configEffect" }] : /* istanbul ignore next */ []));
+    ngOnInit() {
+        this._instance.content = this._viewContainer;
+        this._instance.init();
+        this._embeddedView = this._viewContainer.createEmbeddedView(this._templateRef);
+        // detach the embedded view
+        this._viewContainer.detach();
+        // reattach it through the template configuration.
+        // the template configuration acts as the default.
+        this._instance.template = {
+            viewRef: this._embeddedView
         };
     }
-    get delegate() {
-        return this._delegate;
-    }
-    get config() {
-        return this._config;
+    ngOnDestroy() {
+        this._instance.destroy();
+        this._embeddedView?.destroy(); // destroy our embedded view too if it is set.
     }
-    // MARK: LimitedStorageAccessor
-    get(inputKey) {
-        const storeKey = this.makeStorageKey(inputKey);
-        return this._delegate.get(storeKey).pipe(map((storedData) => {
-            let result;
-            if (storedData) {
-                const readStoredData = this.readStoredData(storedData);
-                if (readStoredData.expired) {
-                    throw new DataIsExpiredError(readStoredData);
-                }
-                else {
-                    result = readStoredData.convertedData;
-                }
+    /**
+     * {@inheritDoc DbxInjectionContext.showContext}
+     *
+     * @param config - The injection context configuration describing the component and its usage.
+     * @returns Resolves to the output of the injected component's usage.
+     */
+    async showContext(config) {
+        // clear the current context before showing something new.
+        this.resetContext();
+        let promiseRef;
+        let result;
+        let error;
+        // wait for the promise to resolve and use to finish using that instance.
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-misused-promises
+            promiseRef = promiseReference(async (resolve, reject) => {
+                const injectionConfig = {
+                    ...config.config,
+                    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+                    init: async (instance) => {
+                        // init if available in the base config.
+                        if (config.config.init) {
+                            config.config.init(instance);
+                        }
+                        try {
+                            const result = (await config.use(instance));
+                            resolve(result);
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                    }
+                };
+                this.setConfig(injectionConfig);
+            });
+            this._currentPromise = promiseRef;
+            // await the promise
+            result = await promiseRef.promise;
+        }
+        catch (e) {
+            error = e;
+        }
+        // if we're still using the same promiseRef
+        if (promiseRef && promiseRef === this._currentPromise) {
+            // clear the config to reshow the view
+            this.setConfig(undefined);
+            // clear the current promise
+            this._currentPromise = undefined;
+        }
+        if (error != null) {
+            if (error instanceof Error) {
+                throw error;
             }
-            else {
-                throw new DataDoesNotExistError();
+            let message;
+            if (error == null) {
+                message = String(error);
             }
-            return result;
-        }));
-    }
-    set(inputKey, inputValue) {
-        const storeKey = this.makeStorageKey(inputKey);
-        const storeData = this.buildStoredData(inputValue);
-        const data = JSON.stringify(storeData);
-        return this._delegate.set(storeKey, data);
-    }
-    remove(key) {
-        const storeKey = this.makeStorageKey(key);
-        return this._delegate.remove(storeKey);
-    }
-    all() {
-        return this._delegate.all(this._config.fullPrefix).pipe(map((allStoredData) => {
-            return allStoredData
-                .map((storedData) => {
-                const readStoredData = this.readStoredData(storedData);
-                return readStoredData.expired ? null : readStoredData.convertedData;
-            })
-                .filter(hasNonNullValue);
-        }));
-    }
-    allKeys() {
-        return this._delegate.allKeys(this._config.fullPrefix).pipe(map((keys) => keys.map((x) => this.decodeStorageKey(x))));
-    }
-    clear() {
-        return this._delegate.clear();
-    }
-    // MARK: Stored Values
-    readStoredData(storedDataString) {
-        const storedData = JSON.parse(storedDataString);
-        const expired = this.isExpiredStoredData(storedData);
-        const convertedData = this._delegate.parseValue(storedData.data);
-        return {
-            ...storedData,
-            expired,
-            convertedData
-        };
-    }
-    buildStoredData(value) {
-        return {
-            storedAt: unixDateTimeSecondsNumberForNow(),
-            data: this.stringifyValue(value)
-        };
-    }
-    isExpiredStoredData(storeData) {
-        const expiresIn = this._config.expiresIn;
-        let result;
-        if (expiresIn) {
-            if (storeData.storedAt) {
-                result = isThrottled(expiresIn, storeData.storedAt);
+            else if (typeof error === 'object') {
+                message = JSON.stringify(error);
             }
             else {
-                result = true;
+                message = String(error);
             }
-        }
-        else {
-            result = false;
+            throw new Error(message);
         }
         return result;
     }
-    // MARK: Internal
-    makeStorageKey(key) {
-        return `${this._config.prefix}${this._config.prefixSplitter}${String(key)}`;
-    }
-    isKeyOfAccessor(storageKey) {
-        return storageKey.startsWith(this._config.fullPrefix);
-    }
-    decodeStorageKey(storageKey) {
-        const split = splitJoinRemainder(storageKey, this._config.prefixSplitter, 2);
-        return split[1];
+    /**
+     * {@inheritDoc DbxInjectionContext.resetContext}
+     *
+     * @returns `true` if an active context was cleared, `false` otherwise.
+     */
+    resetContext() {
+        let clearedValue = false;
+        if (this._currentPromise) {
+            const promise = this._currentPromise;
+            // clear the current promise too
+            this._currentPromise = undefined;
+            // clear the config.
+            this.setConfig(undefined);
+            // send a rejection signal to bail out.
+            promise.reject(new Error('dbxInjectionContext bailout'));
+            clearedValue = true;
+        }
+        return clearedValue;
     }
-    stringifyValue(value) {
-        return this._delegate.stringifyValue(value);
+    /**
+     * Sets or clears the active component configuration.
+     *
+     * When a config is provided, the original embedded view is detached and the component is injected.
+     * When `undefined` is provided, the injected component is removed and the original view is re-attached.
+     *
+     * @param config - The component config to display, or `undefined` to restore the original content.
+     */
+    setConfig(config) {
+        let reattach = false;
+        if (config) {
+            if (!this._isDetached) {
+                // detach the original view before setting config.
+                this._viewContainer.detach();
+                this._isDetached = true;
+            }
+        }
+        else if (this._isDetached) {
+            reattach = true;
+        }
+        this._instance.config = config;
+        if (reattach) {
+            this._viewContainer.insert(this._embeddedView);
+            this._isDetached = false;
+        }
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxInjectionContextDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.4", type: DbxInjectionContextDirective, isStandalone: true, selector: "[dbxInjectionContext]", inputs: { config: { classPropertyName: "config", publicName: "config", isSignal: true, isRequired: false, transformFunction: null } }, providers: provideDbxInjectionContext(DbxInjectionContextDirective), ngImport: i0 });
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: DbxInjectionContextDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxInjectionContext]',
+                    providers: provideDbxInjectionContext(DbxInjectionContextDirective)
+                }]
+        }], propDecorators: { config: [{ type: i0.Input, args: [{ isSignal: true, alias: "config", required: false }] }] } });
 
 /**
- * {@link StorageAccessor} implementation that wraps a {@link FullStorageObject} and stores raw strings.
+ * Abstract directive that delegates {@link DbxInjectionContext} operations to a host-level
+ * `DbxInjectionContext` obtained via Angular's dependency injection (`{ host: true }`).
  *
- * Each operation completes synchronously within an observable wrapper.
+ * This is useful for creating specialized injection context subtypes that can be injected
+ * by their own token while still forwarding the actual show/reset behavior to a parent
+ * {@link DbxInjectionContextDirective}.
  *
  * @example
  * ```typescript
- * const accessor = new StringStorageAccessor(localStorage);
- * accessor.set('key', 'value').subscribe();
- * accessor.get('key').subscribe(value => console.log(value)); // 'value'
+ * @Directive({ providers: [{ provide: MySpecialContext, useExisting: MyForwardDirective }] })
+ * class MyForwardDirective extends AbstractForwardDbxInjectionContextDirective {}
  * ```
+ *
+ * @see {@link DbxInjectionContext}
+ * @see {@link DbxInjectionContextDirective}
  */
-class StringStorageAccessor {
-    _storage;
-    constructor(storage) {
-        this._storage = storage;
-    }
-    get(key) {
-        return new Observable((x) => {
-            const value = this._storage.getItem(key);
-            x.next(value);
-            x.complete();
-        });
-    }
-    set(key, value) {
-        return new Observable((x) => {
-            this._storage.setItem(key, value);
-            x.next();
-            x.complete();
-        });
-    }
-    remove(key) {
-        return new Observable((x) => {
-            this._storage.removeItem(key);
-            x.next();
-            x.complete();
-        });
-    }
-    clear() {
-        const removed = this._storage.removeAll();
-        return new Observable((x) => {
-            x.next(removed);
-            x.complete();
-        });
-    }
-    all() {
-        return this.allKeys().pipe(map((x) => filterMaybeArrayValues(x.map((y) => this._storage.getItem(y)))), shareReplay(1));
+class AbstractForwardDbxInjectionContextDirective {
+    /**
+     * The host-level {@link DbxInjectionContext} that all operations are forwarded to.
+     */
+    dbxInjectionContext = inject(DbxInjectionContext, { host: true });
+    // MARK: DbxInjectionContext
+    /**
+     * {@inheritDoc DbxInjectionContext.showContext}
+     *
+     * @param config - The injection context configuration to forward to the host context.
+     * @returns Resolves to the output of the injected component's usage.
+     */
+    showContext(config) {
+        return this.dbxInjectionContext.showContext(config);
     }
-    allKeys() {
-        return new Observable((x) => {
-            const result = StorageObjectUtility.allKeysFromStorageObject(this._storage);
-            x.next(result);
-            x.complete();
-        });
+    /**
+     * {@inheritDoc DbxInjectionContext.resetContext}
+     *
+     * @returns `true` if an active context was cleared, `false` otherwise.
+     */
+    resetContext() {
+        return this.dbxInjectionContext.resetContext();
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: AbstractForwardDbxInjectionContextDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.4", type: AbstractForwardDbxInjectionContextDirective, isStandalone: true, ngImport: i0 });
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: AbstractForwardDbxInjectionContextDirective, decorators: [{
+            type: Directive
+        }] });
 
 /**
- * DI token for the application's default {@link FullStorageObject} instance.
+ * Creates an RxJS operator that switches between injection component configs, falling back to a
+ * default config when the source emits `null`, `undefined`, or `true`.
  *
- * Provided by {@link provideDbxStorage}.
+ * If the `defaultConfig` resolves to a class (function), it is automatically wrapped into a
+ * `{ componentClass }` config object.
+ *
+ * This is useful for reactive streams where an upstream value may indicate "use the default component"
+ * rather than providing an explicit configuration.
+ *
+ * @param defaultConfig - A static value, getter, or component class to use as the fallback config.
+ * @returns An RxJS operator compatible with `pipe()`.
+ *
+ * @see {@link DbxInjectionComponentConfig}
+ * @typeParam T - The specific {@link DbxInjectionComponentConfig} subtype.
+ * @typeParam X - The component type.
+ *
+ * @example
+ * ```typescript
+ * config$.pipe(
+ *   switchMapDbxInjectionComponentConfig(MyDefaultComponent)
+ * ).subscribe(config => {
+ *   // config is always a DbxInjectionComponentConfig or undefined
+ * });
+ * ```
  */
-const DEFAULT_STORAGE_OBJECT_TOKEN = new InjectionToken('DBX_CORE_DEFAULT_STORAGE_OBJECT');
+function switchMapDbxInjectionComponentConfig(defaultConfig) {
+    const defaultAsGetter = asGetter(defaultConfig);
+    return switchMapObject({
+        defaultGetter: () => {
+            const value = defaultAsGetter();
+            // if value is a function, it is a component class
+            return typeof value === 'function' ? { componentClass: value } : value;
+        }
+    });
+}
+
 /**
- * DI token for the application's default {@link SimpleStorageAccessorFactory} instance.
+ * Creates a child injector with the given `type` as its sole provider and immediately
+ * resolves an instance of that type.
  *
- * Provided by {@link provideDbxStorage}.
+ * This is a convenience for one-off instantiation of an injectable class using a specific
+ * parent injector, without needing to manually configure `Injector.create()`.
+ *
+ * @param type - The injectable class to provide and resolve.
+ * @param parent - The parent injector that supplies the type's dependencies.
+ * @returns A new instance of `T`.
+ *
+ * @typeParam T - The type to instantiate.
+ *
+ * @example
+ * ```typescript
+ * const service = newWithInjector(MyService, parentInjector);
+ * ```
  */
-const DEFAULT_STORAGE_ACCESSOR_FACTORY_TOKEN = new InjectionToken('DBX_CORE_DEFAULT_STORAGE_ACCESSOR_FACTORY');
+function newWithInjector(type, parent) {
+    const injector = Injector.create({ providers: [type], parent });
+    return injector.get(type);
+}
 
 /**
- * Injectable factory for creating namespaced {@link SimpleStorageAccessor} instances
- * backed by the application's default storage object.
+ * Abstract NgRx `ComponentStore` extension that integrates a {@link LockSet} for coordinating
+ * async operations and delays destruction until all locks are released.
+ *
+ * Subclasses call {@link setupLockSet} to register parent lock sets and named locks.
+ * On destroy, the store waits for all locks to unlock before completing cleanup,
+ * preventing premature teardown of in-flight operations.
+ *
+ * @typeParam S - The shape of the component store's state object.
  *
  * @example
  * ```typescript
- * @Injectable()
- * export class UserPrefsService {
- *   private readonly storage = inject(SimpleStorageAccessorFactory)
- *     .createStorageAccessor<UserPrefs>({ prefix: 'user_prefs' });
+ * interface MyState { items: string[]; }
  *
- *   save(prefs: UserPrefs) { return this.storage.set('current', prefs); }
- *   load() { return this.storage.get('current'); }
+ * @Injectable()
+ * export class MyStore extends LockSetComponentStore<MyState> {
+ *   constructor() {
+ *     super({ items: [] });
+ *   }
  * }
  * ```
  */
-class SimpleStorageAccessorFactory {
-    storageObject = inject(DEFAULT_STORAGE_OBJECT_TOKEN);
-    createStorageAccessor(config) {
-        const storage = config.storage ?? new StringStorageAccessor(this.storageObject);
-        const converter = config.converter ?? new StringifySimpleStorageAccessorConverter();
-        const delegate = new WrapperSimpleStorageAccessorDelegate(storage, converter);
-        const accessorConfig = {
-            prefix: config.prefix
-        };
-        return new SimpleStorageAccessor(delegate, accessorConfig);
+class LockSetComponentStore extends ComponentStore {
+    initialState;
+    lockSet = new LockSet();
+    lockSetDestroyDelayMs = 2000;
+    lockSetDestroyTimeoutMs;
+    // NOTE: Injection does not occur here, but we need @Injectable to compile properly for Angular usage
+    // eslint-disable-next-line @angular-eslint/prefer-inject
+    constructor(initialState) {
+        super(initialState);
+        this.initialState = initialState;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: SimpleStorageAccessorFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: SimpleStorageAccessorFactory });
+    // MARK: State Changes
+    resetStore = this.updater(() => ({ ...this.initialState }));
+    // MARK: Locks
+    setupLockSet({ parent, locks }) {
+        if (parent) {
+            this.setParentLockSet(parent);
+        }
+        if (locks) {
+            for (const key in locks) {
+                if (locks[key]) {
+                    this.addLock(key, locks[key]);
+                }
+            }
+        }
+    }
+    setParentLockSet(obs) {
+        this.lockSet.setParentLockSet(asObservable(obs).pipe(map((x) => x?.lockSet)));
+    }
+    addLock(key, obs) {
+        this.lockSet.addLock(key, obs);
+    }
+    // MARK: Cleanup
+    ngOnDestroy() {
+        // Wait for any actions to complete before destroying.
+        this.lockSet.destroyOnNextUnlock({
+            fn: () => {
+                this._destroyNow();
+            },
+            timeout: this.lockSetDestroyTimeoutMs
+        }, this.lockSetDestroyDelayMs);
+    }
+    /**
+     * Immediately completes cleanup by destroying the lock set.
+     * Called after all locks are released during the deferred destruction process.
+     */
+    _destroyNow() {
+        this.lockSet.destroy();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: LockSetComponentStore, deps: [{ token: null, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: LockSetComponentStore });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: SimpleStorageAccessorFactory, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: LockSetComponentStore, decorators: [{
             type: Injectable
-        }] });
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [null]
+                }, {
+                    type: Optional
+                }] }] });
 
 /**
  * Abstract storage accessor providing key-value get/set/remove operations and a clear-all method.
@@ -9652,5 +9866,5 @@ function hasNonTrivialChildNodes(element) {
  * Generated bundle index. Do not edit.
  */
 
-export { ACTION_CONTEXT_STORE_LOCKSET_DESTROY_DELAY_TIME, APP_ACTION_DISABLED_DIRECTIVE_KEY, APP_ACTION_DISABLED_ON_SUCCESS_DIRECTIVE_KEY, APP_ACTION_ENFORCE_MODIFIED_DIRECTIVE_KEY, AbstractDbxActionHandlerDirective, AbstractDbxActionValueGetterDirective, AbstractDbxAnchorDirective, AbstractDbxButtonDirective, AbstractDbxFilterMapInstanceDirective, AbstractDbxFilterMapSourceDirective, AbstractDbxInjectionDirective, AbstractFilterSourceConnectorDirective, AbstractFilterSourceDirective, AbstractForwardDbxInjectionContextDirective, AbstractIfDirective, AbstractTransitionDirective, AbstractTransitionWatcherDirective, ActionContextStore, ActionContextStoreSource, ActionContextStoreSourceMap, AsObservablePipe, CutTextPipe, DBX_ACTION_BUTTON_ECHO_CONFIG, DBX_ACTION_HANDLER_LOCK_KEY, DBX_APP_APP_CONTEXT_STATE, DBX_APP_AUTH_ROUTER_EFFECTS_TOKEN, DBX_ASSET_LOADER_CONFIG_TOKEN, DBX_AUTH_APP_CONTEXT_STATE, DBX_INIT_APP_CONTEXT_STATE, DBX_INJECTION_COMPONENT_DATA, DBX_KNOWN_APP_CONTEXT_STATES, DBX_OAUTH_APP_CONTEXT_STATE, DBX_ONBOARD_APP_CONTEXT_STATE, DBX_PUBLIC_APP_CONTEXT_STATE, DEFAULT_ACTION_DISABLED_KEY, DEFAULT_ACTION_MAP_WORKING_DISABLED_KEY, DEFAULT_DBX_ACTION_BUTTON_ECHO_CONFIG, DEFAULT_DBX_ACTION_BUTTON_ERROR_ECHO, DEFAULT_DBX_ACTION_BUTTON_SUCCESS_ECHO, DEFAULT_DBX_BUTTON_ECHO_DURATION, DEFAULT_DBX_ROUTE_MODEL_ID_PARAM_ID_PARAM_KEY, DEFAULT_DBX_ROUTE_MODEL_ID_PARAM_KEY_PARAM_KEY, DEFAULT_DBX_ROUTE_MODEL_ID_PARAM_USE_PARAM_VALUE, DEFAULT_FILTER_SOURCE_DIRECTIVE_FILTER_TOKEN, DEFAULT_LOCAL_ASSET_BASE_URL, DEFAULT_REDIRECT_FOR_IDENTIFIER_PARAM_KEY, DEFAULT_REDIRECT_FOR_IDENTIFIER_PARAM_VALUE, DEFAULT_REDIRECT_FOR_USER_IDENTIFIER_PARAM_KEY, DEFAULT_REDIRECT_FOR_USER_IDENTIFIER_PARAM_VALUE, DEFAULT_STORAGE_ACCESSOR_FACTORY_TOKEN, DEFAULT_STORAGE_OBJECT_TOKEN, DateDayRangePipe, DateDayTimeRangePipe, DateDistancePipe, DateFormatDistancePipe, DateFormatFromToPipe, DateRangeDistancePipe, DateTimeRangeOnlyDistancePipe, DateTimeRangeOnlyPipe, DateTimeRangePipe, DbxActionAutoModifyDirective, DbxActionAutoTriggerDirective, DbxActionButtonDirective, DbxActionButtonTriggerDirective, DbxActionContextBaseSource, DbxActionContextLoggerDirective, DbxActionContextMachine, DbxActionContextMachineAsService, DbxActionContextMapDirective, DbxActionContextStoreSourceInstance, DbxActionDirective, DbxActionDisabledDirective, DbxActionDisabledOnSuccessDirective, DbxActionEnforceModifiedDirective, DbxActionErrorHandlerDirective, DbxActionFromMapDirective, DbxActionHandlerDirective, DbxActionHandlerInstance, DbxActionHandlerValueDirective, DbxActionHasSuccessDirective, DbxActionIdleDirective, DbxActionIsModifiedDirective, DbxActionIsWorkingDirective, DbxActionMapSourceDirective, DbxActionMapWorkingDisableDirective, DbxActionPreSuccessDirective, DbxActionSourceDirective, DbxActionState, DbxActionSuccessHandlerDirective, DbxActionTriggeredDirective, DbxActionValueDirective, DbxActionValueGetterInstance, DbxActionValueStreamDirective, DbxActionValueTriggerDirective, DbxActionWorkInstanceDelegate, DbxActionWorkable, DbxAnchor, DbxAngularRouterService, DbxAppAuthRouterEffects, DbxAppAuthRouterService, DbxAppAuthRoutes, DbxAppAuthStateService, DbxAppContextService, DbxAppContextStateDirective, DbxAppEnvironment, DbxAppEnvironmentService, DbxAuthHasAnyRoleDirective, DbxAuthHasRolesDirective, DbxAuthImpersonationDelegate, DbxAuthImpersonationQuerySyncDirective, DbxAuthImpersonationService, DbxAuthImpersonationTriggerDirective, DbxAuthNotAnyRoleDirective, DbxAuthService, DbxButton, DbxButtonDirective, DbxButtonSegueDirective, DbxCoreActionModule, DbxCoreAngularRouterSegueModule, DbxCoreAssetLoader, DbxCoreButtonModule, DbxCoreFilterModule, DbxFilterConnectSourceDirective, DbxFilterMapDirective, DbxFilterMapSourceConnectorDirective, DbxFilterMapSourceDirective, DbxFilterSourceConnectorDirective, DbxFilterSourceDirective, DbxInjectionArrayComponent, DbxInjectionComponent, DbxInjectionContext, DbxInjectionContextDirective, DbxInjectionInstance, DbxLoadingButtonDirective, DbxRouteModelIdDirective, DbxRouteModelIdDirectiveDelegate, DbxRouteModelIdFromAuthUserIdDirective, DbxRouteModelKeyDirective, DbxRouteModelKeyDirectiveDelegate, DbxRouteParamDefaultRedirectInstance, DbxRouterService, DbxRouterTransitionEventType, DbxRouterTransitionService, DbxUIRouterService, DollarAmountPipe, FilterSourceDirective, FullLocalStorageObject, GetValueOncePipe, GetValuePipe, InstantStorageAccessor, LimitedStorageAccessor, LockSetComponentStore, MemoryStorageObject, MinutesStringPipe, NO_AUTH_USER_IDENTIFIER, PrettyJsonPipe, SecondaryActionContextStoreSource, SimpleStorageAccessor, SimpleStorageAccessorFactory, StorageAccessor, StringStorageAccessor, StringifySimpleStorageAccessorConverter, SystemDateToTargetDatePipe, TargetDateToSystemDatePipe, TimeDistanceCountdownPipe, TimeDistancePipe, TimezoneAbbreviationPipe, ToJsDatePipe, ToMinutesPipe, WrapperSimpleStorageAccessorDelegate, actionContextHasNoErrorAndIsModifiedAndCanTrigger, actionContextIsModifiedAndCanTrigger, actionContextStoreSourceMap, actionContextStoreSourceMapReader, actionContextStoreSourcePipe, anchorTypeForAnchor, asSegueRef, asSegueRefString, assertValidStorageKeyPrefix, authRolesSetContainsAllRolesFrom, authRolesSetContainsAnyRoleFrom, authRolesSetContainsNoRolesFrom, authUserIdentifier, canReadyValue, canTriggerAction, canTriggerActionState, checkNgContentWrapperHasContent, clean, cleanDestroy, cleanListLoadingContext, cleanLoadingContext, cleanLockSet, cleanSubscription, cleanSubscriptionWithLockSet, cleanWithLockSet, clickableUrlInNewTab, clickableUrlMailTo, clickableUrlTel, completeOnDestroy, createInjectorForInjectionComponentConfig, dbxActionWorkProgress, dbxButtonDisplayType, dbxInjectionComponentConfigIsEqual, dbxRouteModelIdParamRedirect, dbxRouteModelKeyParamRedirect, dbxRouteParamReaderInstance, defaultStorageObjectFactory, enableHasAuthRoleHook, enableHasAuthStateHook, enableIsLoggedInHook, expandClickableAnchorLinkTree, expandClickableAnchorLinkTreeNode, expandClickableAnchorLinkTrees, filterTransitionEvent, filterTransitionSuccess, flattenExpandedClickableAnchorLinkTree, flattenExpandedClickableAnchorLinkTreeToLinks, fromAllActionContextStoreSourceMapSources, index as fromDbxAppAuth, index$2 as fromDbxAppContext, goWithRouter, hasAuthRoleDecisionPipe, hasNonTrivialChildNodes, initInjectionComponent, isActionContextDisabled, isActionContextEnabled, isClickableFilterPreset, isClickablePartialFilterPreset, isDisabledActionContextState, isIdleActionState, isLatestSuccessfulRoute, isSegueRef, isSegueRefActive, isSegueRefActiveFunction, isSegueRefActiveOnTransitionSuccess, isValidStorageKeyPrefix, isWorkingActionState, latestSuccessfulRoutes, loadingStateForActionContextState, loadingStateTypeForActionContextState, loadingStateTypeForActionState, loggedInObsFromIsLoggedIn, loggedOutObsFromIsLoggedIn, makeAuthTransitionHook, makeDbxActionContextSourceReference, mapRefStringObsToSegueRefObs, mergeDbxInjectionComponentConfigs, mergeStaticProviders, newWithInjector, index$1 as onDbxAppAuth, index$3 as onDbxAppContext, onRouterTransitionEventType, onRouterTransitionSuccessEvent, pipeActionStore, provideActionStoreSource, provideDbxActionButtonEchoConfig, provideDbxActionWorkable, provideDbxAnchor, provideDbxAppAuth, provideDbxAppAuthRouter, provideDbxAppAuthRouterState, provideDbxAppAuthState, provideDbxAppContextState, provideDbxAppEnvironment, provideDbxAssetLoader, provideDbxAuthImpersonation, provideDbxAuthImpersonationDelegate, provideDbxButton, provideDbxInjectionContext, provideDbxRouteModelIdDirectiveDelegate, provideDbxRouteModelKeyDirectiveDelegate, provideDbxStorage, provideDbxUIRouterService, provideFilterSource, provideFilterSourceConnector, provideFilterSourceDirective, provideSecondaryActionStoreSource, redirectBasedOnAuthUserState, redirectForIdentifierParamHook, redirectForUserIdentifierParamHook, refStringToSegueRef, successTransition, switchMapDbxInjectionComponentConfig, transformEmptyStringInputToUndefined, useActionStore };
+export { ACTION_CONTEXT_STORE_LOCKSET_DESTROY_DELAY_TIME, APP_ACTION_DISABLED_DIRECTIVE_KEY, APP_ACTION_DISABLED_ON_SUCCESS_DIRECTIVE_KEY, APP_ACTION_ENFORCE_MODIFIED_DIRECTIVE_KEY, AbstractDbxActionHandlerDirective, AbstractDbxActionValueGetterDirective, AbstractDbxAnchorDirective, AbstractDbxButtonDirective, AbstractDbxFilterMapInstanceDirective, AbstractDbxFilterMapSourceDirective, AbstractDbxInjectionDirective, AbstractFilterSourceConnectorDirective, AbstractFilterSourceDirective, AbstractForwardDbxInjectionContextDirective, AbstractIfDirective, AbstractTransitionDirective, AbstractTransitionWatcherDirective, ActionContextStore, ActionContextStoreSource, ActionContextStoreSourceMap, AsObservablePipe, CutTextPipe, DBX_ACTION_BUTTON_ECHO_CONFIG, DBX_ACTION_HANDLER_LOCK_KEY, DBX_APP_APP_CONTEXT_STATE, DBX_APP_AUTH_ROUTER_EFFECTS_TOKEN, DBX_ASSET_LOADER_CONFIG_TOKEN, DBX_AUTH_APP_CONTEXT_STATE, DBX_FILTER_STORAGE_SERVICE_CONFIG_TOKEN, DBX_INIT_APP_CONTEXT_STATE, DBX_INJECTION_COMPONENT_DATA, DBX_KNOWN_APP_CONTEXT_STATES, DBX_OAUTH_APP_CONTEXT_STATE, DBX_ONBOARD_APP_CONTEXT_STATE, DBX_PUBLIC_APP_CONTEXT_STATE, DEFAULT_ACTION_DISABLED_KEY, DEFAULT_ACTION_MAP_WORKING_DISABLED_KEY, DEFAULT_DBX_ACTION_BUTTON_ECHO_CONFIG, DEFAULT_DBX_ACTION_BUTTON_ERROR_ECHO, DEFAULT_DBX_ACTION_BUTTON_SUCCESS_ECHO, DEFAULT_DBX_BUTTON_ECHO_DURATION, DEFAULT_DBX_FILTER_STORAGE_PREFIX, DEFAULT_DBX_ROUTE_MODEL_ID_PARAM_ID_PARAM_KEY, DEFAULT_DBX_ROUTE_MODEL_ID_PARAM_KEY_PARAM_KEY, DEFAULT_DBX_ROUTE_MODEL_ID_PARAM_USE_PARAM_VALUE, DEFAULT_FILTER_SOURCE_DIRECTIVE_FILTER_TOKEN, DEFAULT_LOCAL_ASSET_BASE_URL, DEFAULT_REDIRECT_FOR_IDENTIFIER_PARAM_KEY, DEFAULT_REDIRECT_FOR_IDENTIFIER_PARAM_VALUE, DEFAULT_REDIRECT_FOR_USER_IDENTIFIER_PARAM_KEY, DEFAULT_REDIRECT_FOR_USER_IDENTIFIER_PARAM_VALUE, DEFAULT_STORAGE_ACCESSOR_FACTORY_TOKEN, DEFAULT_STORAGE_OBJECT_TOKEN, DateDayRangePipe, DateDayTimeRangePipe, DateDistancePipe, DateFormatDistancePipe, DateFormatFromToPipe, DateRangeDistancePipe, DateTimeRangeOnlyDistancePipe, DateTimeRangeOnlyPipe, DateTimeRangePipe, DbxActionAutoModifyDirective, DbxActionAutoTriggerDirective, DbxActionButtonDirective, DbxActionButtonTriggerDirective, DbxActionContextBaseSource, DbxActionContextLoggerDirective, DbxActionContextMachine, DbxActionContextMachineAsService, DbxActionContextMapDirective, DbxActionContextStoreSourceInstance, DbxActionDirective, DbxActionDisabledDirective, DbxActionDisabledOnSuccessDirective, DbxActionEnforceModifiedDirective, DbxActionErrorHandlerDirective, DbxActionFromMapDirective, DbxActionHandlerDirective, DbxActionHandlerInstance, DbxActionHandlerValueDirective, DbxActionHasSuccessDirective, DbxActionIdleDirective, DbxActionIsModifiedDirective, DbxActionIsWorkingDirective, DbxActionMapSourceDirective, DbxActionMapWorkingDisableDirective, DbxActionPreSuccessDirective, DbxActionSourceDirective, DbxActionState, DbxActionSuccessHandlerDirective, DbxActionTriggeredDirective, DbxActionValueDirective, DbxActionValueGetterInstance, DbxActionValueStreamDirective, DbxActionValueTriggerDirective, DbxActionWorkInstanceDelegate, DbxActionWorkable, DbxAnchor, DbxAngularRouterService, DbxAppAuthRouterEffects, DbxAppAuthRouterService, DbxAppAuthRoutes, DbxAppAuthStateService, DbxAppContextService, DbxAppContextStateDirective, DbxAppEnvironment, DbxAppEnvironmentService, DbxAuthHasAnyRoleDirective, DbxAuthHasRolesDirective, DbxAuthImpersonationDelegate, DbxAuthImpersonationQuerySyncDirective, DbxAuthImpersonationService, DbxAuthImpersonationTriggerDirective, DbxAuthNotAnyRoleDirective, DbxAuthService, DbxButton, DbxButtonDirective, DbxButtonSegueDirective, DbxCoreActionModule, DbxCoreAngularRouterSegueModule, DbxCoreAssetLoader, DbxCoreButtonModule, DbxCoreFilterModule, DbxFilterConnectSourceDirective, DbxFilterMapDirective, DbxFilterMapMergeSourceDirective, DbxFilterMapSourceConnectorDirective, DbxFilterMapSourceDirective, DbxFilterMapStorageDirective, DbxFilterSourceConnectorDirective, DbxFilterSourceDirective, DbxFilterStorageService, DbxInjectionArrayComponent, DbxInjectionComponent, DbxInjectionContext, DbxInjectionContextDirective, DbxInjectionInstance, DbxLoadingButtonDirective, DbxRouteModelIdDirective, DbxRouteModelIdDirectiveDelegate, DbxRouteModelIdFromAuthUserIdDirective, DbxRouteModelKeyDirective, DbxRouteModelKeyDirectiveDelegate, DbxRouteParamDefaultRedirectInstance, DbxRouterService, DbxRouterTransitionEventType, DbxRouterTransitionService, DbxUIRouterService, DollarAmountPipe, FilterSourceDirective, FullLocalStorageObject, GetValueOncePipe, GetValuePipe, InstantStorageAccessor, LimitedStorageAccessor, LockSetComponentStore, MemoryStorageObject, MinutesStringPipe, NO_AUTH_USER_IDENTIFIER, PrettyJsonPipe, SecondaryActionContextStoreSource, SimpleStorageAccessor, SimpleStorageAccessorFactory, StorageAccessor, StringStorageAccessor, StringifySimpleStorageAccessorConverter, SystemDateToTargetDatePipe, TargetDateToSystemDatePipe, TimeDistanceCountdownPipe, TimeDistancePipe, TimezoneAbbreviationPipe, ToJsDatePipe, ToMinutesPipe, WrapperSimpleStorageAccessorDelegate, actionContextHasNoErrorAndIsModifiedAndCanTrigger, actionContextIsModifiedAndCanTrigger, actionContextStoreSourceMap, actionContextStoreSourceMapReader, actionContextStoreSourcePipe, anchorTypeForAnchor, asSegueRef, asSegueRefString, assertValidStorageKeyPrefix, authRolesSetContainsAllRolesFrom, authRolesSetContainsAnyRoleFrom, authRolesSetContainsNoRolesFrom, authUserIdentifier, canReadyValue, canTriggerAction, canTriggerActionState, checkNgContentWrapperHasContent, clean, cleanDestroy, cleanListLoadingContext, cleanLoadingContext, cleanLockSet, cleanSubscription, cleanSubscriptionWithLockSet, cleanWithLockSet, clickableUrlInNewTab, clickableUrlMailTo, clickableUrlTel, completeOnDestroy, createInjectorForInjectionComponentConfig, dbxActionWorkProgress, dbxButtonDisplayType, dbxInjectionComponentConfigIsEqual, dbxRouteModelIdParamRedirect, dbxRouteModelKeyParamRedirect, dbxRouteParamReaderInstance, defaultStorageObjectFactory, enableHasAuthRoleHook, enableHasAuthStateHook, enableIsLoggedInHook, expandClickableAnchorLinkTree, expandClickableAnchorLinkTreeNode, expandClickableAnchorLinkTrees, filterTransitionEvent, filterTransitionSuccess, flattenExpandedClickableAnchorLinkTree, flattenExpandedClickableAnchorLinkTreeToLinks, fromAllActionContextStoreSourceMapSources, index as fromDbxAppAuth, index$2 as fromDbxAppContext, goWithRouter, hasAuthRoleDecisionPipe, hasNonTrivialChildNodes, initInjectionComponent, isActionContextDisabled, isActionContextEnabled, isClickableFilterPreset, isClickablePartialFilterPreset, isDisabledActionContextState, isIdleActionState, isLatestSuccessfulRoute, isSegueRef, isSegueRefActive, isSegueRefActiveFunction, isSegueRefActiveOnTransitionSuccess, isValidStorageKeyPrefix, isWorkingActionState, latestSuccessfulRoutes, loadingStateForActionContextState, loadingStateTypeForActionContextState, loadingStateTypeForActionState, loggedInObsFromIsLoggedIn, loggedOutObsFromIsLoggedIn, makeAuthTransitionHook, makeDbxActionContextSourceReference, mapRefStringObsToSegueRefObs, mergeDbxInjectionComponentConfigs, mergeStaticProviders, newWithInjector, index$1 as onDbxAppAuth, index$3 as onDbxAppContext, onRouterTransitionEventType, onRouterTransitionSuccessEvent, pipeActionStore, provideActionStoreSource, provideDbxActionButtonEchoConfig, provideDbxActionWorkable, provideDbxAnchor, provideDbxAppAuth, provideDbxAppAuthRouter, provideDbxAppAuthRouterState, provideDbxAppAuthState, provideDbxAppContextState, provideDbxAppEnvironment, provideDbxAssetLoader, provideDbxAuthImpersonation, provideDbxAuthImpersonationDelegate, provideDbxButton, provideDbxFilterStorage, provideDbxInjectionContext, provideDbxRouteModelIdDirectiveDelegate, provideDbxRouteModelKeyDirectiveDelegate, provideDbxStorage, provideDbxUIRouterService, provideFilterSource, provideFilterSourceConnector, provideFilterSourceDirective, provideSecondaryActionStoreSource, redirectBasedOnAuthUserState, redirectForIdentifierParamHook, redirectForUserIdentifierParamHook, refStringToSegueRef, successTransition, switchMapDbxInjectionComponentConfig, transformEmptyStringInputToUndefined, useActionStore };
 //# sourceMappingURL=dereekb-dbx-core.mjs.map