@dereekb/dbx-core 0.0.1 → 1.2.0

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

@@ -1,21 +1,21 @@
 import { NgZone } from '@angular/core';
 import { LoadingContext } from '@dereekb/rxjs';
 import { AbstractSubscriptionDirective } from '../subscription';
-import { DbNgxButton } from './button';
+import { DbxButton } from './button';
 import * as i0 from "@angular/core";
 /**
  * Context used for linking a button to a LoadingContext.
  *
  * It will be set working when the context is set loading.
  */
-export declare class DbNgxLoadingButtonDirective extends AbstractSubscriptionDirective {
-    readonly button: DbNgxButton;
+export declare class DbxLoadingButtonDirective extends AbstractSubscriptionDirective {
+    readonly button: DbxButton;
     readonly ngZone: NgZone;
-    constructor(button: DbNgxButton, 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<DbNgxLoadingButtonDirective, [{ host: true; }, null]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxLoadingButtonDirective, "[dbxLoadingButton]", never, { "context": "dbxLoadingButton"; }, {}, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxLoadingButtonDirective, [{ host: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxLoadingButtonDirective, "[dbxLoadingButton]", never, { "context": "dbxLoadingButton"; }, {}, never>;
 }

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

@@ -4,8 +4,8 @@ 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";
-export declare class DbNgxCoreButtonModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxCoreButtonModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DbNgxCoreButtonModule, [typeof i1.DbNgxButtonDirective, typeof i2.DbNgxLoadingButtonDirective, typeof i3.DbNgxActionButtonTriggerDirective, typeof i4.DbNgxActionButtonDirective, typeof i5.DbNgxButtonSegueDirective], never, [typeof i1.DbNgxButtonDirective, typeof i2.DbNgxLoadingButtonDirective, typeof i3.DbNgxActionButtonTriggerDirective, typeof i4.DbNgxActionButtonDirective, typeof i5.DbNgxButtonSegueDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<DbNgxCoreButtonModule>;
+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 ɵinj: i0.ɵɵInjectorDeclaration<DbxCoreButtonModule>;
 }

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

@@ -1,18 +1,18 @@
 import { OnInit, OnDestroy } from '@angular/core';
 import { Maybe } from '@dereekb/util';
 import { AbstractSubscriptionDirective } from '../../subscription';
-import { DbNgxButton } from '../button';
-import { SegueRef, DbNgxRouterService } from '../../router';
+import { DbxButton } from '../button';
+import { SegueRef, DbxRouterService } from '../../router';
 import * as i0 from "@angular/core";
-export declare class DbNgxButtonSegueDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
-    readonly dbxButton: DbNgxButton;
-    readonly dbxRouterService: DbNgxRouterService;
+export declare class DbxButtonSegueDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+    readonly dbxButton: DbxButton;
+    readonly dbxRouterService: DbxRouterService;
     private _segueRef;
     readonly segueRef$: import("rxjs").Observable<SegueRef<any>>;
     get segueRef(): Maybe<SegueRef>;
     set segueRef(segueRef: Maybe<SegueRef>);
-    constructor(dbxButton: DbNgxButton, dbxRouterService: DbNgxRouterService);
+    constructor(dbxButton: DbxButton, dbxRouterService: DbxRouterService);
     ngOnInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxButtonSegueDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxButtonSegueDirective, "[dbxButtonSegue]", never, { "segueRef": "dbxButtonSegue"; }, {}, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxButtonSegueDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxButtonSegueDirective, "[dbxButtonSegue]", never, { "segueRef": "dbxButtonSegue"; }, {}, never>;
 }

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

@@ -0,0 +1,17 @@
+import { HandleActionFunction } from '../../action/action.handler';
+import { AbstractFilterSourceDirective } from '../filter.abstract.source.directive';
+import { ActionContextStoreSourceInstance } from '../../action/action.store.source';
+import * as i0 from "@angular/core";
+/**
+ * Abstract filter source for components that use an action to filter.
+ */
+export declare abstract class AbstractActionFilterSourceDirective<F> extends AbstractFilterSourceDirective<F> {
+    readonly filterAction: ActionContextStoreSourceInstance;
+    applyFilter(): void;
+    /**
+     * Pre-set action handler for the template to use to set the filter.
+     */
+    setFilterAction: HandleActionFunction<F>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractActionFilterSourceDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractActionFilterSourceDirective<any>, never, never, {}, {}, never>;
+}

package/lib/filter/action/index.d.ts

@@ -0,0 +1 @@
+export * from './action.filter.source.directive';

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

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

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

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+import { OnDestroy, OnInit } from '@angular/core';
+import { FilterSource, FilterSourceInstance, ObservableGetter } from '@dereekb/rxjs';
+import { Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+/**
+ * Abstract FilterSource implementation.
+ */
+export declare abstract class AbstractFilterSourceDirective<F> implements FilterSource<F>, OnInit, OnDestroy {
+    protected _defaultFilterSource: FilterSourceInstance<F>;
+    readonly filter$: Observable<F>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    initWithFilter(filterObs: Observable<F>): void;
+    setFilter(filter: F): void;
+    resetFilter(): void;
+    protected makeDefaultFilter(): ObservableGetter<Maybe<F>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractFilterSourceDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractFilterSourceDirective<any>, never, never, {}, {}, never>;
+}

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

@@ -0,0 +1,9 @@
+import { AbstractFilterSourceConnectorDirective } from './filter.abstract.connector.directive';
+import * as i0 from "@angular/core";
+/**
+ * Used as a FilterSource and FilterSourceConnector.
+ */
+export declare class DbxFilterSourceConnectorDirective<F> extends AbstractFilterSourceConnectorDirective<F> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFilterSourceConnectorDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterSourceConnectorDirective<any>, "[dbxFilterSourceConnector]", never, {}, {}, never>;
+}

package/lib/filter/filter.content.d.ts

@@ -0,0 +1,10 @@
+import { FilterSource, FilterSourceConnector } from "@dereekb/rxjs";
+import { Provider, Type } from '@angular/core';
+/**
+ * Angular provider convenience function for a FilterSource.
+ */
+export declare function ProvideFilterSource<S extends FilterSource<any>>(sourceType: Type<S>): Provider[];
+/**
+ * Angular provider convenience function for a FilterSourceConnector.
+ */
+export declare function ProvideFilterSourceConnector<S extends FilterSourceConnector<any>>(sourceType: Type<S>): Provider[];

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

@@ -0,0 +1,14 @@
+import { FilterSourceConnector, FilterSource, FilterMapKey } from '@dereekb/rxjs';
+import { DbxFilterMapSourceDirective } from './filter.map.source.directive';
+import { 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>);
+    connectWithSource(filterSource: FilterSource<F>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFilterMapSourceConnectorDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterMapSourceConnectorDirective<any>, "[dbxFilterMapSourceConnector]", ["dbxFilterMapSourceConnector"], { "key": "dbxFilterMapSourceConnector"; }, {}, never>;
+}

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

@@ -0,0 +1,13 @@
+import { OnDestroy } from '@angular/core';
+import { FilterMap } from '@dereekb/rxjs';
+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>);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFilterMapDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterMapDirective<any>, "[dbxFilterMap]", ["dbxFilterMap"], {}, {}, never>;
+}

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

@@ -0,0 +1,18 @@
+import { BehaviorSubject } from 'rxjs';
+import { OnDestroy } from '@angular/core';
+import { FilterMap } from '@dereekb/rxjs';
+import { 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 {
+    readonly dbxFilterMap: FilterMap<F>;
+    protected _key: BehaviorSubject<Maybe<string>>;
+    readonly key$: import("rxjs").Observable<string>;
+    readonly instance$: import("rxjs").Observable<import("@dereekb/rxjs").FilterMapKeyInstance<F>>;
+    constructor(dbxFilterMap: FilterMap<F>);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxFilterMapInstanceDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxFilterMapInstanceDirective<any>, never, never, {}, {}, never>;
+}

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

@@ -0,0 +1,16 @@
+import { FilterSource, FilterMapKey } from '@dereekb/rxjs';
+import { Observable } from 'rxjs';
+import { AbstractDbxFilterMapInstanceDirective } from './filter.map.instance.directive';
+import { Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+/**
+ * Provides a FilterSource from a parent FilterMap.
+ */
+export declare class DbxFilterMapSourceDirective<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<DbxFilterMapSourceDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterMapSourceDirective<any>, "[dbxFilterMapSource]", ["dbxFilterMapSource"], { "key": "dbxFilterMapSource"; }, {}, never>;
+}

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

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

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

@@ -0,0 +1,9 @@
+import { AbstractFilterSourceDirective } from './filter.abstract.source.directive';
+import * as i0 from "@angular/core";
+/**
+ * Basic filter source directive.
+ */
+export declare class DbxFilterSourceDirective<F> extends AbstractFilterSourceDirective<F> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFilterSourceDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterSourceDirective<any>, "[dbxFilterSource]", never, {}, {}, never>;
+}

package/lib/filter/index.d.ts

@@ -0,0 +1,11 @@
+export * from './action';
+export * from './filter.abstract.connector.directive';
+export * from './filter.abstract.source.directive';
+export * from './filter.connector.directive';
+export * from './filter.content';
+export * from './filter.map.connector.directive';
+export * from './filter.map.directive';
+export * from './filter.map.instance.directive';
+export * from './filter.map.source.directive';
+export * from './filter.module';
+export * from './filter.source.directive';

package/lib/index.d.ts

@@ -2,6 +2,7 @@ export * from './action';
 export * from './button';
 export * from './router';
 export * from './pipe';
+export * from './filter';
 export * from './injected';
 export * from './storage';
 export * from './subscription';

package/lib/injected/injected.component.d.ts

@@ -1,15 +1,15 @@
 import { ViewContainerRef } from '@angular/core';
-import { DbNgxInjectedComponentConfig, DbNgxInjectedTemplateConfig } from './injected';
-import { AbstractDbNgxInjectedDirective } from './injected.directive';
+import { DbxInjectedComponentConfig, DbxInjectedTemplateConfig } from './injected';
+import { AbstractDbxInjectedDirective } from './injected.directive';
 import { Maybe } from '@dereekb/util';
 import * as i0 from "@angular/core";
 /**
  * Component that injects content based on the configuration into the view.
  */
-export declare class DbNgxInjectedComponent<T> extends AbstractDbNgxInjectedDirective<T> {
-    set config(config: Maybe<DbNgxInjectedComponentConfig<T>>);
-    set template(template: Maybe<DbNgxInjectedTemplateConfig<T>>);
+export declare class DbxInjectedComponent<T> extends AbstractDbxInjectedDirective<T> {
+    set config(config: Maybe<DbxInjectedComponentConfig<T>>);
+    set template(template: Maybe<DbxInjectedTemplateConfig<T>>);
     set content(content: Maybe<ViewContainerRef>);
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxInjectedComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DbNgxInjectedComponent<any>, "dbx-injected-content, [dbx-injected-content]", never, { "config": "config"; "template": "template"; }, {}, never, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxInjectedComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxInjectedComponent<any>, "dbx-injected-content, [dbx-injected-content]", never, { "config": "config"; "template": "template"; }, {}, never, never>;
 }

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

@@ -1,8 +1,8 @@
 import * as i0 from "@angular/core";
 import * as i1 from "./injected.component";
 import * as i2 from "@angular/common";
-export declare class DbNgxInjectedComponentModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxInjectedComponentModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DbNgxInjectedComponentModule, [typeof i1.DbNgxInjectedComponent], [typeof i2.CommonModule], [typeof i1.DbNgxInjectedComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<DbNgxInjectedComponentModule>;
+export declare class DbxInjectedComponentModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxInjectedComponentModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxInjectedComponentModule, [typeof i1.DbxInjectedComponent], [typeof i2.CommonModule], [typeof i1.DbxInjectedComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxInjectedComponentModule>;
 }

package/lib/injected/injected.d.ts

@@ -1,20 +1,33 @@
-import { Injector, TemplateRef, Type, ViewRef } from "@angular/core";
+import { InjectionToken, Injector, NgModuleRef, StaticProvider, TemplateRef, Type, ViewRef } from "@angular/core";
 import { Maybe } from "@dereekb/util";
-export interface DbNgxInjectedComponentConfig<T = any> {
+export declare const DBX_INJECTED_COMPONENT_DATA: InjectionToken<unknown>;
+export interface DbxInjectedComponentConfig<T = any> {
     /**
      * Type of Component to initialize.
      */
     componentClass: Type<T>;
     /**
-     * Custom Injector to use when creating the component.
+     * (Optional) providers to provide to the existing injector.
+     */
+    providers?: StaticProvider[];
+    /**
+     * (Optional) Custom Injector to use when creating the component. If provided, providers is ignored.
      */
     injector?: Injector;
     /**
-     * Custom initialization code when an instance is created.
+     * (Optional) Module ref to use when creating the component.
+     */
+    ngModuleRef?: NgModuleRef<unknown>;
+    /**
+     * (Optional) Custom initialization code when an instance is created.
      */
     init?: (instance: T) => void;
+    /**
+     * Any optional data to inject into the component.
+     */
+    data?: any;
 }
-export interface DbNgxInjectedTemplateConfig<T = any> {
+export interface DbxInjectedTemplateConfig<T = any> {
     /**
      * Template ref to display.
      */
@@ -24,3 +37,10 @@ export interface DbNgxInjectedTemplateConfig<T = any> {
      */
     viewRef?: Maybe<ViewRef>;
 }
+/**
+ * Merges multiple configurations into a single configuration.
+ *
+ * @param configs
+ * @returns
+ */
+export declare function mergeDbxInjectedComponentConfigs(configs: Maybe<Partial<DbxInjectedComponentConfig>>[]): Partial<DbxInjectedComponentConfig>;

package/lib/injected/injected.directive.d.ts

@@ -1,17 +1,19 @@
-import { ViewContainerRef, OnInit, OnDestroy } from '@angular/core';
+import { ViewContainerRef, OnInit, OnDestroy, Injector } from '@angular/core';
 import { Maybe } from '@dereekb/util';
-import { DbNgxInjectedComponentConfig, DbNgxInjectedTemplateConfig } from './injected';
+import { DbxInjectedComponentConfig, DbxInjectedTemplateConfig } from './injected';
 import * as i0 from "@angular/core";
 /**
  * Abstract directive that injects content based on the configuration into the view.
  */
-export declare abstract class AbstractDbNgxInjectedDirective<T> implements OnInit, OnDestroy {
+export declare abstract class AbstractDbxInjectedDirective<T> implements OnInit, OnDestroy {
+    private readonly _injector;
     private _instance;
+    constructor(_injector: Injector);
     ngOnInit(): void;
     ngOnDestroy(): void;
-    setConfig(config: Maybe<DbNgxInjectedComponentConfig>): void;
-    setTemplate(template: Maybe<DbNgxInjectedTemplateConfig>): void;
+    setConfig(config: Maybe<DbxInjectedComponentConfig>): void;
+    setTemplate(template: Maybe<DbxInjectedTemplateConfig>): void;
     setContent(content: Maybe<ViewContainerRef>): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbNgxInjectedDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbNgxInjectedDirective<any>, never, never, {}, {}, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxInjectedDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxInjectedDirective<any>, never, never, {}, {}, never>;
 }

package/lib/injected/injected.instance.d.ts

@@ -1,26 +1,28 @@
-import { ComponentRef, ViewContainerRef } from '@angular/core';
-import { DbNgxInjectedComponentConfig, DbNgxInjectedTemplateConfig } from './injected';
+import { ComponentRef, Injector, ViewContainerRef } from '@angular/core';
+import { DbxInjectedComponentConfig, DbxInjectedTemplateConfig } from './injected';
 import { Initialized, Destroyable, Maybe } from '@dereekb/util';
 /**
  * Instance used by components to inject content based on the configuration into the view.
  */
-export declare class DbNgxInjectedComponentInstance<T> implements Initialized, Destroyable {
+export declare class DbxInjectedComponentInstance<T> implements Initialized, Destroyable {
+    private readonly _injector;
     private _subscriptionObject;
     private _config;
     private _template;
     private _content;
     private _componentRef;
-    readonly config$: import("rxjs").Observable<Maybe<DbNgxInjectedComponentConfig<T>>>;
-    readonly template$: import("rxjs").Observable<Maybe<DbNgxInjectedTemplateConfig<T>>>;
+    readonly config$: import("rxjs").Observable<Maybe<DbxInjectedComponentConfig<T>>>;
+    readonly template$: import("rxjs").Observable<Maybe<DbxInjectedTemplateConfig<T>>>;
     readonly content$: import("rxjs").Observable<ViewContainerRef>;
-    get config(): Maybe<DbNgxInjectedComponentConfig<T>>;
-    set config(config: Maybe<DbNgxInjectedComponentConfig<T>>);
-    get template(): Maybe<DbNgxInjectedTemplateConfig<T>>;
-    set template(template: Maybe<DbNgxInjectedTemplateConfig<T>>);
+    get config(): Maybe<DbxInjectedComponentConfig<T>>;
+    set config(config: Maybe<DbxInjectedComponentConfig<T>>);
+    get template(): Maybe<DbxInjectedTemplateConfig<T>>;
+    set template(template: Maybe<DbxInjectedTemplateConfig<T>>);
     get content(): Maybe<Maybe<ViewContainerRef>>;
     set content(content: Maybe<Maybe<ViewContainerRef>>);
     get componentRef(): Maybe<ComponentRef<T>>;
     set componentRef(componentRef: Maybe<ComponentRef<T>>);
+    constructor(_injector: Injector);
     init(): void;
     destroy(): void;
     private _initComponent;

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

@@ -6,8 +6,8 @@ import * as i4 from "./timedistance.pipe";
 import * as i5 from "./datedistance.pipe";
 import * as i6 from "./tojsdate.pipe";
 import * as i7 from "./tominutes.pipe";
-export declare class DbNgxDatePipeModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxDatePipeModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DbNgxDatePipeModule, [typeof i1.DateFromToTimePipe, typeof i2.DateFormatDistancePipe, typeof i3.MinutesStringPipe, typeof i4.TimeDistanceCountdownPipe, typeof i4.TimeDistancePipe, typeof i5.DateDistancePipe, typeof i6.ToJsDatePipe, typeof i7.ToMinutesPipe], never, [typeof i1.DateFromToTimePipe, typeof i2.DateFormatDistancePipe, typeof i3.MinutesStringPipe, typeof i4.TimeDistanceCountdownPipe, typeof i4.TimeDistancePipe, typeof i5.DateDistancePipe, typeof i6.ToJsDatePipe, typeof i7.ToMinutesPipe]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<DbNgxDatePipeModule>;
+export declare class DbxDatePipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxDatePipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxDatePipeModule, [typeof i1.DateFromToTimePipe, typeof i2.DateFormatDistancePipe, typeof i3.MinutesStringPipe, typeof i4.TimeDistanceCountdownPipe, typeof i4.TimeDistancePipe, typeof i5.DateDistancePipe, typeof i6.ToJsDatePipe, typeof i7.ToMinutesPipe], never, [typeof i1.DateFromToTimePipe, typeof i2.DateFormatDistancePipe, typeof i3.MinutesStringPipe, typeof i4.TimeDistanceCountdownPipe, typeof i4.TimeDistancePipe, typeof i5.DateDistancePipe, typeof i6.ToJsDatePipe, typeof i7.ToMinutesPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxDatePipeModule>;
 }

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

@@ -1,8 +1,8 @@
 import { PipeTransform } from '@angular/core';
-import { DateOrDateString } from '@dereekb/util';
+import { DateOrDateString, Maybe } from '@dereekb/util';
 import * as i0 from "@angular/core";
 export declare class DateDistancePipe implements PipeTransform {
-    transform(input: DateOrDateString | undefined, to: Date, unavailable?: string): string;
+    transform(input: Maybe<DateOrDateString>, to?: Maybe<Date>, unavailable?: string): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<DateDistancePipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<DateDistancePipe, "dateDistance">;
 }

package/lib/router/anchor/anchor.d.ts

@@ -1,6 +1,6 @@
 import { ClickableFunction, ClickableUrl } from './clickable';
 import { SegueRef } from '../segue';
-import { Maybe } from '@dereekb/util';
+import { ExpandTreeFunction, FlattenTreeFunction, Maybe, TreeNode } from '@dereekb/util';
 import { Type, Provider } from '@angular/core';
 import { Observable } from 'rxjs';
 export interface ClickableAnchor extends ClickableFunction, ClickableUrl, SegueRef {
@@ -13,19 +13,42 @@ export interface ClickableAnchorLink extends ClickableAnchor {
 export interface ClickableIconAnchorLink extends Omit<ClickableAnchorLink, 'title'> {
     icon: string;
 }
+export interface ClickableAnchorLinkTree extends ClickableAnchorLink {
+    children?: ClickableAnchorLinkTree[];
+}
+export declare type ExpandedClickableAnchorLinkTree = TreeNode<ClickableAnchorLinkTree>;
+export declare const expandClickableAnchorLinkTreeNode: ExpandTreeFunction<ClickableAnchorLinkTree, ExpandedClickableAnchorLinkTree>;
+export declare const flattenExpandedClickableAnchorLinkTree: FlattenTreeFunction<ExpandedClickableAnchorLinkTree, ExpandedClickableAnchorLinkTree>;
+export declare const flattenExpandedClickableAnchorLinkTreeToLinks: FlattenTreeFunction<ExpandedClickableAnchorLinkTree, ClickableAnchorLinkTree>;
+/**
+ * Fully expands the given parent link and flattens the tree to a single parent link.
+ *
+ * @param link
+ * @returns
+ */
+export declare function expandClickableAnchorLinkTree(link: ClickableAnchorLinkTree): ExpandedClickableAnchorLinkTree[];
+/**
+ * Expands an array of links into an array of ExpandedClickableAnchorLinkTree tree values.
+ */
+export declare const expandClickableAnchorLinkTrees: import("@dereekb/util").ExpandFlattenTreeFunction<ClickableAnchorLinkTree, ExpandedClickableAnchorLinkTree>;
 export declare enum AnchorType {
-    None = 0,
-    Clickable = 1,
-    Sref = 2,
-    Href = 3,
-    Disabled = 4
+    /**
+     * When the anchor has no specific content but is not disabled.
+     *
+     * Is a passthrough for the content.
+     */
+    PLAIN = 0,
+    CLICKABLE = 1,
+    SREF = 2,
+    HREF = 3,
+    DISABLED = 4
 }
 export declare function anchorTypeForAnchor(anchor: Maybe<ClickableAnchor>, disabled?: Maybe<boolean>): AnchorType;
-export declare abstract class DbNgxAnchor<T extends ClickableAnchor = ClickableAnchor> {
+export declare abstract class DbxAnchor<T extends ClickableAnchor = ClickableAnchor> {
     abstract disabled$: Observable<Maybe<boolean>>;
     abstract anchor$: Observable<Maybe<T>>;
     abstract disabled: Maybe<boolean>;
     abstract anchor: Maybe<T>;
     abstract type$: Observable<AnchorType>;
 }
-export declare function ProvideDbNgxAnchor<S extends DbNgxAnchor>(sourceType: Type<S>): Provider[];
+export declare function ProvideDbxAnchor<S extends DbxAnchor>(sourceType: Type<S>): Provider[];

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

@@ -1,11 +1,11 @@
 import { Observable } from 'rxjs';
 import { Maybe } from '@dereekb/util';
-import { AnchorType, ClickableAnchor, DbNgxAnchor } from './anchor';
+import { AnchorType, ClickableAnchor, DbxAnchor } from './anchor';
 import * as i0 from "@angular/core";
 /**
  * Abstract anchor directive.
  */
-export declare class AbstractDbNgxAnchorDirective<T extends ClickableAnchor = ClickableAnchor> implements DbNgxAnchor {
+export declare class AbstractDbxAnchorDirective<T extends ClickableAnchor = ClickableAnchor> implements DbxAnchor {
     private _disabled;
     private _anchor;
     readonly disabled$: Observable<Maybe<boolean>>;
@@ -15,6 +15,6 @@ export declare class AbstractDbNgxAnchorDirective<T extends ClickableAnchor = Cl
     set anchor(anchor: Maybe<T>);
     get disabled(): Maybe<boolean>;
     set disabled(disabled: Maybe<boolean>);
-    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbNgxAnchorDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbNgxAnchorDirective<any>, never, never, { "anchor": "anchor"; "disabled": "disabled"; }, {}, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxAnchorDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxAnchorDirective<any>, never, never, { "anchor": "anchor"; "disabled": "disabled"; }, {}, never>;
 }

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

@@ -1,17 +1,19 @@
-import { DbNgxRouterService, DbNgxRouterTransitionService } from '../../service';
+import { DbxRouterService, DbxRouterTransitionService } from '../../service';
 import { SegueRef } from "../../../segue";
+import { DbxRouterTransitionEvent } from "../../transition/transition";
 import { ActivatedRoute, NavigationBehaviorOptions, NavigationExtras, Router } from '@angular/router';
-import { DbNgxRouterTransitionEvent } from "../../transition/transition";
 import * as i0 from "@angular/core";
 /**
- * AngularRouter implementation of DbNgxRouterService and DbNgxRouterTransitionService.
+ * AngularRouter implementation of DbxRouterService and DbxRouterTransitionService.
  */
-export declare class DbNgxAngularRouterService implements DbNgxRouterService, DbNgxRouterTransitionService {
+export declare class DbxAngularRouterService implements DbxRouterService, DbxRouterTransitionService {
     readonly router: Router;
     readonly activatedRoute: ActivatedRoute;
-    readonly transitions$: import("rxjs").Observable<DbNgxRouterTransitionEvent>;
+    readonly transitions$: import("rxjs").Observable<DbxRouterTransitionEvent>;
     constructor(router: Router, activatedRoute: ActivatedRoute);
     go(segueRef: SegueRef<NavigationExtras | NavigationBehaviorOptions>): Promise<boolean>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxAngularRouterService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DbNgxAngularRouterService>;
+    isActive(segueRef: SegueRef<any>): boolean;
+    comparePrecision(a: SegueRef, b: SegueRef): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAngularRouterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxAngularRouterService>;
 }

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

@@ -1,8 +1,8 @@
 import { ModuleWithProviders } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare class DbNgxCoreAngularRouterSegueModule {
-    static forRoot(): ModuleWithProviders<DbNgxCoreAngularRouterSegueModule>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxCoreAngularRouterSegueModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DbNgxCoreAngularRouterSegueModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<DbNgxCoreAngularRouterSegueModule>;
+export declare class DbxCoreAngularRouterSegueModule {
+    static forRoot(): ModuleWithProviders<DbxCoreAngularRouterSegueModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxCoreAngularRouterSegueModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxCoreAngularRouterSegueModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxCoreAngularRouterSegueModule>;
 }

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

@@ -1,2 +1,3 @@
+export * from './util';
 export * from './uirouter.router.service';
 export * from './uirouter.router.service.module';

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

@@ -1,19 +1,21 @@
-import { DbNgxRouterService, DbNgxRouterTransitionService } from '../../service';
+import { DbxRouterService, DbxRouterTransitionService } from '../../service';
 import { SegueRef } from "../../../segue";
 import { StateService, UIRouterGlobals, TransitionOptions, TransitionService } from '@uirouter/core';
-import { DbNgxRouterTransitionEvent } from '../../transition/transition';
+import { DbxRouterTransitionEvent } from '../../transition/transition';
 import * as i0 from "@angular/core";
 /**
- * UIRouter implementation of DbNgxRouterService and DbNgxRouterTransitionService.
+ * UIRouter implementation of DbxRouterService and DbxRouterTransitionService.
  */
-export declare class DbNgxUIRouterService implements DbNgxRouterService, DbNgxRouterTransitionService {
+export declare class DbxUIRouterService implements DbxRouterService, DbxRouterTransitionService {
     readonly state: StateService;
     readonly transitionService: TransitionService;
     readonly uiRouterGlobals: UIRouterGlobals;
     private readonly _transitions;
-    readonly transitions$: import("rxjs").Observable<DbNgxRouterTransitionEvent>;
+    readonly transitions$: import("rxjs").Observable<DbxRouterTransitionEvent>;
     constructor(state: StateService, transitionService: TransitionService, uiRouterGlobals: UIRouterGlobals);
     go(segueRef: SegueRef<TransitionOptions>): Promise<boolean>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxUIRouterService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DbNgxUIRouterService>;
+    isActive(segueRef: SegueRef): boolean;
+    comparePrecision(a: SegueRef, b: SegueRef): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxUIRouterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxUIRouterService>;
 }