@dereekb/dbx-core 11.1.7 → 12.0.0

package/lib/button/button.directive.d.ts

@@ -1,35 +1,42 @@
-import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { OnDestroy, OnInit, Signal } from '@angular/core';
 import { type Maybe } from '@dereekb/util';
-import { BehaviorSubject, Subject } from 'rxjs';
+import { Subject, BehaviorSubject } from 'rxjs';
 import { AbstractSubscriptionDirective } from '../subscription';
-import { DbxButton, DbxButtonDisplayContent, DbxButtonDisplayContentType, DbxButtonInterceptor } from './button';
+import { DbxButton, DbxButtonDisplay, DbxButtonDisplayType, DbxButtonInterceptor } from './button';
 import * as i0 from "@angular/core";
 /**
  * Abstract button component.
  */
 export declare abstract class AbstractDbxButtonDirective extends AbstractSubscriptionDirective implements DbxButton, OnInit, OnDestroy {
-    private readonly _disabled;
-    private readonly _working;
     /**
      * Pre-interceptor button click.
      */
     protected readonly _buttonClick: Subject<void>;
     protected readonly _buttonInterceptor: BehaviorSubject<Maybe<DbxButtonInterceptor>>;
+    readonly buttonClick: import("@angular/core").OutputEmitterRef<void>;
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, Maybe<boolean>>;
+    readonly working: import("@angular/core").InputSignalWithTransform<boolean, Maybe<boolean>>;
+    readonly buttonDisplay: import("@angular/core").InputSignal<Maybe<DbxButtonDisplay>>;
+    private readonly _disabledSignal;
+    private readonly _workingSignal;
+    private readonly _buttonDisplayContentSignal;
+    readonly disabledSignal: Signal<boolean>;
+    readonly workingSignal: Signal<boolean>;
+    readonly icon: import("@angular/core").InputSignal<Maybe<string>>;
+    readonly text: import("@angular/core").InputSignal<Maybe<string>>;
+    readonly buttonDisplayContentSignal: Signal<DbxButtonDisplay>;
+    readonly buttonDisplayTypeSignal: Signal<DbxButtonDisplayType>;
+    readonly iconSignal: Signal<Maybe<string>>;
+    readonly textSignal: Signal<Maybe<string>>;
     readonly disabled$: import("rxjs").Observable<boolean>;
     readonly working$: import("rxjs").Observable<boolean>;
-    get disabled(): boolean;
-    set disabled(disabled: Maybe<boolean>);
-    get working(): boolean;
-    set working(working: Maybe<boolean>);
-    icon?: Maybe<string>;
-    text?: Maybe<string>;
-    get buttonDisplay(): DbxButtonDisplayContent;
-    set buttonDisplay(buttonDisplay: Maybe<DbxButtonDisplayContent>);
-    get buttonDisplayType(): DbxButtonDisplayContentType;
-    readonly buttonClick: EventEmitter<any>;
-    readonly clicked$: import("rxjs").Observable<any>;
+    readonly display$: import("rxjs").Observable<DbxButtonDisplay>;
+    readonly clicked$: import("rxjs").Observable<void>;
     ngOnInit(): void;
     ngOnDestroy(): void;
+    setDisabled(disabled?: Maybe<boolean>): void;
+    setWorking(working?: Maybe<boolean>): void;
+    setDisplayContent(content: DbxButtonDisplay): void;
     /**
      * Sets the button interceptor. If any interceptor is already set, it is replaced.
      */
@@ -43,12 +50,12 @@ export declare abstract class AbstractDbxButtonDirective extends AbstractSubscri
      */
     protected _forceButtonClicked(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxButtonDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxButtonDirective, never, never, { "disabled": { "alias": "disabled"; "required": false; }; "working": { "alias": "working"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "text": { "alias": "text"; "required": false; }; "buttonDisplay": { "alias": "buttonDisplay"; "required": false; }; }, { "buttonClick": "buttonClick"; }, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxButtonDirective, never, never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "working": { "alias": "working"; "required": false; "isSignal": true; }; "buttonDisplay": { "alias": "buttonDisplay"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, { "buttonClick": "buttonClick"; }, never, never, false, never>;
 }
 /**
  * Provides an DbxButton directive.
  */
 export declare class DbxButtonDirective extends AbstractDbxButtonDirective {
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxButtonDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxButtonDirective, "[dbxButton]", ["dbxButton"], {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxButtonDirective, "[dbxButton]", ["dbxButton"], {}, {}, never, never, true, never>;
 }

package/lib/button/button.loading.directive.d.ts

@@ -1,6 +1,5 @@
-import { NgZone } from '@angular/core';
-import { LoadingContext } from '@dereekb/rxjs';
-import { AbstractSubscriptionDirective } from '../subscription';
+import { LoadingContext, MaybeObservableOrValue } from '@dereekb/rxjs';
+import { AbstractSubscriptionDirective } from '../subscription/subscription.directive';
 import { DbxButton } from './button';
 import * as i0 from "@angular/core";
 /**
@@ -10,11 +9,10 @@ import * as i0 from "@angular/core";
  */
 export declare class DbxLoadingButtonDirective extends AbstractSubscriptionDirective {
     readonly dbxButton: DbxButton;
-    readonly ngZone: NgZone;
-    /**
-     * Sets a LoadingContext that is watched for the loading state.
-     */
-    set context(context: LoadingContext);
+    readonly context: import("@angular/core").InputSignal<MaybeObservableOrValue<LoadingContext<import("@dereekb/rxjs").LoadingContextEvent>>>;
+    readonly context$: import("rxjs").Observable<import("dist/packages/util/src").Maybe<LoadingContext<import("@dereekb/rxjs").LoadingContextEvent>>>;
+    readonly contextSignal: import("@angular/core").Signal<import("dist/packages/util/src").Maybe<LoadingContext<import("@dereekb/rxjs").LoadingContextEvent>>>;
+    protected readonly _loadingEffect: import("@angular/core").EffectRef;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxLoadingButtonDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxLoadingButtonDirective, "[dbxLoadingButton]", never, { "context": { "alias": "dbxLoadingButton"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxLoadingButtonDirective, "[dbxLoadingButton]", never, { "context": { "alias": "dbxLoadingButton"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/button/button.module.d.ts

@@ -4,8 +4,16 @@ import * as i2 from "./button.loading.directive";
 import * as i3 from "./action/action.button.trigger.directive";
 import * as i4 from "./action/action.button.directive";
 import * as i5 from "./router/button.segue.directive";
+/**
+ * Exports the following directives:
+ * - DbxButtonDirective
+ * - DbxLoadingButtonDirective
+ * - DbxActionButtonTriggerDirective
+ * - DbxActionButtonDirective
+ * - DbxButtonSegueDirective
+ */
 export declare class DbxCoreButtonModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxCoreButtonModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxCoreButtonModule, [typeof i1.DbxButtonDirective, typeof i2.DbxLoadingButtonDirective, typeof i3.DbxActionButtonTriggerDirective, typeof i4.DbxActionButtonDirective, typeof i5.DbxButtonSegueDirective], never, [typeof i1.DbxButtonDirective, typeof i2.DbxLoadingButtonDirective, typeof i3.DbxActionButtonTriggerDirective, typeof i4.DbxActionButtonDirective, typeof i5.DbxButtonSegueDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxCoreButtonModule, never, [typeof i1.DbxButtonDirective, typeof i2.DbxLoadingButtonDirective, typeof i3.DbxActionButtonTriggerDirective, typeof i4.DbxActionButtonDirective, typeof i5.DbxButtonSegueDirective], [typeof i1.DbxButtonDirective, typeof i2.DbxLoadingButtonDirective, typeof i3.DbxActionButtonTriggerDirective, typeof i4.DbxActionButtonDirective, typeof i5.DbxButtonSegueDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DbxCoreButtonModule>;
 }

package/lib/button/router/button.segue.directive.d.ts

@@ -1,8 +1,9 @@
 import { OnInit, OnDestroy } from '@angular/core';
 import { type Maybe } from '@dereekb/util';
-import { AbstractSubscriptionDirective } from '../../subscription';
+import { AbstractSubscriptionDirective } from '../../subscription/subscription.directive';
 import { DbxButton } from '../button';
-import { SegueRef, DbxRouterService } from '../../router';
+import { DbxRouterService } from '../../router/router/service/router.service';
+import { SegueRef } from '../../router/segue';
 import * as i0 from "@angular/core";
 export declare class DbxButtonSegueDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
     readonly dbxButton: DbxButton;
@@ -14,5 +15,5 @@ export declare class DbxButtonSegueDirective extends AbstractSubscriptionDirecti
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxButtonSegueDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxButtonSegueDirective, "[dbxButtonSegue]", never, { "segueRef": { "alias": "dbxButtonSegue"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxButtonSegueDirective, "[dbxButtonSegue]", never, { "segueRef": { "alias": "dbxButtonSegue"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/context/context.d.ts

@@ -10,21 +10,24 @@
  * More complex apps may have more sub-sections or app portions that could each have their own context state.
  */
 export type DbxAppContextState = string;
+/**
+ * The init state of an app after the default context has been initialized.
+ */
 export declare const DBX_INIT_APP_CONTEXT_STATE = "init";
 /**
- *
+ * The public state of an app, typically when a user opens up the site to a public page.
  */
 export declare const DBX_PUBLIC_APP_CONTEXT_STATE = "public";
 /**
- *
+ * The auth state of an app, typically when a user has not finished logging in.
  */
 export declare const DBX_AUTH_APP_CONTEXT_STATE = "auth";
 /**
- *
+ * The onboarding state of an app, typically when a user has completed auth but not finished setting up their account.
  */
 export declare const DBX_ONBOARD_APP_CONTEXT_STATE = "onboard";
 /**
- *
+ * The app state of an app, typically when a user has completed auth and onboarding.
  */
 export declare const DBX_APP_APP_CONTEXT_STATE = "app";
 /**

package/lib/context/context.directive.d.ts

@@ -15,5 +15,5 @@ export declare class DbxAppContextStateDirective extends AbstractSubscriptionDir
     ngOnDestroy(): void;
     set state(state: Maybe<DbxAppContextState>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxAppContextStateDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAppContextStateDirective, "[dbxAppContextState]", never, { "state": { "alias": "dbxAppContextState"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAppContextStateDirective, "[dbxAppContextState]", never, { "state": { "alias": "dbxAppContextState"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/context/context.module.d.ts

@@ -1,8 +1,10 @@
 import * as i0 from "@angular/core";
 import * as i1 from "./context.directive";
-import * as i2 from "@ngrx/store";
+/**
+ * @deprecated Use provideDbxAppContextState() and import DbxAppContextStateDirective directly. DbxAppContextStateDirective is now standalone.
+ */
 export declare class DbxAppContextStateModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxAppContextStateModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxAppContextStateModule, [typeof i1.DbxAppContextStateDirective], [typeof i2.StoreFeatureModule], [typeof i1.DbxAppContextStateDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxAppContextStateModule, never, [typeof i1.DbxAppContextStateDirective], [typeof i1.DbxAppContextStateDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DbxAppContextStateModule>;
 }

package/lib/context/context.providers.d.ts

@@ -0,0 +1,7 @@
+import { EnvironmentProviders } from '@angular/core';
+/**
+ * Creates EnvironmentProviders for providing the DbxAppContext state.
+ *
+ * @returns EnvironmentProviders
+ */
+export declare function provideDbxAppContextState(): EnvironmentProviders;

package/lib/context/index.d.ts

@@ -2,4 +2,5 @@ export * from './state';
 export * from './context';
 export * from './context.directive';
 export * from './context.module';
+export * from './context.providers';
 export * from './context.service';

package/lib/context/state/action/data.action.d.ts

@@ -6,8 +6,8 @@ export declare const setState: import("@ngrx/store").ActionCreator<"[App/Context
     state: DbxAppContextState;
 }) => {
     state: DbxAppContextState;
-} & import("@ngrx/store/src/models").TypedAction<"[App/Context] Set State">>;
+} & import("@ngrx/store").Action<"[App/Context] Set State">>;
 /**
  * Resets the app back to the init context.
  */
-export declare const resetState: import("@ngrx/store").ActionCreator<"[App/Context] Reset", () => import("@ngrx/store/src/models").TypedAction<"[App/Context] Reset">>;
+export declare const resetState: import("@ngrx/store").ActionCreator<"[App/Context] Reset", () => import("@ngrx/store").Action<"[App/Context] Reset">>;

package/lib/context/state/reducer/data.reducer.d.ts

@@ -10,4 +10,4 @@ export interface DbxAppContextStateData {
     state: DbxAppContextState;
 }
 export declare const initialState: DbxAppContextStateData;
-export declare const reducer: import("@ngrx/store").ActionReducer<DbxAppContextStateData, import("@ngrx/store").Action>;
+export declare const reducer: import("@ngrx/store").ActionReducer<DbxAppContextStateData, import("@ngrx/store").Action<string>>;

package/lib/environment/environment.providers.d.ts

@@ -0,0 +1,8 @@
+import { EnvironmentProviders } from '@angular/core';
+import { DbxAppEnviroment } from './environment';
+/**
+ * Provides the DbxAppEnviromentService and DbxAppEnviroment.
+ *
+ * @param environment
+ */
+export declare function provideDbxAppEnviroment(environment: DbxAppEnviroment): EnvironmentProviders;

package/lib/environment/index.d.ts

@@ -1,2 +1,3 @@
-export * from './service/environment';
-export * from './service/environment.service';
+export * from './environment';
+export * from './environment.service';
+export * from './environment.providers';

package/lib/filter/filter.abstract.connector.directive.d.ts

@@ -6,7 +6,7 @@ import * as i0 from "@angular/core";
  * Abstract FilterSourceConnector directive.
  */
 export declare abstract class AbstractFilterSourceConnectorDirective<F> implements FilterSourceConnector<F>, FilterSource<F>, OnDestroy {
-    private _source;
+    private readonly _source;
     readonly filter$: Observable<F>;
     ngOnDestroy(): void;
     connectWithSource(filterSource: FilterSource<F>): void;

package/lib/filter/filter.abstract.source.directive.d.ts

@@ -1,33 +1,37 @@
 import { Observable } from 'rxjs';
-import { OnDestroy, OnInit, Provider, Type } from '@angular/core';
-import { FilterSource, FilterSourceInstance, ObservableOrValue } from '@dereekb/rxjs';
+import { InjectionToken, Injector, OnDestroy, Provider, Type } from '@angular/core';
+import { FilterSource, FilterSourceInstance, MaybeObservableOrValue } from '@dereekb/rxjs';
 import { type Maybe } from '@dereekb/util';
 import * as i0 from "@angular/core";
+export declare const FILTER_SOURCE_DIRECTIVE_DEFAULT_FILTER_TOKEN: InjectionToken<Maybe<Observable<unknown>>>;
 export declare abstract class FilterSourceDirective<F = unknown> implements FilterSource<F> {
-    abstract filter$: Observable<F>;
+    abstract readonly filter$: Observable<F>;
     abstract initWithFilter(filterObs: Observable<F>): void;
     abstract setFilter(filter: F): void;
     abstract resetFilter(): void;
 }
+export type ProvideFilterSourceDirectiveDefaultFilterFactoryFunction<F = unknown> = (injector: Injector) => MaybeObservableOrValue<F>;
 /**
  * Angular provider convenience function for a FilterSourceDirective.
  */
-export declare function provideFilterSourceDirective<S extends FilterSourceDirective<F>, F = unknown>(sourceType: Type<S>): Provider[];
+export declare function provideFilterSourceDirective<S extends FilterSourceDirective<F>, F = unknown>(sourceType: Type<S>, defaultFilterFactory?: ProvideFilterSourceDirectiveDefaultFilterFactoryFunction): Provider[];
 /**
  * Abstract FilterSource implementation and directive.
  */
-export declare abstract class AbstractFilterSourceDirective<F = unknown> implements FilterSourceDirective<F>, OnInit, OnDestroy {
-    protected defaultFilterValue?: Maybe<F>;
-    protected _defaultFilterSource: FilterSourceInstance<F>;
+export declare abstract class AbstractFilterSourceDirective<F = unknown> implements FilterSourceDirective<F>, OnDestroy {
+    private readonly _defaultFilter;
+    protected readonly _defaultFilterSource: FilterSourceInstance<F>;
     readonly filter$: Observable<F>;
-    ngOnInit(): void;
     ngOnDestroy(): void;
+    protected setDefaultFilter(defaultFilter: Observable<Maybe<F>>): void;
     initWithFilter(filterObs: Observable<F>): void;
     setFilter(filter: F): void;
     resetFilter(): void;
-    get initialFilterTakesPriority(): boolean;
+    setInitialFilterTakesPriority(initialFilterTakesPriority: boolean): void;
+    /**
+     * @deprecated use setInitialFilterTakesPriority() instead.
+     */
     set initialFilterTakesPriority(initialFilterTakesPriority: boolean);
-    protected makeDefaultFilter(): ObservableOrValue<Maybe<F>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractFilterSourceDirective<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractFilterSourceDirective<any>, never, never, {}, {}, never, never, false, never>;
 }

package/lib/filter/filter.connect.source.directive.d.ts

@@ -9,5 +9,5 @@ export declare class DbxFilterConnectSourceDirective<F = unknown> implements OnI
     readonly filterSourceConnector: FilterSourceConnector<any>;
     ngOnInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxFilterConnectSourceDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterConnectSourceDirective<any>, "[dbxFilterConnectSource]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterConnectSourceDirective<any>, "[dbxFilterConnectSource]", never, {}, {}, never, never, true, never>;
 }

package/lib/filter/filter.connector.directive.d.ts

@@ -5,5 +5,5 @@ import * as i0 from "@angular/core";
  */
 export declare class DbxFilterSourceConnectorDirective<F = unknown> extends AbstractFilterSourceConnectorDirective<F> {
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxFilterSourceConnectorDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterSourceConnectorDirective<any>, "[dbxFilterSourceConnector]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterSourceConnectorDirective<any>, "[dbxFilterSourceConnector]", never, {}, {}, never, never, true, never>;
 }

package/lib/filter/filter.map.connector.directive.d.ts

@@ -1,14 +1,14 @@
-import { FilterSourceConnector, FilterSource, FilterMapKey } from '@dereekb/rxjs';
-import { DbxFilterMapSourceDirective } from './filter.map.source.directive';
+import { FilterSourceConnector, FilterSource } from '@dereekb/rxjs';
+import { AbstractDbxFilterMapSourceDirective } from './filter.map.source.directive';
 import { type Maybe } from '@dereekb/util';
 import * as i0 from "@angular/core";
 /**
  * Acts as an "input" FilterSourceConnector for an FilterMap, as well as a source for the FilterSourceConnector.
  */
-export declare class DbxFilterMapSourceConnectorDirective<F> extends DbxFilterMapSourceDirective<F> implements FilterSourceConnector<F> {
-    get key(): Maybe<FilterMapKey>;
-    set key(key: Maybe<FilterMapKey>);
+export declare class DbxFilterMapSourceConnectorDirective<F> extends AbstractDbxFilterMapSourceDirective<F> implements FilterSourceConnector<F> {
+    readonly dbxFilterMapSourceConnector: import("@angular/core").InputSignal<Maybe<string>>;
+    protected readonly _dbxFilterMapSourceConnectorEffect: import("@angular/core").EffectRef;
     connectWithSource(filterSource: FilterSource<F>): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxFilterMapSourceConnectorDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterMapSourceConnectorDirective<any>, "[dbxFilterMapSourceConnector]", ["dbxFilterMapSourceConnector"], { "key": { "alias": "dbxFilterMapSourceConnector"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterMapSourceConnectorDirective<any>, "[dbxFilterMapSourceConnector]", ["dbxFilterMapSourceConnector"], { "dbxFilterMapSourceConnector": { "alias": "dbxFilterMapSourceConnector"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/filter/filter.map.directive.d.ts

@@ -8,5 +8,5 @@ export declare class DbxFilterMapDirective<F> implements OnDestroy {
     readonly filterMap: FilterMap<any>;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxFilterMapDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterMapDirective<any>, "[dbxFilterMap]", ["dbxFilterMap"], {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterMapDirective<any>, "[dbxFilterMap]", ["dbxFilterMap"], {}, {}, never, never, true, never>;
 }

package/lib/filter/filter.map.instance.directive.d.ts

@@ -1,17 +1,16 @@
-import { FilterMap } from '@dereekb/rxjs';
-import { BehaviorSubject } from 'rxjs';
+import { FilterMapKey, FilterMap, MaybeObservableOrValue } from '@dereekb/rxjs';
 import { OnDestroy } from '@angular/core';
-import { type Maybe } from '@dereekb/util';
 import * as i0 from "@angular/core";
 /**
  * Provides a FilterSource from a parent FilterMap.
  */
 export declare abstract class AbstractDbxFilterMapInstanceDirective<F> implements OnDestroy {
-    protected _key: BehaviorSubject<Maybe<string>>;
     readonly dbxFilterMap: FilterMap<any>;
-    readonly key$: import("rxjs").Observable<string>;
+    private readonly _currentFilterMapKey;
+    readonly filterMapKey$: import("rxjs").Observable<string>;
     readonly instance$: import("rxjs").Observable<import("@dereekb/rxjs").FilterMapKeyInstance<any>>;
     ngOnDestroy(): void;
+    setFilterMapKey(filterMapKey: MaybeObservableOrValue<FilterMapKey>): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxFilterMapInstanceDirective<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxFilterMapInstanceDirective<any>, never, never, {}, {}, never, never, false, never>;
 }

package/lib/filter/filter.map.source.directive.d.ts

@@ -1,16 +1,23 @@
-import { FilterSource, FilterMapKey } from '@dereekb/rxjs';
+import { FilterSource } from '@dereekb/rxjs';
 import { Observable } from 'rxjs';
 import { AbstractDbxFilterMapInstanceDirective } from './filter.map.instance.directive';
 import { type Maybe } from '@dereekb/util';
 import * as i0 from "@angular/core";
 /**
- * Provides a FilterSource from a parent FilterMap.
+ * Abstract directive that extends AbstractDbxFilterMapInstanceDirective and implements FilterSource.
  */
-export declare class DbxFilterMapSourceDirective<F> extends AbstractDbxFilterMapInstanceDirective<F> implements FilterSource<F> {
+export declare abstract class AbstractDbxFilterMapSourceDirective<F> extends AbstractDbxFilterMapInstanceDirective<F> implements FilterSource<F> {
     readonly filter$: Observable<F>;
-    get key(): Maybe<FilterMapKey>;
-    set key(key: Maybe<FilterMapKey>);
     initWithFilter(filterObs: Observable<F>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxFilterMapSourceDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxFilterMapSourceDirective<any>, never, never, {}, {}, never, never, false, never>;
+}
+/**
+ * Provides a FilterSource from a parent FilterMap.
+ */
+export declare class DbxFilterMapSourceDirective<F> extends AbstractDbxFilterMapSourceDirective<F> implements FilterSource<F> {
+    readonly dbxFilterMapSource: import("@angular/core").InputSignal<Maybe<string>>;
+    protected readonly _dbxFilterMapSourceEffect: import("@angular/core").EffectRef;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxFilterMapSourceDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterMapSourceDirective<any>, "[dbxFilterMapSource]", ["dbxFilterMapSource"], { "key": { "alias": "dbxFilterMapSource"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterMapSourceDirective<any>, "[dbxFilterMapSource]", ["dbxFilterMapSource"], { "dbxFilterMapSource": { "alias": "dbxFilterMapSource"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/filter/filter.module.d.ts

@@ -5,9 +5,8 @@ import * as i3 from "./filter.connect.source.directive";
 import * as i4 from "./filter.connector.directive";
 import * as i5 from "./filter.map.directive";
 import * as i6 from "./filter.map.source.directive";
-import * as i7 from "@angular/common";
 export declare class DbxCoreFilterModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxCoreFilterModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxCoreFilterModule, [typeof i1.DbxFilterSourceDirective, typeof i2.DbxFilterMapSourceConnectorDirective, typeof i3.DbxFilterConnectSourceDirective, typeof i4.DbxFilterSourceConnectorDirective, typeof i5.DbxFilterMapDirective, typeof i6.DbxFilterMapSourceDirective], [typeof i7.CommonModule], [typeof i1.DbxFilterSourceDirective, typeof i2.DbxFilterMapSourceConnectorDirective, typeof i3.DbxFilterConnectSourceDirective, typeof i4.DbxFilterSourceConnectorDirective, typeof i5.DbxFilterMapDirective, typeof i6.DbxFilterMapSourceDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxCoreFilterModule, never, [typeof i1.DbxFilterSourceDirective, typeof i2.DbxFilterMapSourceConnectorDirective, typeof i3.DbxFilterConnectSourceDirective, typeof i4.DbxFilterSourceConnectorDirective, typeof i5.DbxFilterMapDirective, typeof i6.DbxFilterMapSourceDirective], [typeof i1.DbxFilterSourceDirective, typeof i2.DbxFilterMapSourceConnectorDirective, typeof i3.DbxFilterConnectSourceDirective, typeof i4.DbxFilterSourceConnectorDirective, typeof i5.DbxFilterMapDirective, typeof i6.DbxFilterMapSourceDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DbxCoreFilterModule>;
 }

package/lib/filter/filter.source.directive.d.ts

@@ -5,5 +5,5 @@ import * as i0 from "@angular/core";
  */
 export declare class DbxFilterSourceDirective<F> extends AbstractFilterSourceDirective<F> {
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxFilterSourceDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterSourceDirective<any>, "[dbxFilterSource]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterSourceDirective<any>, "[dbxFilterSource]", never, {}, {}, never, never, true, never>;
 }

package/lib/injection/injection.array.component.d.ts

@@ -1,17 +1,11 @@
-import { OnDestroy, TrackByFunction } from '@angular/core';
 import { DbxInjectionArrayEntry } from './injection.array';
 import { type Maybe } from '@dereekb/util';
 import * as i0 from "@angular/core";
 /**
  * Component that injects content based on the configuration into the view.
  */
-export declare class DbxInjectionArrayComponent implements OnDestroy {
-    private _entries;
-    readonly entries$: import("rxjs").Observable<DbxInjectionArrayEntry<unknown>[]>;
-    readonly trackByKeyFn: TrackByFunction<DbxInjectionArrayEntry>;
-    ngOnDestroy(): void;
-    get entries(): DbxInjectionArrayEntry[];
-    set entries(entries: Maybe<DbxInjectionArrayEntry[]>);
+export declare class DbxInjectionArrayComponent {
+    readonly entries: import("@angular/core").InputSignal<Maybe<DbxInjectionArrayEntry<unknown>[]>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxInjectionArrayComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DbxInjectionArrayComponent, "dbx-injection-array", never, { "entries": { "alias": "entries"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxInjectionArrayComponent, "dbx-injection-array", never, { "entries": { "alias": "entries"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/injection/injection.component.d.ts

@@ -2,14 +2,18 @@ import { ViewContainerRef } from '@angular/core';
 import { DbxInjectionComponentConfig, DbxInjectionTemplateConfig } from './injection';
 import { AbstractDbxInjectionDirective } from './injection.directive';
 import { type Maybe } from '@dereekb/util';
+import { ObservableOrValueGetter } from '@dereekb/rxjs';
 import * as i0 from "@angular/core";
 /**
  * Component that injects content based on the configuration into the view.
  */
 export declare class DbxInjectionComponent<T> extends AbstractDbxInjectionDirective<T> {
-    set config(config: Maybe<DbxInjectionComponentConfig<T>>);
-    set template(template: Maybe<DbxInjectionTemplateConfig<T>>);
-    set content(content: Maybe<ViewContainerRef>);
+    readonly content: import("@angular/core").Signal<ViewContainerRef | undefined>;
+    readonly config: import("@angular/core").InputSignal<Maybe<ObservableOrValueGetter<DbxInjectionComponentConfig<T>>>>;
+    readonly template: import("@angular/core").InputSignal<Maybe<ObservableOrValueGetter<DbxInjectionTemplateConfig<T>>>>;
+    protected readonly _contentEffect: import("@angular/core").EffectRef;
+    protected readonly _configEffect: import("@angular/core").EffectRef;
+    protected readonly _templateEffect: import("@angular/core").EffectRef;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxInjectionComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DbxInjectionComponent<any>, "dbx-injection, [dbxInjection], [dbx-injection]", never, { "config": { "alias": "config"; "required": false; }; "template": { "alias": "template"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxInjectionComponent<any>, "dbx-injection, [dbxInjection], [dbx-injection]", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "template": { "alias": "template"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/injection/injection.component.module.d.ts

@@ -2,10 +2,15 @@ import * as i0 from "@angular/core";
 import * as i1 from "./injection.component";
 import * as i2 from "./injection.array.component";
 import * as i3 from "./injection.context.directive";
-import * as i4 from "@angular/common";
-import * as i5 from "../pipe/async/async.pipe.module";
+/**
+ * @deprecated import the individual components instead.
+ *
+ * - DbxInjectionComponent
+ * - DbxInjectionArrayComponent
+ * - DbxInjectionContextDirective
+ */
 export declare class DbxInjectionComponentModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxInjectionComponentModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxInjectionComponentModule, [typeof i1.DbxInjectionComponent, typeof i2.DbxInjectionArrayComponent, typeof i3.DbxInjectionContextDirective], [typeof i4.CommonModule, typeof i5.DbxAsyncPipeModule], [typeof i1.DbxInjectionComponent, typeof i2.DbxInjectionArrayComponent, typeof i3.DbxInjectionContextDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxInjectionComponentModule, never, [typeof i1.DbxInjectionComponent, typeof i2.DbxInjectionArrayComponent, typeof i3.DbxInjectionContextDirective], [typeof i1.DbxInjectionComponent, typeof i2.DbxInjectionArrayComponent, typeof i3.DbxInjectionContextDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DbxInjectionComponentModule>;
 }

package/lib/injection/injection.context.directive.d.ts

@@ -10,8 +10,8 @@ export declare class DbxInjectionContextDirective<O = unknown> implements DbxInj
     private readonly _injector;
     private readonly _templateRef;
     private readonly _viewContainer;
+    private readonly _instance;
     private _currentPromise;
-    private _instance;
     private _embeddedView;
     private _isDetached;
     set config(config: Maybe<DbxInjectionComponentConfig<unknown>>);
@@ -20,5 +20,5 @@ export declare class DbxInjectionContextDirective<O = unknown> implements DbxInj
     showContext<T, O>(config: DbxInjectionContextConfig<T>): Promise<O>;
     resetContext(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxInjectionContextDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxInjectionContextDirective<any>, "[dbxInjectionContext]", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxInjectionContextDirective<any>, "[dbxInjectionContext]", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/injection/injection.d.ts

@@ -5,27 +5,27 @@ export interface DbxInjectionComponentConfig<T = unknown> {
     /**
      * Type of Component to initialize.
      */
-    componentClass: Type<T>;
+    readonly componentClass: Type<T>;
     /**
      * (Optional) providers to provide to the existing injector.
      */
-    providers?: StaticProvider[];
+    readonly providers?: StaticProvider[];
     /**
      * (Optional) Custom parent injector to use when creating the component.
      */
-    injector?: Injector;
+    readonly injector?: Injector;
     /**
      * (Optional) Module ref to use when creating the component.
      */
-    ngModuleRef?: NgModuleRef<unknown>;
+    readonly ngModuleRef?: NgModuleRef<unknown>;
     /**
      * (Optional) Custom initialization code when an instance is created.
      */
-    init?: (instance: T) => void;
+    readonly init?: (instance: T) => void;
     /**
      * unknown optional data to inject into the component.
      */
-    data?: unknown;
+    readonly data?: unknown;
 }
 /**
  * The injector may be important to where the dbxInjection is getting injected at. Some types may disallow setting a custom parent injector.
@@ -36,11 +36,11 @@ export interface DbxInjectionTemplateConfig<T = unknown> {
     /**
      * Template ref to display.
      */
-    templateRef?: Maybe<TemplateRef<T>>;
+    readonly templateRef?: Maybe<TemplateRef<T>>;
     /**
      * View ref to inject.
      */
-    viewRef?: Maybe<ViewRef>;
+    readonly viewRef?: Maybe<ViewRef>;
 }
 /**
  * Merges multiple configurations into a single configuration.

package/lib/injection/injection.directive.d.ts

@@ -1,16 +1,17 @@
 import { ViewContainerRef, OnInit, OnDestroy } from '@angular/core';
 import { type Maybe } from '@dereekb/util';
 import { DbxInjectionComponentConfig, DbxInjectionTemplateConfig } from './injection';
+import { ObservableOrValueGetter } from '@dereekb/rxjs';
 import * as i0 from "@angular/core";
 /**
  * Abstract directive that injects content based on the configuration into the view.
  */
 export declare abstract class AbstractDbxInjectionDirective<T> implements OnInit, OnDestroy {
-    private _instance;
+    private readonly _instance;
     ngOnInit(): void;
     ngOnDestroy(): void;
-    setConfig(config: Maybe<DbxInjectionComponentConfig<T>>): void;
-    setTemplate(template: Maybe<DbxInjectionTemplateConfig<T>>): void;
+    setConfig(config: Maybe<ObservableOrValueGetter<DbxInjectionComponentConfig<T>>>): void;
+    setTemplate(template: Maybe<ObservableOrValueGetter<DbxInjectionTemplateConfig<T>>>): void;
     setContent(content: Maybe<ViewContainerRef>): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxInjectionDirective<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxInjectionDirective<any>, never, never, {}, {}, never, never, false, never>;

package/lib/injection/injection.instance.d.ts

@@ -1,6 +1,7 @@
 import { ComponentRef, Injector, ViewContainerRef } from '@angular/core';
 import { DbxInjectionComponentConfig, DbxInjectionTemplateConfig } from './injection';
 import { Initialized, Destroyable, Maybe } from '@dereekb/util';
+import { ObservableOrValueGetter } from '@dereekb/rxjs';
 /**
  * Instance used by components to inject content based on the configuration into the view.
  */
@@ -14,10 +15,10 @@ export declare class DbxInjectionInstance<T> implements Initialized, Destroyable
     readonly config$: import("rxjs").Observable<Maybe<DbxInjectionComponentConfig<T>>>;
     readonly template$: import("rxjs").Observable<Maybe<DbxInjectionTemplateConfig<T>>>;
     readonly content$: import("rxjs").Observable<ViewContainerRef>;
-    get config(): Maybe<DbxInjectionComponentConfig<T>>;
-    set config(config: Maybe<DbxInjectionComponentConfig<T>>);
-    get template(): Maybe<DbxInjectionTemplateConfig<T>>;
-    set template(template: Maybe<DbxInjectionTemplateConfig<T>>);
+    get config(): Maybe<ObservableOrValueGetter<DbxInjectionComponentConfig<T>>>;
+    set config(config: Maybe<ObservableOrValueGetter<DbxInjectionComponentConfig<T>>>);
+    get template(): Maybe<ObservableOrValueGetter<DbxInjectionTemplateConfig<T>>>;
+    set template(template: Maybe<ObservableOrValueGetter<DbxInjectionTemplateConfig<T>>>);
     get content(): Maybe<Maybe<ViewContainerRef>>;
     set content(content: Maybe<Maybe<ViewContainerRef>>);
     get componentRef(): Maybe<ComponentRef<T>>;