@dereekb/dbx-core 12.6.21 → 12.7.0

package/lib/action/action.machine.d.ts

@@ -3,7 +3,6 @@ import { ActionContextStoreSource } from './action.store.source';
 import { DbxActionContextBaseSource } from './action.holder';
 import { Destroyable, type Maybe } from '@dereekb/util';
 import { Work } from '@dereekb/rxjs';
-import { OnDestroy } from '@angular/core';
 import * as i0 from "@angular/core";
 /**
  * DbxActionContextMachine configuration.
@@ -40,11 +39,10 @@ export declare class DbxActionContextMachine<T = unknown, O = unknown> extends D
     get isShutdown(): boolean;
 }
 /**
- * DbxActionContextMachine that implements OnDestroy and is configured for use as a Service/Injectable.
+ * DbxActionContextMachine configured for use as a Service/Injectable.
  */
-export declare class DbxActionContextMachineAsService<T = unknown, O = unknown> extends DbxActionContextMachine<T, O> implements OnDestroy {
+export declare class DbxActionContextMachineAsService<T = unknown, O = unknown> extends DbxActionContextMachine<T, O> {
     constructor();
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionContextMachineAsService<any, any>, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DbxActionContextMachineAsService<any, any>>;
 }

package/lib/action/action.store.d.ts

@@ -2,7 +2,7 @@ import { OnDestroy } from '@angular/core';
 import { ComponentStore } from '@ngrx/component-store';
 import { Observable } from 'rxjs';
 import { BooleanStringKeyArray, Maybe, ReadableError } from '@dereekb/util';
-import { LoadingStateType, LoadingState, LockSet } from '@dereekb/rxjs';
+import { LoadingStateType, LoadingState } from '@dereekb/rxjs';
 import { DbxActionRejectedPair, DbxActionState, DbxActionSuccessPair, DbxActionWorkOrWorkProgress, DbxActionWorkProgress } from './action';
 import * as i0 from "@angular/core";
 export declare function isActionContextEnabled(state: ActionContextState): boolean;
@@ -50,7 +50,7 @@ export interface ActionContextState<T = unknown, O = unknown> {
     readonly errorCount?: number;
 }
 export declare class ActionContextStore<T = unknown, O = unknown> extends ComponentStore<ActionContextState<T, O>> implements OnDestroy {
-    readonly lockSet: LockSet;
+    readonly lockSet: import("@dereekb/rxjs").LockSet;
     constructor();
     readonly actionState$: Observable<DbxActionState>;
     /**

package/lib/action/action.store.source.provide.d.ts

@@ -1,8 +1,5 @@
 import { type Provider, type Type } from '@angular/core';
-import { ActionContextStoreSource, DbxActionContextStoreSourceInstance, SecondaryActionContextStoreSource } from './action.store.source';
-import { DbxActionContextMachineAsService } from './action.machine';
-export declare const actionContextStoreSourceInstanceFactory: (source: ActionContextStoreSource) => DbxActionContextStoreSourceInstance<unknown, unknown>;
-export declare const actionContextStoreSourceMachineFactory: () => DbxActionContextMachineAsService<unknown, unknown>;
+import { ActionContextStoreSource, SecondaryActionContextStoreSource } from './action.store.source';
 /**
  * Provides an ActionContextStoreSource, as well as an DbxActionContextStoreSourceInstance.
  */

package/lib/action/directive/auto/action.automodify.directive.d.ts

@@ -1,13 +1,11 @@
-import { OnInit, OnDestroy } from '@angular/core';
-import { AbstractSubscriptionDirective } from '../../../subscription';
 import { Observable } from 'rxjs';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import * as i0 from "@angular/core";
-export declare class DbxActionAutoModifyDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+export declare class DbxActionAutoModifyDirective<T, O> {
     readonly source: DbxActionContextStoreSourceInstance<T, O>;
     readonly autoModifyEnabled: import("@angular/core").InputSignalWithTransform<boolean, string | boolean>;
     readonly markAsModified$: Observable<void>;
-    ngOnInit(): void;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionAutoModifyDirective<any, any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionAutoModifyDirective<any, any>, "dbxActionAutoModify, [dbxActionAutoModify]", never, { "autoModifyEnabled": { "alias": "dbxActionAutoModify"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/auto/action.autotrigger.directive.d.ts

@@ -1,5 +1,4 @@
-import { OnInit, OnDestroy, Signal } from '@angular/core';
-import { AbstractSubscriptionDirective } from '../../../subscription';
+import { Signal } from '@angular/core';
 import { Observable } from 'rxjs';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import { type Maybe } from '@dereekb/util';
@@ -9,7 +8,7 @@ import * as i0 from "@angular/core";
  *
  * When using auto triggers be sure to make sure that the action is not triggering too often due to misconfiguration.
  */
-export declare class DbxActionAutoTriggerDirective<T = unknown, O = unknown> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+export declare class DbxActionAutoTriggerDirective<T = unknown, O = unknown> {
     readonly source: DbxActionContextStoreSourceInstance<T, O>;
     readonly triggerDebounce: import("@angular/core").InputSignal<Maybe<number>>;
     readonly triggerThrottle: import("@angular/core").InputSignal<Maybe<number>>;
@@ -31,8 +30,7 @@ export declare class DbxActionAutoTriggerDirective<T = unknown, O = unknown> ext
     private readonly _isTriggerLimited$;
     readonly isTriggerAllowedToRun$: Observable<boolean>;
     readonly automaticTrigger$: Observable<void>;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionAutoTriggerDirective<any, any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionAutoTriggerDirective<any, any>, "dbxActionAutoTrigger,[dbxActionAutoTrigger]", never, { "triggerDebounce": { "alias": "triggerDebounce"; "required": false; "isSignal": true; }; "triggerThrottle": { "alias": "triggerThrottle"; "required": false; "isSignal": true; }; "triggerErrorThrottle": { "alias": "triggerErrorThrottle"; "required": false; "isSignal": true; }; "maxErrorsForThrottle": { "alias": "maxErrorsForThrottle"; "required": false; "isSignal": true; }; "triggerLimit": { "alias": "triggerLimit"; "required": false; "isSignal": true; }; "triggerEnabled": { "alias": "dbxActionAutoTrigger"; "required": false; "isSignal": true; }; "useFastTriggerPreset": { "alias": "useFastTriggerPreset"; "required": false; "isSignal": true; }; "useInstantTriggerPreset": { "alias": "useInstantTriggerPreset"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

@@ -1,12 +1,10 @@
-import { OnDestroy } from '@angular/core';
 import { DbxActionContextBaseSource } from '../../action.holder';
 import * as i0 from "@angular/core";
 /**
  * Provides an DbxActionContext.
  */
-export declare class DbxActionDirective<T = unknown, O = unknown> extends DbxActionContextBaseSource<T, O> implements OnDestroy {
+export declare class DbxActionDirective<T = unknown, O = unknown> extends DbxActionContextBaseSource<T, O> {
     constructor();
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionDirective<any, any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDirective<any, any>, "dbx-action,[dbxAction],dbx-action-context,[dbxActionContext]", ["action", "dbxAction"], {}, {}, never, never, true, never>;
 }

package/lib/action/directive/debug/action.logger.directive.d.ts

@@ -1,13 +1,11 @@
-import { OnInit } from '@angular/core';
-import { AbstractSubscriptionDirective } from '../../../subscription';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import * as i0 from "@angular/core";
 /**
  * Prints out the current state to the console. Useful for debugging.
  */
-export declare class DbxActionContextLoggerDirective extends AbstractSubscriptionDirective implements OnInit {
+export declare class DbxActionContextLoggerDirective {
     readonly source: DbxActionContextStoreSourceInstance<any, any>;
-    ngOnInit(): void;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionContextLoggerDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionContextLoggerDirective, "[dbxActionLogger],[dbxActionContextLogger]", never, {}, {}, never, never, true, never>;
 }

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

@@ -1,4 +1,3 @@
-import { OnDestroy } from '@angular/core';
 import { ActionContextStoreSourceMap } from './action.map';
 import * as i0 from "@angular/core";
 /**
@@ -6,9 +5,8 @@ import * as i0 from "@angular/core";
  *
  * This is useful for passing action contexts around via the providers instead of explicit injection.
  */
-export declare class DbxActionContextMapDirective implements OnDestroy {
+export declare class DbxActionContextMapDirective {
     readonly actionContextStoreSourceMap: ActionContextStoreSourceMap<any, any>;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionContextMapDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionContextMapDirective, "[dbxActionContextMap]", ["actionMap"], {}, {}, never, never, true, never>;
 }

package/lib/action/directive/map/action.map.working.disable.directive.d.ts

@@ -1,19 +1,16 @@
-import { OnInit, OnDestroy } from '@angular/core';
 import { type Maybe } from '@dereekb/util';
-import { AbstractSubscriptionDirective } from '../../../subscription';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import * as i0 from "@angular/core";
 export declare const DEFAULT_ACTION_MAP_WORKING_DISABLED_KEY = "action_map_working_disable";
 /**
  * Used to communicate with an dbxActionMap and set the ActionContextStore to be disabled if any other element in the map is working.
  */
-export declare class DbxActionMapWorkingDisableDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+export declare class DbxActionMapWorkingDisableDirective {
     private readonly _actionContextStoreSourceMap;
     readonly source: DbxActionContextStoreSourceInstance<any, any>;
     readonly disabledKey: import("@angular/core").InputSignal<Maybe<string>>;
     readonly areAnySourcesWorking$: import("rxjs").Observable<boolean>;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionMapWorkingDisableDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionMapWorkingDisableDirective, "[dbxActionMapWorkingDisable]", never, { "disabledKey": { "alias": "dbxActionMapWorkingDisable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/state/action.disabled.directive.d.ts

@@ -1,18 +1,15 @@
-import { OnDestroy } from '@angular/core';
 import { type Maybe } from '@dereekb/util';
-import { AbstractSubscriptionDirective } from '../../../subscription';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import * as i0 from "@angular/core";
 export declare const APP_ACTION_DISABLED_DIRECTIVE_KEY = "dbx_action_disabled";
 /**
  * Directive that allows disabling an action using the inputs.
  */
-export declare class DbxActionDisabledDirective<T, O> extends AbstractSubscriptionDirective implements OnDestroy {
+export declare class DbxActionDisabledDirective<T, O> {
     readonly source: DbxActionContextStoreSourceInstance<T, O>;
     readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, Maybe<boolean | "">>;
     readonly disabled$: import("rxjs").Observable<boolean>;
     constructor();
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionDisabledDirective<any, any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDisabledDirective<any, any>, "[dbxActionDisabled]", never, { "disabled": { "alias": "dbxActionDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/state/action.disableonsuccess.directive.d.ts

@@ -1,18 +1,15 @@
-import { OnDestroy } from '@angular/core';
 import { type Maybe } from '@dereekb/util';
-import { AbstractSubscriptionDirective } from '../../../subscription';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import * as i0 from "@angular/core";
 export declare const APP_ACTION_DISABLED_ON_SUCCESS_DIRECTIVE_KEY = "dbx_action_disabled_on_success";
 /**
  * Directive that will disable the action after the action completes successfully.
  */
-export declare class DbxActionDisabledOnSuccessDirective<T, O> extends AbstractSubscriptionDirective implements OnDestroy {
+export declare class DbxActionDisabledOnSuccessDirective<T, O> {
     readonly source: DbxActionContextStoreSourceInstance<T, O>;
     readonly disabledOnSuccess: import("@angular/core").InputSignalWithTransform<boolean, Maybe<boolean | "">>;
     readonly disabledOnSuccess$: import("rxjs").Observable<boolean>;
     constructor();
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionDisabledOnSuccessDirective<any, any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDisabledOnSuccessDirective<any, any>, "[dbxActionDisabledOnSuccess]", never, { "disabledOnSuccess": { "alias": "dbxActionDisabledOnSuccess"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/state/action.enforce.modified.directive.d.ts

@@ -1,18 +1,15 @@
-import { OnInit, OnDestroy } from '@angular/core';
 import { type Maybe } from '@dereekb/util';
-import { AbstractSubscriptionDirective } from '../../../subscription';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import * as i0 from "@angular/core";
 export declare const APP_ACTION_ENFORCE_MODIFIED_DIRECTIVE_KEY = "dbx_action_enforce_modified";
 /**
  * Directive that toggles disabling an action if the action is not marked modified.
  */
-export declare class DbxActionEnforceModifiedDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+export declare class DbxActionEnforceModifiedDirective {
     readonly source: DbxActionContextStoreSourceInstance<any, any>;
     readonly enabled: import("@angular/core").InputSignalWithTransform<boolean, Maybe<boolean | "">>;
     readonly enabled$: import("rxjs").Observable<boolean>;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionEnforceModifiedDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionEnforceModifiedDirective, "[dbxActionEnforceModified]", never, { "enabled": { "alias": "dbxActionEnforceModified"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/state/action.error.handler.directive.d.ts

@@ -1,6 +1,4 @@
-import { OnInit, OnDestroy } from '@angular/core';
 import { ReadableError, type Maybe } from '@dereekb/util';
-import { AbstractSubscriptionDirective } from '../../../subscription';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import * as i0 from "@angular/core";
 /**
@@ -10,11 +8,11 @@ export type DbxActionErrorHandlerFunction = (error?: Maybe<ReadableError>) => vo
 /**
  * Directive that executes a function on ActionContextStore error.
  */
-export declare class DbxActionErrorHandlerDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+export declare class DbxActionErrorHandlerDirective<T, O> {
     readonly source: DbxActionContextStoreSourceInstance<T, O>;
     readonly dbxActionErrorHandler: import("@angular/core").InputSignal<Maybe<DbxActionErrorHandlerFunction>>;
     readonly errorFunction$: import("rxjs").Observable<DbxActionErrorHandlerFunction>;
-    ngOnInit(): void;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionErrorHandlerDirective<any, any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionErrorHandlerDirective<any, any>, "[dbxActionErrorHandler]", never, { "dbxActionErrorHandler": { "alias": "dbxActionErrorHandler"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/state/action.handler.directive.d.ts

@@ -1,4 +1,3 @@
-import { OnDestroy } from '@angular/core';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import { FactoryWithInput, GetterOrValue, type Maybe } from '@dereekb/util';
 import { DbxActionHandlerInstance } from './action.handler.instance';
@@ -7,11 +6,10 @@ import * as i0 from "@angular/core";
 /**
  * Abstract directive that wraps and handles a DbxActionHandlerInstance lifecycle.
  */
-export declare abstract class AbstractDbxActionHandlerDirective<T = unknown, O = unknown> implements OnDestroy {
+export declare abstract class AbstractDbxActionHandlerDirective<T = unknown, O = unknown> {
     readonly source: DbxActionContextStoreSourceInstance<T, O>;
     protected readonly _dbxActionHandlerInstance: DbxActionHandlerInstance<T, O>;
     constructor();
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxActionHandlerDirective<any, any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxActionHandlerDirective<any, any>, never, never, {}, {}, never, never, false, never>;
 }

package/lib/action/directive/state/action.success.directive.d.ts

@@ -1,4 +1,3 @@
-import { OnDestroy } from '@angular/core';
 import { type Maybe } from '@dereekb/util';
 import { AbstractIfDirective } from '../../../view/if.directive';
 import * as i0 from "@angular/core";
@@ -7,7 +6,7 @@ import * as i0 from "@angular/core";
  *
  * Can be configured to show for a temporary period.
  */
-export declare class DbxActionHasSuccessDirective extends AbstractIfDirective implements OnDestroy {
+export declare class DbxActionHasSuccessDirective extends AbstractIfDirective {
     private readonly _store;
     readonly hideAfter: import("@angular/core").InputSignalWithTransform<Maybe<number>, "" | Maybe<number>>;
     readonly show$: import("rxjs").Observable<boolean>;

package/lib/action/directive/state/action.success.handler.directive.d.ts

@@ -1,6 +1,4 @@
-import { OnInit, OnDestroy } from '@angular/core';
 import { type Maybe } from '@dereekb/util';
-import { AbstractSubscriptionDirective } from '../../../subscription';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import * as i0 from "@angular/core";
 /**
@@ -10,11 +8,11 @@ export type DbxActionSuccessHandlerFunction<O = unknown> = (value: O) => void;
 /**
  * Directive that executes a function on ActionContextStore Success.
  */
-export declare class DbxActionSuccessHandlerDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+export declare class DbxActionSuccessHandlerDirective<T, O> {
     readonly source: DbxActionContextStoreSourceInstance<T, O>;
     readonly dbxActionSuccessHandler: import("@angular/core").InputSignal<Maybe<DbxActionSuccessHandlerFunction<O>>>;
     readonly successFunction$: import("rxjs").Observable<DbxActionSuccessHandlerFunction<O>>;
-    ngOnInit(): void;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionSuccessHandlerDirective<any, any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionSuccessHandlerDirective<any, any>, "[dbxActionSuccessHandler]", never, { "dbxActionSuccessHandler": { "alias": "dbxActionSuccessHandler"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/state/action.value.directive.d.ts

@@ -1,7 +1,5 @@
-import { OnInit, OnDestroy } from '@angular/core';
 import { Maybe, GetterOrValue } from '@dereekb/util';
 import { Observable } from 'rxjs';
-import { AbstractSubscriptionDirective } from '../../../subscription';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import * as i0 from "@angular/core";
 /**
@@ -13,15 +11,13 @@ import * as i0 from "@angular/core";
  *
  * Use a getter if null/undefined values should be passed to the action.
  */
-export declare class DbxActionValueDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+export declare class DbxActionValueDirective<T, O> {
     readonly valueOrFunction: import("@angular/core").InputSignal<Maybe<"" | GetterOrValue<T>>>;
     readonly source: DbxActionContextStoreSourceInstance<T, O>;
     private readonly _valueOrFunctionOverride;
     readonly valueOrFunction$: Observable<GetterOrValue<T>>;
     constructor();
-    ngOnInit(): void;
     setValueOrFunction(value: Maybe<GetterOrValue<T>>): void;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionValueDirective<any, any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionValueDirective<any, any>, "dbxActionValue,[dbxActionValue]", never, { "valueOrFunction": { "alias": "dbxActionValue"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/state/action.value.stream.directive.d.ts

@@ -1,23 +1,19 @@
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import { Observable } from 'rxjs';
-import { OnInit, OnDestroy } from '@angular/core';
 import { Maybe } from '@dereekb/util';
 import { IsEqualFunction, IsModifiedFunction } from '@dereekb/rxjs';
 import * as i0 from "@angular/core";
 /**
  * Directive that watches a value observable for changes and sets the new value and modified states as necessary.
  */
-export declare class DbxActionValueStreamDirective<T, O> implements OnInit, OnDestroy {
+export declare class DbxActionValueStreamDirective<T, O> {
     readonly source: DbxActionContextStoreSourceInstance<T, O>;
     readonly dbxActionValueStream: import("@angular/core").InputSignal<Observable<T>>;
     readonly dbxActionValueStreamIsEqualValue: import("@angular/core").InputSignal<Maybe<IsEqualFunction<T>>>;
     readonly dbxActionValueStreamIsModifiedValue: import("@angular/core").InputSignal<Maybe<IsModifiedFunction<T>>>;
-    private readonly _modifiedSub;
-    private readonly _triggerSub;
     readonly isModifiedFunction$: Observable<IsModifiedFunction<T>>;
     readonly modifiedValue$: Observable<[boolean, T]>;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionValueStreamDirective<any, any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionValueStreamDirective<any, any>, "[dbxActionValueStream]", never, { "dbxActionValueStream": { "alias": "dbxActionValueStream"; "required": false; "isSignal": true; }; "dbxActionValueStreamIsEqualValue": { "alias": "dbxActionValueStreamIsEqualValue"; "required": false; "isSignal": true; }; "dbxActionValueStreamIsModifiedValue": { "alias": "dbxActionValueStreamIsModifiedValue"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/state/action.value.trigger.directive.d.ts

@@ -1,4 +1,4 @@
-import { OnDestroy, OnInit, Signal } from '@angular/core';
+import { Signal } from '@angular/core';
 import { IsEqualFunction, IsModifiedFunction } from '@dereekb/rxjs';
 import { type Maybe } from '@dereekb/util';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
@@ -12,12 +12,11 @@ export interface DbxActionValueGetterDirectiveComputeInputsConfig<T> {
 /**
  * Abstract class for directives that may perform an action when trigger is called, and returns a value.
  */
-export declare abstract class AbstractDbxActionValueGetterDirective<T> implements OnInit, OnDestroy {
+export declare abstract class AbstractDbxActionValueGetterDirective<T> {
     private readonly _injector;
     readonly source: DbxActionContextStoreSourceInstance<T, unknown>;
     private readonly _triggerInstance;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
+    constructor();
     setValueGetterFunction(valueGetterFunction: Maybe<DbxActionValueGetterValueGetterFunction<T>>): void;
     protected configureInputs(config: DbxActionValueGetterDirectiveComputeInputsConfig<T>): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxActionValueGetterDirective<any>, never>;
@@ -29,7 +28,7 @@ export declare abstract class AbstractDbxActionValueGetterDirective<T> implement
  * Similar to DbxActionValueDirective, but the getter is called when a trigger is activated.
  * The DbxActionValueDirective always pipes the latests value while waiting for a trigger, and does not allow using a getter.
  */
-export declare class DbxActionValueTriggerDirective<T = object> extends AbstractDbxActionValueGetterDirective<T> implements OnDestroy {
+export declare class DbxActionValueTriggerDirective<T = object> extends AbstractDbxActionValueGetterDirective<T> {
     readonly dbxActionValueGetter: import("@angular/core").InputSignal<Maybe<DbxActionValueGetterValueGetterFunction<T>>>;
     readonly dbxActionValueGetterIsModified: import("@angular/core").InputSignal<Maybe<IsModifiedFunction>>;
     readonly dbxActionValueGetterIsEqual: import("@angular/core").InputSignal<Maybe<IsEqualFunction>>;

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

@@ -1,14 +1,10 @@
-import { OnInit, OnDestroy } from '@angular/core';
 import { DbxActionButtonTriggerDirective } from './action.button.trigger.directive';
 import * as i0 from "@angular/core";
 /**
  * Context used for linking a button to an ActionContext.
  */
-export declare class DbxActionButtonDirective extends DbxActionButtonTriggerDirective implements OnInit, OnDestroy {
-    private readonly _workingSub;
-    private readonly _disabledSub;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
+export declare class DbxActionButtonDirective extends DbxActionButtonTriggerDirective {
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionButtonDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionButtonDirective, "[dbxActionButton]", never, {}, {}, never, never, true, never>;
 }

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

@@ -1,15 +1,13 @@
-import { OnInit } from '@angular/core';
-import { AbstractSubscriptionDirective } from '../../subscription/subscription.directive';
 import { DbxButton } from '../button';
 import { DbxActionContextStoreSourceInstance } from '../../action/action.store.source';
 import * as i0 from "@angular/core";
 /**
  * Context used for linking a button to an ActionContext and only look for triggers.
  */
-export declare class DbxActionButtonTriggerDirective extends AbstractSubscriptionDirective implements OnInit {
+export declare class DbxActionButtonTriggerDirective {
     readonly dbxButton: DbxButton;
     readonly source: DbxActionContextStoreSourceInstance<any, any>;
-    ngOnInit(): void;
+    constructor();
     protected _buttonClicked(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionButtonTriggerDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionButtonTriggerDirective, "[dbxActionButtonTrigger]", never, {}, {}, never, never, true, never>;

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

@@ -1,13 +1,12 @@
-import { OnDestroy, OnInit, Signal } from '@angular/core';
+import { Signal } from '@angular/core';
 import { type Maybe } from '@dereekb/util';
 import { Subject, BehaviorSubject } from 'rxjs';
-import { AbstractSubscriptionDirective } from '../subscription';
 import { DbxButton, DbxButtonDisplay, DbxButtonDisplayType, DbxButtonInterceptor, DbxButtonWorking } from './button';
 import * as i0 from "@angular/core";
 /**
  * Abstract button component.
  */
-export declare abstract class AbstractDbxButtonDirective extends AbstractSubscriptionDirective implements DbxButton, OnInit, OnDestroy {
+export declare abstract class AbstractDbxButtonDirective implements DbxButton {
     /**
      * Pre-interceptor button click.
      */
@@ -33,8 +32,7 @@ export declare abstract class AbstractDbxButtonDirective extends AbstractSubscri
     readonly working$: import("rxjs").Observable<import("@dereekb/dbx-core").DbxActionWorkOrWorkProgress>;
     readonly display$: import("rxjs").Observable<DbxButtonDisplay>;
     readonly clicked$: import("rxjs").Observable<void>;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
+    constructor();
     setDisabled(disabled?: Maybe<boolean>): void;
     setWorking(working?: Maybe<DbxButtonWorking>): void;
     setDisplayContent(content: DbxButtonDisplay): void;

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

@@ -1,5 +1,4 @@
 import { LoadingContext, MaybeObservableOrValue } from '@dereekb/rxjs';
-import { AbstractSubscriptionDirective } from '../subscription/subscription.directive';
 import { DbxButton } from './button';
 import * as i0 from "@angular/core";
 /**
@@ -7,11 +6,12 @@ import * as i0 from "@angular/core";
  *
  * It will be set working when the context is set loading.
  */
-export declare class DbxLoadingButtonDirective extends AbstractSubscriptionDirective {
+export declare class DbxLoadingButtonDirective {
     readonly dbxButton: DbxButton;
     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 _loadingEffectSub: import("@dereekb/rxjs").SubscriptionObject<import("rxjs").Unsubscribable>;
     protected readonly _loadingEffect: import("@angular/core").EffectRef;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxLoadingButtonDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxLoadingButtonDirective, "[dbxLoadingButton]", never, { "context": { "alias": "dbxLoadingButton"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;

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

@@ -1,10 +1,9 @@
 import { type Maybe } from '@dereekb/util';
-import { AbstractSubscriptionDirective } from '../../subscription/subscription.directive';
 import { DbxButton } from '../button';
 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 {
+export declare class DbxButtonSegueDirective {
     readonly dbxButton: DbxButton;
     readonly dbxRouterService: DbxRouterService;
     readonly segueRef: import("@angular/core").InputSignal<Maybe<SegueRef<object>>>;

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

@@ -1,14 +1,12 @@
 import { Observable } from 'rxjs';
-import { OnDestroy } from '@angular/core';
 import { FilterSourceConnector, FilterSource } from '@dereekb/rxjs';
 import * as i0 from "@angular/core";
 /**
  * Abstract FilterSourceConnector directive.
  */
-export declare abstract class AbstractFilterSourceConnectorDirective<F> implements FilterSourceConnector<F>, FilterSource<F>, OnDestroy {
+export declare abstract class AbstractFilterSourceConnectorDirective<F> implements FilterSourceConnector<F>, FilterSource<F> {
     private readonly _source;
     readonly filter$: Observable<F>;
-    ngOnDestroy(): void;
     connectWithSource(filterSource: FilterSource<F>): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractFilterSourceConnectorDirective<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractFilterSourceConnectorDirective<any>, never, never, {}, {}, never, never, false, never>;

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

@@ -1,12 +1,10 @@
-import { OnDestroy } from '@angular/core';
 import { FilterMap } from '@dereekb/rxjs';
 import * as i0 from "@angular/core";
 /**
  * Direction that provides a FilterMap.
  */
-export declare class DbxFilterMapDirective<F> implements OnDestroy {
+export declare class DbxFilterMapDirective<F> {
     readonly filterMap: FilterMap<any>;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxFilterMapDirective<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterMapDirective<any>, "[dbxFilterMap]", ["dbxFilterMap"], {}, {}, never, never, true, never>;
 }

package/lib/index.d.ts

@@ -9,6 +9,6 @@ export * from './filter';
 export * from './injection';
 export * from './ngrx';
 export * from './storage';
-export * from './subscription';
+export * from './rxjs';
 export * from './util';
 export * from './view';

package/lib/injection/injection.d.ts

@@ -20,6 +20,8 @@ export interface DbxInjectionComponentConfig<T = unknown> {
     readonly ngModuleRef?: NgModuleRef<unknown>;
     /**
      * (Optional) Custom initialization code when an instance is created.
+     *
+     * This is called in an Angular injection context of the created component, so that inject() is available and will be destroyed when the created component is destroyed.
      */
     readonly init?: Maybe<(instance: T) => void>;
     /**

package/lib/router/model/model.router.id.directive.d.ts

@@ -1,22 +1,19 @@
 import { Observable } from 'rxjs';
-import { OnDestroy, OnInit } from '@angular/core';
 import { Maybe, ModelKey } from '@dereekb/util';
 import { MaybeObservableOrValueGetter, SwitchMapToDefaultFilterFunction } from '@dereekb/rxjs';
-import { AbstractSubscriptionDirective } from '../../subscription/subscription.directive';
 import { DbxRouterService } from '../router/service/router.service';
 import { DbxRouteModelIdDirectiveDelegate } from './model.router';
 import * as i0 from "@angular/core";
 /**
  * Used for retrieving the model's id from the current route using the configured parameter and passes it to its delegate.
  */
-export declare class DbxRouteModelIdDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+export declare class DbxRouteModelIdDirective {
     readonly dbxRouterService: DbxRouterService;
     readonly dbxRouteModelIdDelegate: DbxRouteModelIdDirectiveDelegate;
     private readonly _redirectInstance;
     readonly idFromParams$: Observable<Maybe<ModelKey>>;
     readonly id$: Observable<Maybe<ModelKey>>;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
+    constructor();
     get idParam(): string;
     set idParam(idParam: string);
     set dbxRouteModelIdDefault(defaultValue: MaybeObservableOrValueGetter<ModelKey>);

package/lib/router/model/model.router.key.directive.d.ts

@@ -1,8 +1,6 @@
 import { Observable } from 'rxjs';
-import { OnDestroy, OnInit } from '@angular/core';
 import { Maybe, ModelKey } from '@dereekb/util';
 import { MaybeObservableOrValueGetter, SwitchMapToDefaultFilterFunction } from '@dereekb/rxjs';
-import { AbstractSubscriptionDirective } from '../../subscription/subscription.directive';
 import { DbxRouterService } from '../router/service/router.service';
 import { DbxRouteModelKeyDirectiveDelegate } from './model.router';
 import * as i0 from "@angular/core";
@@ -11,14 +9,13 @@ import * as i0 from "@angular/core";
  *
  * If the key does not exist in the params, then the p
  */
-export declare class DbxRouteModelKeyDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+export declare class DbxRouteModelKeyDirective {
     readonly dbxRouterService: DbxRouterService;
     readonly dbxRouteModelKeyDelegate: DbxRouteModelKeyDirectiveDelegate;
     private readonly _redirectInstance;
     readonly keyFromParams$: Observable<Maybe<ModelKey>>;
     readonly key$: Observable<Maybe<ModelKey>>;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
+    constructor();
     get keyParam(): string;
     set keyParam(idParam: string);
     set dbxRouteModelKeyDefault(defaultValue: MaybeObservableOrValueGetter<ModelKey>);

package/lib/router/model/model.router.uid.directive.d.ts

@@ -1,15 +1,13 @@
-import { OnInit } from '@angular/core';
 import { DbxRouteModelIdDirectiveDelegate } from './model.router';
 import { DbxAuthService } from '../../auth';
-import { AbstractSubscriptionDirective } from '../../subscription/subscription.directive';
 import * as i0 from "@angular/core";
 /**
  * Used for retrieving the user's current id DbxAuthService and passes it as an identifier for a DbxRouteModelIdDirectiveDelegate.
  */
-export declare class DbxRouteModelIdFromAuthUserIdDirective extends AbstractSubscriptionDirective implements OnInit {
+export declare class DbxRouteModelIdFromAuthUserIdDirective {
     readonly dbxAuthService: DbxAuthService;
     readonly dbxRouteModelIdDelegate: DbxRouteModelIdDirectiveDelegate;
-    ngOnInit(): void;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxRouteModelIdFromAuthUserIdDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxRouteModelIdFromAuthUserIdDirective, "[dbxRouteModelIdFromAuthUserId]", never, {}, {}, never, never, true, never>;
 }