@dereekb/dbx-core 2.1.0 → 4.0.1

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

@@ -0,0 +1,39 @@
+import { Provider, Type } from "@angular/core";
+import { DbxInjectionComponentConfig } from "./injection";
+/**
+ * DbxInjectedViewContext showContext() configuration.
+ */
+export interface DbxInjectionContextConfig<T = any, O = any> {
+    /**
+     * Injected config.
+     */
+    config: DbxInjectionComponentConfig<T>;
+    /**
+     * Promise used to retrieve data from the given instance.
+     */
+    use: (instance: T) => Promise<O>;
+}
+/**
+ * View that can switch to show another arbitrary view, then switch back when the promise ends.
+ *
+ * It is similar to *ngIf/*ngSwitch, but the original child content is retained instead of discarded,
+ * and returns once the special context is done being used.
+ */
+export declare abstract class DbxInjectionContext {
+    /**
+     * Shows the given context until the promise ends, then displays the original content.
+     *
+     * The original content is hidden instead of removed from the context to avoid destruction of children elements.
+     */
+    abstract showContext<T = any, O = any>(config: DbxInjectionContextConfig<T>): Promise<O>;
+    /**
+     * Bails out of any current promise, if one is set.
+     *
+     * Returns true if the bail signal has been sent.
+     */
+    abstract resetContext(): boolean;
+}
+/**
+ * Allows a directive to provide a formly context and form.
+ */
+export declare function ProvideDbxInjectionContext<T extends DbxInjectionContext>(type: Type<T>): Provider[];

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

