@dereekb/dbx-core 10.1.30 → 11.0.0

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

@@ -8,8 +8,13 @@ import * as i0 from "@angular/core";
  * Abstract button component.
  */
 export declare abstract class AbstractDbxButtonDirective extends AbstractSubscriptionDirective implements DbxButton, OnInit, OnDestroy {
-    private _disabled;
-    private _working;
+    private readonly _disabled;
+    private readonly _working;
+    /**
+     * Pre-interceptor button click.
+     */
+    protected readonly _buttonClick: Subject<void>;
+    protected readonly _buttonInterceptor: BehaviorSubject<Maybe<DbxButtonInterceptor>>;
     readonly disabled$: import("rxjs").Observable<boolean>;
     readonly working$: import("rxjs").Observable<boolean>;
     get disabled(): boolean;
@@ -23,12 +28,6 @@ export declare abstract class AbstractDbxButtonDirective extends AbstractSubscri
     get buttonDisplayType(): DbxButtonDisplayContentType;
     readonly buttonClick: EventEmitter<any>;
     readonly clicked$: import("rxjs").Observable<any>;
-    constructor();
-    /**
-     * Pre-interceptor button click.
-     */
-    protected _buttonClick: Subject<void>;
-    protected _buttonInterceptor: BehaviorSubject<Maybe<DbxButtonInterceptor>>;
     ngOnInit(): void;
     ngOnDestroy(): void;
     /**

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

@@ -9,13 +9,12 @@ import * as i0 from "@angular/core";
  * It will be set working when the context is set loading.
  */
 export declare class DbxLoadingButtonDirective extends AbstractSubscriptionDirective {
-    readonly button: DbxButton;
+    readonly dbxButton: DbxButton;
     readonly ngZone: NgZone;
-    constructor(button: DbxButton, ngZone: NgZone);
     /**
      * Sets a LoadingContext that is watched for the loading state.
      */
     set context(context: LoadingContext);
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxLoadingButtonDirective, [{ host: true; }, null]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxLoadingButtonDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxLoadingButtonDirective, "[dbxLoadingButton]", never, { "context": { "alias": "dbxLoadingButton"; "required": false; }; }, {}, never, never, false, never>;
 }

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

@@ -7,11 +7,10 @@ import * as i0 from "@angular/core";
 export declare class DbxButtonSegueDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
     readonly dbxButton: DbxButton;
     readonly dbxRouterService: DbxRouterService;
-    private _segueRef;
+    private readonly _segueRef;
     readonly segueRef$: import("rxjs").Observable<SegueRef<object>>;
     get segueRef(): Maybe<SegueRef>;
     set segueRef(segueRef: Maybe<SegueRef>);
-    constructor(dbxButton: DbxButton, dbxRouterService: DbxRouterService);
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxButtonSegueDirective, never>;

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

@@ -9,8 +9,8 @@ import * as i0 from "@angular/core";
  */
 export declare class DbxAppContextStateDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
     readonly dbxAppContextStateService: DbxAppContextService;
-    private _state;
-    constructor(dbxAppContextStateService: DbxAppContextService);
+    private readonly _state;
+    constructor();
     ngOnInit(): void;
     ngOnDestroy(): void;
     set state(state: Maybe<DbxAppContextState>);

package/lib/context/context.service.d.ts

@@ -1,14 +1,12 @@
 import { Store } from '@ngrx/store';
 import { DbxAppContextState } from './context';
-import { DbxAppContextFullState } from './state/state';
 import * as i0 from "@angular/core";
 /**
  * State for accessing the app's DbxAppContextState defined within the DbxAppContextFullState for the ngrx store.
  */
 export declare class DbxAppContextService {
-    readonly store: Store<DbxAppContextFullState>;
+    readonly store: Store<any>;
     readonly state$: import("rxjs").Observable<string>;
-    constructor(store: Store<DbxAppContextFullState>);
     setState(state: DbxAppContextState): void;
     resetState(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxAppContextService, never>;

package/lib/context/state/effect/index.d.ts

@@ -2,33 +2,18 @@ import { OnRunEffects, Actions, EffectNotification } from '@ngrx/effects';
 import { Store } from '@ngrx/store';
 import { Observable } from 'rxjs';
 import { DbxAppContextState } from '../../context';
-import { ArrayOrValue } from '@dereekb/util';
+import { IterableOrValue } from '@dereekb/util';
 /**
  * Abstract effects class that only runs/allows effects when the DbxAppContextState in the ngrx state matches input activeState value.
  */
 export declare abstract class AbstractOnDbxAppContextStateEffects<S = unknown> implements OnRunEffects {
+    protected readonly actions$: Actions<any>;
+    protected readonly store: Store<any>;
     /**
-     * ngrx Actions
+     * The set of state(s) to activate on.
      */
-    protected readonly actions$: Actions;
-    /**
-     * ngrx Store
-     */
-    protected readonly store: Store<S>;
     private _activeStatesSet;
-    constructor(
-    /**
-     * The state(s) to activate on.
-     */
-    activeStates: ArrayOrValue<DbxAppContextState>, 
-    /**
-     * ngrx Actions
-     */
-    actions$: Actions, 
-    /**
-     * ngrx Store
-     */
-    store: Store<S>);
+    constructor(activeStates: IterableOrValue<DbxAppContextState>);
     /**
      * Configures all actions of the sub-class to only activate when the DbxAppContextState in App
      *

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

@@ -5,10 +5,9 @@ import * as i0 from "@angular/core";
  * Connects the host FilterSource to a FilterSourceConnector.
  */
 export declare class DbxFilterConnectSourceDirective<F = unknown> implements OnInit {
-    readonly filterSource: FilterSource<F>;
-    readonly filterSourceConnector: FilterSourceConnector<F>;
-    constructor(filterSource: FilterSource<F>, filterSourceConnector: FilterSourceConnector<F>);
+    readonly filterSource: FilterSource<any>;
+    readonly filterSourceConnector: FilterSourceConnector<any>;
     ngOnInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFilterConnectSourceDirective<any>, [{ host: true; }, null]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFilterConnectSourceDirective<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterConnectSourceDirective<any>, "[dbxFilterConnectSource]", never, {}, {}, never, never, false, never>;
 }

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

@@ -5,8 +5,7 @@ import * as i0 from "@angular/core";
  * Direction that provides an FilterMap.
  */
 export declare class DbxFilterMapDirective<F> implements OnDestroy {
-    readonly filterMap: FilterMap<F>;
-    constructor(filterMap: FilterMap<F>);
+    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>;

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

@@ -7,11 +7,10 @@ import * as i0 from "@angular/core";
  * Provides a FilterSource from a parent FilterMap.
  */
 export declare abstract class AbstractDbxFilterMapInstanceDirective<F> implements OnDestroy {
-    readonly dbxFilterMap: FilterMap<F>;
     protected _key: BehaviorSubject<Maybe<string>>;
+    readonly dbxFilterMap: FilterMap<any>;
     readonly key$: import("rxjs").Observable<string>;
-    readonly instance$: import("rxjs").Observable<import("@dereekb/rxjs").FilterMapKeyInstance<F>>;
-    constructor(dbxFilterMap: FilterMap<F>);
+    readonly instance$: import("rxjs").Observable<import("@dereekb/rxjs").FilterMapKeyInstance<any>>;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxFilterMapInstanceDirective<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxFilterMapInstanceDirective<any>, never, never, {}, {}, never, never, false, never>;

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

@@ -9,7 +9,6 @@ export declare class DbxInjectionArrayComponent implements OnDestroy {
     private _entries;
     readonly entries$: import("rxjs").Observable<DbxInjectionArrayEntry<unknown>[]>;
     readonly trackByKeyFn: TrackByFunction<DbxInjectionArrayEntry>;
-    constructor();
     ngOnDestroy(): void;
     get entries(): DbxInjectionArrayEntry[];
     set entries(entries: Maybe<DbxInjectionArrayEntry[]>);

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

@@ -1,4 +1,4 @@
-import { Injector, TemplateRef, ViewContainerRef, OnDestroy, OnInit } from '@angular/core';
+import { OnDestroy, OnInit } from '@angular/core';
 import { DbxInjectionContext, DbxInjectionContextConfig } from './injection.context';
 import { DbxInjectionComponentConfig } from './injection';
 import { Maybe } from '@dereekb/util';
@@ -14,7 +14,6 @@ export declare class DbxInjectionContextDirective<O = unknown> implements DbxInj
     private _instance;
     private _embeddedView;
     private _isDetached;
-    constructor(_injector: Injector, _templateRef: TemplateRef<O>, _viewContainer: ViewContainerRef);
     set config(config: Maybe<DbxInjectionComponentConfig<unknown>>);
     ngOnInit(): void;
     ngOnDestroy(): void;

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

@@ -8,9 +8,8 @@ import * as i0 from "@angular/core";
  */
 export declare abstract class AbstractForwardDbxInjectionContextDirective implements DbxInjectionContext {
     readonly dbxInjectionContext: DbxInjectionContext;
-    constructor(dbxInjectionContext: DbxInjectionContext);
     showContext<T = unknown, O = unknown>(config: DbxInjectionContextConfig<T, unknown>): Promise<O>;
     resetContext(): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractForwardDbxInjectionContextDirective, [{ host: true; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractForwardDbxInjectionContextDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractForwardDbxInjectionContextDirective, never, never, {}, {}, never, never, false, never>;
 }

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

@@ -1,4 +1,4 @@
-import { ViewContainerRef, OnInit, OnDestroy, Injector } from '@angular/core';
+import { ViewContainerRef, OnInit, OnDestroy } from '@angular/core';
 import { Maybe } from '@dereekb/util';
 import { DbxInjectionComponentConfig, DbxInjectionTemplateConfig } from './injection';
 import * as i0 from "@angular/core";
@@ -6,9 +6,7 @@ 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 readonly _injector;
     private _instance;
-    constructor(_injector: Injector);
     ngOnInit(): void;
     ngOnDestroy(): void;
     setConfig(config: Maybe<DbxInjectionComponentConfig<T>>): void;

package/lib/pipe/date/dateformatdistance.pipe.d.ts

@@ -6,7 +6,6 @@ import * as i0 from "@angular/core";
  */
 export declare class DateFormatDistancePipe implements PipeTransform {
     private locale;
-    constructor(locale: string);
     transform(input: Maybe<DateOrDateString>, format: string, includeSeconds?: boolean): Maybe<string>;
     static ɵfac: i0.ɵɵFactoryDeclaration<DateFormatDistancePipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<DateFormatDistancePipe, "dateFormatDistance", false>;

package/lib/pipe/date/datefromtoformat.pipe.d.ts

@@ -7,7 +7,6 @@ import * as i0 from "@angular/core";
 export declare class DateFromToTimePipe implements PipeTransform {
     private locale;
     static formatFromTo(input: Maybe<DateOrDateString>, format: string, minutes: number, locale: string): Maybe<string>;
-    constructor(locale: string);
     transform(input: Maybe<DateOrDateString>, format: string, minutes: number): Maybe<string>;
     static ɵfac: i0.ɵɵFactoryDeclaration<DateFromToTimePipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<DateFromToTimePipe, "dateFromPlusTo", false>;

package/lib/router/router/provider/angular/angular.router.service.d.ts

@@ -13,7 +13,6 @@ export declare class DbxAngularRouterService implements DbxRouterService, DbxRou
     readonly activatedRoute: ActivatedRoute;
     readonly params$: Observable<SegueRefRawSegueParams>;
     readonly transitions$: Observable<DbxRouterTransitionEvent>;
-    constructor(router: Router, activatedRoute: ActivatedRoute);
     go(input: ObservableOrValue<SegueRefOrSegueRefRouterLink<NavigationExtras | NavigationBehaviorOptions>>): Promise<boolean>;
     updateParams(inputParams: ObservableOrValue<SegueRefRawSegueParams>): Promise<boolean>;
     isActive(segueRef: SegueRefOrSegueRefRouterLink): boolean;

package/lib/router/router/provider/uirouter/uirouter.router.service.d.ts

@@ -17,7 +17,7 @@ export declare class DbxUIRouterService implements DbxRouterService, DbxRouterTr
     readonly params$: Observable<SegueRefRawSegueParams>;
     private readonly _transitions;
     readonly transitions$: Observable<DbxRouterTransitionEvent>;
-    constructor(state: StateService, transitionService: TransitionService, uiRouterGlobals: UIRouterGlobals);
+    constructor();
     ngOnDestroy(): void;
     get params(): import("@uirouter/core").StateParams;
     go(input: ObservableOrValue<SegueRefOrSegueRefRouterLink<TransitionOptions>>): Promise<boolean>;

package/lib/router/router/transition/transition.directive.d.ts

@@ -8,7 +8,6 @@ export declare abstract class AbstractTransitionDirective {
     protected readonly dbxRouterTransitionService: DbxRouterTransitionService;
     readonly transitionSuccess$: Observable<import("@dereekb/dbx-core").DbxRouterTransitionEvent>;
     readonly initAndUpdateOnTransitionSuccess$: Observable<void>;
-    constructor(dbxRouterTransitionService: DbxRouterTransitionService);
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractTransitionDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractTransitionDirective, never, never, {}, {}, never, never, false, never>;
 }

package/lib/router/router/transition/transition.watcher.directive.d.ts

@@ -1,16 +1,14 @@
 import { NgZone, OnDestroy, OnInit } from '@angular/core';
-import { DbxRouterTransitionService } from '../service/router.transition.service';
 import { AbstractTransitionDirective } from './transition.directive';
 import * as i0 from "@angular/core";
 /**
  * Abstract directive that listens to onSuccess transition events and runs a function.
  */
 export declare abstract class AbstractTransitionWatcherDirective extends AbstractTransitionDirective implements OnInit, OnDestroy {
-    protected readonly ngZone: NgZone;
     private _transitionSub;
+    protected readonly ngZone: NgZone;
     ngOnInit(): void;
     ngOnDestroy(): void;
-    constructor(dbxRouterTransitionService: DbxRouterTransitionService, ngZone: NgZone);
     protected zoneUpdateForSuccessfulTransition(): void;
     protected abstract updateForSuccessfulTransition(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractTransitionWatcherDirective, never>;

package/lib/router/router/util/route.reader.d.ts

@@ -19,10 +19,13 @@ export interface DbxRouteParamReader<T> {
      */
     readonly value$: Observable<Maybe<T>>;
     /**
-     * Param key getter/setters.
+     * Returns the current param key.
      */
-    get paramKey(): string;
-    set paramKey(paramKey: Maybe<string>);
+    getParamKey(): string;
+    /**
+     * Sets a new param key. If the value is undefined, the param reader will use the default key.
+     */
+    setParamKey(paramKey: Maybe<string>): void;
     /**
      * Sets the default value source.
      *
@@ -36,29 +39,18 @@ export interface DbxRouteParamReader<T> {
      */
     setParamValue(value: MaybeObservableOrValueGetter<T>): void;
 }
-/**
- * Utility class used for reading a single value from the DbxRouterService.
- */
-export declare class DbxRouteParamReaderInstance<T> implements DbxRouteParamReader<T>, Destroyable {
+export interface DbxRouteParamReaderInstance<T> extends DbxRouteParamReader<T>, Destroyable {
     readonly dbxRouterService: DbxRouterService;
-    readonly defaultParamKey: string;
-    readonly defaultValue?: MaybeObservableOrValueGetter<T>;
-    private _paramKey;
     readonly paramKey$: Observable<string>;
-    private _defaultValue;
-    readonly paramValue$: Observable<Maybe<T>>;
     readonly nextDefaultValue$: Observable<Maybe<T>>;
-    readonly defaultValue$: Observable<Maybe<T>>;
     readonly value$: Observable<Maybe<T>>;
-    constructor(dbxRouterService: DbxRouterService, defaultParamKey: string, defaultValue?: MaybeObservableOrValueGetter<T>);
-    destroy(): void;
-    get paramKey(): string;
-    set paramKey(paramKey: Maybe<string>);
-    setDefaultValue(defaultValue: MaybeObservableOrValueGetter<T>): void;
-    /**
-     * Convenience function to set the param value on the router.
-     *
-     * @param value
-     */
-    setParamValue(value: MaybeObservableOrValueGetter<T>): void;
 }
+/**
+ * Creates a new DbxRouteParamReaderInstance from the input.
+ *
+ * @param dbxRouterService
+ * @param defaultParamKey
+ * @param defaultValue
+ * @returns
+ */
+export declare function dbxRouteParamReaderInstance<T>(dbxRouterService: DbxRouterService, defaultParamKey: string, defaultValue?: MaybeObservableOrValueGetter<T>): DbxRouteParamReaderInstance<T>;

package/lib/storage/storage.accessor.simple.factory.d.ts

@@ -11,7 +11,6 @@ export interface StorageAccessorFactoryConfig<T> extends SimpleStorageAccessorCo
  */
 export declare class SimpleStorageAccessorFactory {
     readonly storageObject: FullStorageObject;
-    constructor(storageObject: FullStorageObject);
     createStorageAccessor<T>(config: StorageAccessorFactoryConfig<T>): SimpleStorageAccessor<T>;
     static ɵfac: i0.ɵɵFactoryDeclaration<SimpleStorageAccessorFactory, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SimpleStorageAccessorFactory>;

package/lib/subscription/subscription.directive.d.ts

@@ -1,15 +1,15 @@
 import { OnDestroy } from '@angular/core';
 import { Subscription } from 'rxjs';
 import { LockSet } from '@dereekb/rxjs';
+import { Maybe } from '@dereekb/util';
 import * as i0 from "@angular/core";
 /**
  * Abstract component that contains a SubscriptionObject and will clean it up automatically.
  */
 export declare abstract class AbstractSubscriptionDirective implements OnDestroy {
-    private _subscriptionObject;
-    constructor(subscription?: Subscription);
+    private readonly _subscriptionObject;
     ngOnDestroy(): void;
-    protected set sub(subscription: Subscription | undefined);
+    protected set sub(subscription: Maybe<Subscription | undefined>);
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractSubscriptionDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractSubscriptionDirective, never, never, {}, {}, never, never, false, never>;
 }

package/lib/view/if.directive.d.ts

@@ -1,4 +1,4 @@
-import { OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
+import { OnInit } from '@angular/core';
 import { Observable } from 'rxjs';
 import { AbstractSubscriptionDirective } from '../subscription';
 import * as i0 from "@angular/core";
@@ -6,13 +6,12 @@ import * as i0 from "@angular/core";
  * Abstract directive class that watches a show$ observable and behaves like *ngIf.
  */
 export declare abstract class AbstractIfDirective extends AbstractSubscriptionDirective implements OnInit {
-    private templateRef;
-    private viewContainer;
+    private readonly _templateRef;
+    private readonly _viewContainer;
     /**
      * Observable that is watched for showing/hiding.
      */
     abstract readonly show$: Observable<boolean>;
-    constructor(templateRef: TemplateRef<unknown>, viewContainer: ViewContainerRef);
     ngOnInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractIfDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractIfDirective, never, never, {}, {}, never, never, false, never>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dereekb/dbx-core",
-  "version": "10.1.30",
+  "version": "11.0.0",
   "peerDependencies": {
     "@dereekb/util": "*",
     "@dereekb/rxjs": "*",