@@ -0,0 +1,25 @@
+import { Injector, TemplateRef, ViewContainerRef } from '@angular/core';
+import { DbxInjectionContext, DbxInjectionContextConfig } from './injection.context';
+import { DbxInjectionComponentConfig } from './injection';
+import { Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+/**
+ * DbxInjectedViewContext implementation. Acts similar to *ngIf, but instead switches to a different view without destroying the original child view.
+ */
+export declare class DbxInjectionContextDirective<O = any> implements DbxInjectionContext {
+    private readonly _injector;
+    private readonly _templateRef;
+    private readonly _viewContainer;
+    private _currentPromise;
+    private _instance;
+    private _embeddedView;
+    private _isDetached;
+    constructor(_injector: Injector, _templateRef: TemplateRef<O>, _viewContainer: ViewContainerRef);
+    set config(config: Maybe<DbxInjectionComponentConfig<any>>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    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": "config"; }, {}, never>;
+}

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

@@ -0,0 +1,16 @@
+import { DbxInjectionContext, DbxInjectionContextConfig } from "./injection.context";
+import * as i0 from "@angular/core";
+/**
+ * Abstract DbxInjectionContext implementation that forwards commands to a host DbxInjectionContext.
+ *
+ * This abstract type is used by related types for dependency injection purposes, so that those types
+ * can be injected instead of just any DbxInjectionContext.
+ */
+export declare abstract class AbstractForwardDbxInjectionContextDirective implements DbxInjectionContext {
+    readonly dbxInjectionContext: DbxInjectionContext;
+    constructor(dbxInjectionContext: DbxInjectionContext);
+    showContext<T = any, O = any>(config: DbxInjectionContextConfig<T, any>): Promise<O>;
+    resetContext(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractForwardDbxInjectionContextDirective, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractForwardDbxInjectionContextDirective, never, never, {}, {}, never>;
+}

package/lib/{injected/injected.d.ts → injection/injection.d.ts}

@@ -1,7 +1,7 @@
 import { InjectionToken, Injector, NgModuleRef, StaticProvider, TemplateRef, Type, ViewRef } from "@angular/core";
 import { Maybe } from "@dereekb/util";
-export declare const DBX_INJECTED_COMPONENT_DATA: InjectionToken<unknown>;
-export interface DbxInjectedComponentConfig<T = any> {
+export declare const DBX_INJECTION_COMPONENT_DATA: InjectionToken<unknown>;
+export interface DbxInjectionComponentConfig<T = any> {
     /**
      * Type of Component to initialize.
      */
@@ -27,7 +27,7 @@ export interface DbxInjectedComponentConfig<T = any> {
      */
     data?: any;
 }
-export interface DbxInjectedTemplateConfig<T = any> {
+export interface DbxInjectionTemplateConfig<T = any> {
     /**
      * Template ref to display.
      */
@@ -43,4 +43,4 @@ export interface DbxInjectedTemplateConfig<T = any> {
  * @param configs
  * @returns
  */
-export declare function mergeDbxInjectedComponentConfigs(configs: Maybe<Partial<DbxInjectedComponentConfig>>[]): Partial<DbxInjectedComponentConfig>;
+export declare function mergeDbxInjectionComponentConfigs(configs: Maybe<Partial<DbxInjectionComponentConfig>>[]): Partial<DbxInjectionComponentConfig>;

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

@@ -0,0 +1,19 @@
+import { ViewContainerRef, OnInit, OnDestroy, Injector } from '@angular/core';
+import { Maybe } from '@dereekb/util';
+import { DbxInjectionComponentConfig, DbxInjectionTemplateConfig } from './injection';
+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>): void;
+    setTemplate(template: Maybe<DbxInjectionTemplateConfig>): void;
+    setContent(content: Maybe<ViewContainerRef>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxInjectionDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxInjectionDirective<any>, never, never, {}, {}, never>;
+}

package/lib/{injected/injected.instance.d.ts → injection/injection.instance.d.ts}

@@ -1,23 +1,23 @@
 import { ComponentRef, Injector, ViewContainerRef } from '@angular/core';
-import { DbxInjectedComponentConfig, DbxInjectedTemplateConfig } from './injected';
+import { DbxInjectionComponentConfig, DbxInjectionTemplateConfig } from './injection';
 import { Initialized, Destroyable, Maybe } from '@dereekb/util';
 /**
  * Instance used by components to inject content based on the configuration into the view.
  */
-export declare class DbxInjectedComponentInstance<T> implements Initialized, Destroyable {
+export declare class DbxInjectionInstance<T> implements Initialized, Destroyable {
     private readonly _injector;
     private _subscriptionObject;
     private _config;
     private _template;
     private _content;
     private _componentRef;
-    readonly config$: import("rxjs").Observable<Maybe<DbxInjectedComponentConfig<T>>>;
-    readonly template$: import("rxjs").Observable<Maybe<DbxInjectedTemplateConfig<T>>>;
+    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<DbxInjectedComponentConfig<T>>;
-    set config(config: Maybe<DbxInjectedComponentConfig<T>>);
-    get template(): Maybe<DbxInjectedTemplateConfig<T>>;
-    set template(template: Maybe<DbxInjectedTemplateConfig<T>>);
+    get config(): Maybe<DbxInjectionComponentConfig<T>>;
+    set config(config: Maybe<DbxInjectionComponentConfig<T>>);
+    get template(): Maybe<DbxInjectionTemplateConfig<T>>;
+    set template(template: Maybe<DbxInjectionTemplateConfig<T>>);
     get content(): Maybe<Maybe<ViewContainerRef>>;
     set content(content: Maybe<Maybe<ViewContainerRef>>);
     get componentRef(): Maybe<ComponentRef<T>>;

package/lib/ngrx/index.d.ts

@@ -0,0 +1 @@
+export * from './store.lockset';

package/lib/ngrx/store.lockset.d.ts

@@ -0,0 +1,36 @@
+import { Observable } from 'rxjs';
+import { ComponentStore } from '@ngrx/component-store';
+import { OnDestroy } from '@angular/core';
+import { LockSet, ObservableOrValue } from '@dereekb/rxjs';
+import { Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+export interface LockSetComponent {
+    readonly lockSet: LockSet;
+}
+export interface LockSetComponentStoreConfig {
+    parent?: Maybe<Observable<LockSetComponent>>;
+    locks?: {
+        [key: string]: Observable<boolean>;
+    };
+}
+/**
+ * Abstract ComponentStore extension that provides a LockSet and OnDestroy delaying/cleanup.
+ */
+export declare abstract class LockSetComponentStore<S extends object> extends ComponentStore<S> implements OnDestroy {
+    protected readonly initialState?: S | undefined;
+    readonly lockSet: LockSet;
+    protected lockSetDestroyDelayMs: number;
+    protected lockSetDestroyTimeoutMs: Maybe<number>;
+    protected constructor(initialState?: S | undefined);
+    readonly resetStore: () => void;
+    protected setupLockSet({ parent, locks }: LockSetComponentStoreConfig): void;
+    setParentLockSet(obs: ObservableOrValue<Maybe<LockSetComponent>>): void;
+    addLock(key: string, obs: Observable<boolean>): void;
+    ngOnDestroy(): void;
+    /**
+     * Completes the cleanup of the object.
+     */
+    _destroyNow(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LockSetComponentStore<any>, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LockSetComponentStore<any>>;
+}

package/lib/pipe/index.d.ts

@@ -1 +1,3 @@
 export * from './date';
+export * from './misc';
+export * from './pipe.module';

package/lib/pipe/misc/index.d.ts

@@ -0,0 +1,2 @@
+export * from './prettyjson.pipe';
+export * from './misc.pipe.module';

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

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./prettyjson.pipe";
+export declare class DbxMiscPipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxMiscPipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxMiscPipeModule, [typeof i1.PrettyJsonPipe], never, [typeof i1.PrettyJsonPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxMiscPipeModule>;
+}

package/lib/pipe/misc/prettyjson.pipe.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import { Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+export declare class PrettyJsonPipe implements PipeTransform {
+    static toPrettyJson(input: Maybe<any>, spacing?: number): Maybe<string>;
+    transform(input: Maybe<any>, spacing?: number): Maybe<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrettyJsonPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PrettyJsonPipe, "prettyjson">;
+}

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

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./misc/misc.pipe.module";
+import * as i2 from "./date/date.pipe.module";
+export declare class DbxPipesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxPipesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxPipesModule, never, never, [typeof i1.DbxMiscPipeModule, typeof i2.DbxDatePipeModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxPipesModule>;
+}

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

@@ -3,13 +3,17 @@ import { SegueRef } from '../segue';
 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 {
+export interface ClickableAnchor extends ClickableFunction, ClickableUrl, Partial<SegueRef> {
     disabled?: boolean;
 }
 export interface ClickableAnchorLink extends ClickableAnchor {
     title: string;
     icon?: string;
 }
+/**
+ * ClickableAnchorLink that definitely has a SegueRef
+ */
+export declare type ClickableAnchorLinkSegueRef = ClickableAnchorLink & SegueRef;
 export interface ClickableIconAnchorLink extends Omit<ClickableAnchorLink, 'title'> {
     icon: string;
 }

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

@@ -1,20 +1,28 @@
 import { Observable } from 'rxjs';
+import { OnDestroy } from '@angular/core';
 import { Maybe } from '@dereekb/util';
 import { AnchorType, ClickableAnchor, DbxAnchor } from './anchor';
+import { SegueRefOrSegueRefRouterLink } from '../segue';
 import * as i0 from "@angular/core";
 /**
  * Abstract anchor directive.
  */
-export declare class AbstractDbxAnchorDirective<T extends ClickableAnchor = ClickableAnchor> implements DbxAnchor {
+export declare class AbstractDbxAnchorDirective<T extends ClickableAnchor = ClickableAnchor> implements DbxAnchor, OnDestroy {
     private _disabled;
     private _anchor;
     readonly disabled$: Observable<Maybe<boolean>>;
     readonly anchor$: Observable<Maybe<T>>;
     readonly type$: Observable<AnchorType>;
+    constructor();
+    ngOnDestroy(): void;
+    /**
+     * Convenience input to create an Anchor from the input SegueRef.
+     */
+    set ref(ref: Maybe<SegueRefOrSegueRefRouterLink>);
     get anchor(): Maybe<T>;
     set anchor(anchor: Maybe<T>);
     get disabled(): Maybe<boolean>;
     set disabled(disabled: Maybe<boolean>);
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxAnchorDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxAnchorDirective<any>, never, never, { "anchor": "anchor"; "disabled": "disabled"; }, {}, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxAnchorDirective<any>, never, never, { "ref": "ref"; "anchor": "anchor"; "disabled": "disabled"; }, {}, never>;
 }

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

@@ -1,5 +1,6 @@
+import { Observable } from 'rxjs';
 import { DbxRouterService, DbxRouterTransitionService } from '../../service';
-import { SegueRef } from "../../../segue";
+import { SegueRefOrSegueRefRouterLink, SegueRefRawSegueParams } from "../../../segue";
 import { DbxRouterTransitionEvent } from "../../transition/transition";
 import { ActivatedRoute, NavigationBehaviorOptions, NavigationExtras, Router } from '@angular/router';
 import * as i0 from "@angular/core";
@@ -9,11 +10,12 @@ import * as i0 from "@angular/core";
 export declare class DbxAngularRouterService implements DbxRouterService, DbxRouterTransitionService {
     readonly router: Router;
     readonly activatedRoute: ActivatedRoute;
-    readonly transitions$: import("rxjs").Observable<DbxRouterTransitionEvent>;
+    readonly params$: Observable<SegueRefRawSegueParams>;
+    readonly transitions$: Observable<DbxRouterTransitionEvent>;
     constructor(router: Router, activatedRoute: ActivatedRoute);
-    go(segueRef: SegueRef<NavigationExtras | NavigationBehaviorOptions>): Promise<boolean>;
-    isActive(segueRef: SegueRef<any>): boolean;
-    comparePrecision(a: SegueRef, b: SegueRef): number;
+    go(input: SegueRefOrSegueRefRouterLink<NavigationExtras | NavigationBehaviorOptions>): Promise<boolean>;
+    isActive(segueRef: SegueRefOrSegueRefRouterLink): boolean;
+    comparePrecision(a: SegueRefOrSegueRefRouterLink, b: SegueRefOrSegueRefRouterLink): number;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxAngularRouterService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DbxAngularRouterService>;
 }

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

@@ -1,21 +1,27 @@
 import { DbxRouterService, DbxRouterTransitionService } from '../../service';
-import { SegueRef } from "../../../segue";
+import { SegueRefOrSegueRefRouterLink, SegueRefRawSegueParams } from "../../../segue";
 import { StateService, UIRouterGlobals, TransitionOptions, TransitionService } from '@uirouter/core';
+import { OnDestroy } from "@angular/core";
 import { DbxRouterTransitionEvent } from '../../transition/transition';
 import * as i0 from "@angular/core";
 /**
  * UIRouter implementation of DbxRouterService and DbxRouterTransitionService.
  */
-export declare class DbxUIRouterService implements DbxRouterService, DbxRouterTransitionService {
+export declare class DbxUIRouterService implements DbxRouterService, DbxRouterTransitionService, OnDestroy {
     readonly state: StateService;
     readonly transitionService: TransitionService;
     readonly uiRouterGlobals: UIRouterGlobals;
+    private readonly _params;
+    readonly params$: import("rxjs").Observable<SegueRefRawSegueParams>;
     private readonly _transitions;
     readonly transitions$: import("rxjs").Observable<DbxRouterTransitionEvent>;
     constructor(state: StateService, transitionService: TransitionService, uiRouterGlobals: UIRouterGlobals);
-    go(segueRef: SegueRef<TransitionOptions>): Promise<boolean>;
-    isActive(segueRef: SegueRef): boolean;
-    comparePrecision(a: SegueRef, b: SegueRef): number;
+    ngOnDestroy(): void;
+    get params(): import("@uirouter/core").StateParams;
+    go(input: SegueRefOrSegueRefRouterLink<TransitionOptions>): Promise<boolean>;
+    isActive(input: SegueRefOrSegueRefRouterLink): boolean;
+    comparePrecision(aInput: SegueRefOrSegueRefRouterLink, bInput: SegueRefOrSegueRefRouterLink): number;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxUIRouterService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DbxUIRouterService>;
 }
+export declare function readSegueRefString(input: SegueRefOrSegueRefRouterLink | string): string;

package/lib/router/router/service/index.d.ts

@@ -1,2 +1,3 @@
 export * from './router.service';
+export * from './router.go';
 export * from './router.transition.service';

package/lib/router/router/service/router.go.d.ts

@@ -0,0 +1,14 @@
+import { ObservableOrValue } from "@dereekb/rxjs";
+import { SegueRef } from "../../segue";
+import { DbxRouterService } from "./router.service";
+/**
+ * Function that will perform navigation with the input route.
+ */
+export declare type GoWithRouter = (route: ObservableOrValue<SegueRef>) => Promise<boolean>;
+/**
+ * Creates a GoWithRouter function.
+ *
+ * @param dbxRouterService
+ * @returns
+ */
+export declare function goWithRouter(dbxRouterService: DbxRouterService): (route: ObservableOrValue<SegueRef>) => Promise<boolean>;

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

@@ -1,20 +1,26 @@
-import { SegueRef } from "../../segue";
+import { ObservableOrValue } from "@dereekb/rxjs";
+import { Observable } from "rxjs";
+import { SegueRefOrSegueRefRouterLink, SegueRefRawSegueParams } from "../../segue";
 /**
  * Router service definition that can route the app and provide routing details.
  */
 export declare abstract class DbxRouterService {
+    /**
+     * Params of the current successfully loaded route.
+     */
+    abstract readonly params$: Observable<SegueRefRawSegueParams>;
     /**
      * Navigates to the target SegueRef.
      *
      * @param segueRef
      */
-    abstract go(segueRef: SegueRef): Promise<boolean>;
+    abstract go(segueRef: ObservableOrValue<SegueRefOrSegueRefRouterLink>): Promise<boolean>;
     /**
      * Returns true if the input segue ref is considered active.
      *
      * @param segueRef
      */
-    abstract isActive(segueRef: SegueRef): boolean;
+    abstract isActive(segueRef: SegueRefOrSegueRefRouterLink): boolean;
     /**
      * Compares the two refs for precision for a certain route.
      *
@@ -24,5 +30,5 @@ export declare abstract class DbxRouterService {
      * @param a
      * @param b
      */
-    abstract comparePrecision(a: SegueRef, b: SegueRef): number;
+    abstract comparePrecision(a: SegueRefOrSegueRefRouterLink, b: SegueRefOrSegueRefRouterLink): number;
 }

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

@@ -5,10 +5,10 @@ import * as i0 from "@angular/core";
  * Abstract directive that listens to onSuccess transition events and runs a function.
  */
 export declare abstract class AbstractTransitionDirective {
-    protected readonly dbNgxRouterTransitionService: DbxRouterTransitionService;
+    protected readonly dbxRouterTransitionService: DbxRouterTransitionService;
     readonly transitionSuccess$: Observable<import("@dereekb/dbx-core").DbxRouterTransitionEvent>;
     readonly initAndUpdateOnTransitionSuccess$: Observable<void>;
-    constructor(dbNgxRouterTransitionService: DbxRouterTransitionService);
+    constructor(dbxRouterTransitionService: DbxRouterTransitionService);
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractTransitionDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractTransitionDirective, never, never, {}, {}, never>;
 }

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

@@ -10,7 +10,7 @@ export declare abstract class AbstractTransitionWatcherDirective extends Abstrac
     private _transitionSub;
     ngOnInit(): void;
     ngOnDestroy(): void;
-    constructor(dbNgxRouterTransitionService: DbxRouterTransitionService, ngZone: NgZone);
+    constructor(dbxRouterTransitionService: DbxRouterTransitionService, ngZone: NgZone);
     protected zoneUpdateForSuccessfulTransition(): void;
     protected abstract updateForSuccessfulTransition(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractTransitionWatcherDirective, never>;

package/lib/router/segue.d.ts

@@ -1,5 +1,6 @@
+import { ArrayOrValue } from '@dereekb/util';
 import { Observable } from 'rxjs';
-export declare type SegueRefRouterLink = string | any[] | any;
+export declare type SegueRefRouterLink = string | ArrayOrValue<any>;
 export interface SegueRefRawSegueParams {
     [key: string]: any;
 }
@@ -20,9 +21,15 @@ export interface SegueRefOptions<O = any> {
  */
 export interface SegueRef<O = any> extends SegueRefOptions<O> {
     /**
-     * UI Sref reference value.
+     * Ref path value.
      */
-    ref?: SegueRefRouterLink;
+    ref: SegueRefRouterLink;
 }
+/**
+ * A SegueRef object or a different router link representation.
+ */
+export declare type SegueRefOrSegueRefRouterLink<O = any> = SegueRef<O> | SegueRefRouterLink;
+export declare function isSegueRef<O = any>(input: SegueRefOrSegueRefRouterLink<O>): input is SegueRef<O>;
+export declare function asSegueRef<O = any>(input: SegueRefOrSegueRefRouterLink<O>): SegueRef<O>;
 export declare function refStringToSegueRef<O = any>(ref: string, options?: SegueRefOptions<O>): SegueRef<O>;
 export declare function mapRefStringObsToSegueRefObs<O = any>(obs: Observable<string>, options?: SegueRefOptions<O>): Observable<SegueRef<O>>;

package/lib/util/view.d.ts

@@ -15,6 +15,18 @@ export declare function tapDetectChanges<T>(cdRef: ChangeDetectorRef, timeout?:
  * @param cdRef
  */
 export declare function safeDetectChanges(cdRef: ChangeDetectorRef): void;
+/**
+ * Marks the ChangeDetectorRef for changes as long as the view has not been destroyed.
+ *
+ * @param cdRef
+ */
+export declare function safeMarkForCheck(cdRef: ChangeDetectorRef): void;
+/**
+ * Triggers a detection change on the input view as long as the view has not been destroyed.
+ *
+ * @param cdRef
+ */
+export declare function safeUseCdRef(cdRef: ChangeDetectorRef, use: () => void): void;
 /**
  * Used to check an injected ElementRef that wraps an ng-content injection point whether or not any content was injected,
  * or more specifically if the parent component passed any target content to the child. This will still return true if

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

@@ -0,0 +1,19 @@
+import { TemplateRef, ViewContainerRef } from "@angular/core";
+import { Observable } from "rxjs";
+import { AbstractSubscriptionDirective } from "../subscription";
+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 {
+    private templateRef;
+    private viewContainer;
+    /**
+     * Observable that is watched for showing/hiding.
+     */
+    readonly abstract show$: Observable<boolean>;
+    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractIfDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractIfDirective, never, never, {}, {}, never>;
+}

package/lib/view/index.d.ts

@@ -0,0 +1 @@
+export * from './if.directive';

package/package.json

@@ -1,25 +1,18 @@
 {
   "name": "@dereekb/dbx-core",
-  "version": "2.1.0",
+  "version": "4.0.1",
   "peerDependencies": {
     "@angular/common": "^13.0.0",
     "@angular/core": "^13.0.0",
-    "rxjs": "^7.0.0",
-    "@dereekb/util": "2.1.0",
-    "extra-set": "^2.2.11",
-    "make-error": "^1.3.0",
-    "@dereekb/rxjs": "2.1.0",
-    "ms": "^3.0.0-canary.1",
+    "@dereekb/rxjs": "4.0.1",
     "@ngrx/component-store": "^13.0.2",
     "@angular/platform-browser": "^13.0.0",
+    "@ngrx/effects": "^13.0.2",
+    "@ngrx/store": "^13.0.2",
+    "@uirouter/core": "^6.0.8",
     "date-fns": "^2.28.0",
-    "@dereekb/date": "2.1.0",
-    "class-transformer": "^0.5.1",
-    "class-validator": "^0.13.2",
-    "date-fns-tz": "^1.2.2",
-    "rrule": "git+https://git@github.com/dereekb/rrule.git#17adf5708d6567b4d01a3a8afd106261421ea492",
+    "@dereekb/date": "4.0.1",
     "@angular/router": "^13.0.0",
-    "@uirouter/core": "^6.0.8",
     "@uirouter/angular": "^9.1.0"
   },
   "dependencies": {

package/esm2020/lib/action/directive/state/action.success.component.mjs

@@ -1,50 +0,0 @@
-import { Component, Input } from '@angular/core';
-import { of } from 'rxjs';
-import { delay, exhaustMap, shareReplay, startWith } from 'rxjs/operators';
-import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
-import * as i0 from "@angular/core";
-import * as i1 from "../../action.store.source";
-import * as i2 from "@angular/common";
-/**
- * Displays the input content when success is set.
- *
- * Can be configured to show for a limited time afterwards, etc.
- */
-export class DbxActionSuccessComponent {
-    constructor(source) {
-        this.source = source;
-        this.show$ = this.source.isSuccess$.pipe(exhaustMap((success) => {
-            if (success) {
-                if (this.hideAfter) {
-                    return of(false).pipe(delay(this.hideAfter), startWith(true));
-                }
-                else {
-                    return of(true);
-                }
-            }
-            else {
-                return of(false);
-            }
-        }), shareReplay(1));
-    }
-}
-DbxActionSuccessComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: DbxActionSuccessComponent, deps: [{ token: i1.DbxActionContextStoreSourceInstance }], target: i0.ɵɵFactoryTarget.Component });
-DbxActionSuccessComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.4", type: DbxActionSuccessComponent, selector: "dbx-action-success", inputs: { hideAfter: "hideAfter" }, ngImport: i0, template: `
-    <ng-container *ngIf="show$ | async">
-      <ng-content></ng-content>
-    </ng-container>
-  `, isInline: true, directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "async": i2.AsyncPipe } });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: DbxActionSuccessComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'dbx-action-success',
-                    template: `
-    <ng-container *ngIf="show$ | async">
-      <ng-content></ng-content>
-    </ng-container>
-  `
-                }]
-        }], ctorParameters: function () { return [{ type: i1.DbxActionContextStoreSourceInstance }]; }, propDecorators: { hideAfter: [{
-                type: Input
-            }] } });
-//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/injected/index.mjs

@@ -1,6 +0,0 @@
-export * from './injected.component.module';
-export * from './injected.component';
-export * from './injected.instance';
-export * from './injected.directive';
-export * from './injected';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtY29yZS9zcmMvbGliL2luamVjdGVkL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxZQUFZLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2luamVjdGVkLmNvbXBvbmVudC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9pbmplY3RlZC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9pbmplY3RlZC5pbnN0YW5jZSc7XG5leHBvcnQgKiBmcm9tICcuL2luamVjdGVkLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2luamVjdGVkJztcbiJdfQ==