@dereekb/dbx-core 2.1.0 → 3.0.0

package/esm2020/lib/injection/injection.context.directive.mjs

@@ -0,0 +1,124 @@
+import { Directive, Injector, Input, TemplateRef, ViewContainerRef } from '@angular/core';
+import { ProvideDbxInjectionContext } from './injection.context';
+import { DbxInjectionInstance } from './injection.instance';
+import { makePromiseFullRef } 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 class DbxInjectionContextDirective {
+    constructor(_injector, _templateRef, _viewContainer) {
+        this._injector = _injector;
+        this._templateRef = _templateRef;
+        this._viewContainer = _viewContainer;
+        this._instance = new DbxInjectionInstance(this._injector);
+        this._isDetached = false;
+    }
+    set config(config) {
+        let reattach = false;
+        if (config) {
+            if (!this._isDetached) {
+                // detach the original view before setting config.
+                this._viewContainer.detach();
+                this._isDetached = true;
+            }
+        }
+        else if (this._isDetached) {
+            reattach = true;
+        }
+        this._instance.config = config;
+        if (reattach) {
+            this._viewContainer.insert(this._embeddedView);
+            this._isDetached = false;
+        }
+    }
+    ngOnInit() {
+        this._instance.content = this._viewContainer;
+        this._instance.init();
+        this._embeddedView = this._viewContainer.createEmbeddedView(this._templateRef);
+        // detach the embedded view
+        this._viewContainer.detach();
+        // reattach it through the template configuration.
+        // the template configuration acts as the default.
+        this._instance.template = {
+            viewRef: this._embeddedView
+        };
+    }
+    ngOnDestroy() {
+        this._instance.destroy();
+        this._embeddedView?.destroy(); // destroy our embedded view too.
+    }
+    async showContext(config) {
+        // clear the current context before showing something new.
+        this.resetContext();
+        let promiseRef;
+        let result;
+        let error;
+        // wait for the promise to resolve and use to finish using that instance.
+        try {
+            promiseRef = makePromiseFullRef(async (resolve, reject) => {
+                const injectionConfig = {
+                    ...config.config,
+                    init: async (instance) => {
+                        // init if available in the base config.
+                        if (config.config.init) {
+                            config.config.init(instance);
+                        }
+                        try {
+                            resolve(config.use(instance));
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                    }
+                };
+                this.config = injectionConfig;
+            });
+            this._currentPromise = promiseRef;
+            // await the promise
+            await promiseRef.promise;
+        }
+        catch (e) {
+            error = e;
+        }
+        // if we're still using the same promiseRef
+        if (promiseRef && promiseRef === this._currentPromise) {
+            // clear the config to reshow the view
+            this.config = undefined;
+            // clear the current promise
+            this._currentPromise = undefined;
+        }
+        if (error != null) {
+            return Promise.reject(error);
+        }
+        else {
+            return result;
+        }
+    }
+    resetContext() {
+        let clearedValue = false;
+        if (this._currentPromise) {
+            const promise = this._currentPromise;
+            // clear the current promise too
+            this._currentPromise = undefined;
+            // clear the config.
+            this.config = undefined;
+            // send a rejection signal to bail out.
+            promise.reject(new Error('dbxInjectionContext bailout'));
+            clearedValue = true;
+        }
+        return clearedValue;
+    }
+}
+DbxInjectionContextDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxInjectionContextDirective, deps: [{ token: i0.Injector }, { token: i0.TemplateRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+DbxInjectionContextDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.2", type: DbxInjectionContextDirective, selector: "[dbxInjectionContext]", inputs: { config: "config" }, providers: ProvideDbxInjectionContext(DbxInjectionContextDirective), ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxInjectionContextDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxInjectionContext]',
+                    providers: ProvideDbxInjectionContext(DbxInjectionContextDirective)
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i0.TemplateRef }, { type: i0.ViewContainerRef }]; }, propDecorators: { config: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"injection.context.directive.js","sourceRoot":"","sources":["../../../../../../packages/dbx-core/src/lib/injection/injection.context.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, EmbeddedViewRef, Injector, Input, TemplateRef, ViewContainerRef } from '@angular/core';\nimport { DbxInjectionContext, DbxInjectionContextConfig, ProvideDbxInjectionContext } from './injection.context';\nimport { DbxInjectionInstance } from './injection.instance';\nimport { DbxInjectionComponentConfig } from './injection';\nimport { PromiseFullRef, makePromiseFullRef, Maybe } from '@dereekb/util';\n\n/**\n * DbxInjectedViewContext implementation. Acts similar to *ngIf, but instead switches to a different view without destroying the original child view.\n */\n@Directive({\n  selector: '[dbxInjectionContext]',\n  providers: ProvideDbxInjectionContext(DbxInjectionContextDirective)\n})\nexport class DbxInjectionContextDirective<O = any> implements DbxInjectionContext {\n\n  private _currentPromise: Maybe<PromiseFullRef<any>>;\n  private _instance = new DbxInjectionInstance(this._injector);\n  private _embeddedView!: EmbeddedViewRef<O>;\n  private _isDetached = false;\n\n  constructor(\n    private readonly _injector: Injector,\n    private readonly _templateRef: TemplateRef<O>,\n    private readonly _viewContainer: ViewContainerRef\n  ) { }\n\n  @Input()\n  set config(config: Maybe<DbxInjectionComponentConfig<any>>) {\n    let reattach = false;\n\n    if (config) {\n      if (!this._isDetached) {\n\n        // detach the original view before setting config.\n        this._viewContainer.detach();\n        this._isDetached = true;\n      }\n    } else if (this._isDetached) {\n      reattach = true;\n    }\n\n    this._instance.config = config;\n\n    if (reattach) {\n      this._viewContainer.insert(this._embeddedView);\n      this._isDetached = false;\n    }\n  }\n\n  ngOnInit() {\n    this._instance.content = this._viewContainer;\n    this._instance.init();\n    this._embeddedView = this._viewContainer.createEmbeddedView(this._templateRef);\n\n    // detach the embedded view\n    this._viewContainer.detach();\n\n    // reattach it through the template configuration.\n    // the template configuration acts as the default.\n    this._instance.template = {\n      viewRef: this._embeddedView\n    };\n  }\n\n  ngOnDestroy(): void {\n    this._instance.destroy();\n    this._embeddedView?.destroy(); // destroy our embedded view too.\n  }\n\n  async showContext<T, O>(config: DbxInjectionContextConfig<T>): Promise<O> {\n\n    // clear the current context before showing something new.\n    this.resetContext();\n\n    let promiseRef: PromiseFullRef<O>;\n\n    let result: O;\n    let error: any;\n\n    // wait for the promise to resolve and use to finish using that instance.\n    try {\n      promiseRef = makePromiseFullRef(async (resolve, reject) => {\n        const injectionConfig: DbxInjectionComponentConfig<T> = {\n          ...config.config,\n          init: async (instance: T) => {\n\n            // init if available in the base config.\n            if (config.config.init) {\n              config.config.init(instance);\n            }\n\n            try {\n              resolve(config.use(instance));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        };\n\n        this.config = injectionConfig as any;\n      });\n\n      this._currentPromise = promiseRef;\n\n      // await the promise\n      await promiseRef.promise;\n    } catch (e) {\n      error = e;\n    }\n\n    // if we're still using the same promiseRef\n    if (promiseRef! && promiseRef! === this._currentPromise) {\n      // clear the config to reshow the view\n      this.config = undefined;\n\n      // clear the current promise\n      this._currentPromise = undefined;\n    }\n\n    if (error != null) {\n      return Promise.reject(error);\n    } else {\n      return result!;\n    }\n  }\n\n  resetContext(): boolean {\n    let clearedValue = false;\n\n    if (this._currentPromise) {\n      const promise = this._currentPromise;\n\n      // clear the current promise too\n      this._currentPromise = undefined;\n\n      // clear the config.\n      this.config = undefined;\n\n      // send a rejection signal to bail out.\n      promise.reject(new Error('dbxInjectionContext bailout'));\n\n      clearedValue = true;\n    }\n\n    return clearedValue;\n  }\n\n}\n"]}

package/esm2020/lib/injection/injection.context.forward.directive.mjs

@@ -0,0 +1,30 @@
+import { Directive, Host } from "@angular/core";
+import { DbxInjectionContext } from "./injection.context";
+import * as i0 from "@angular/core";
+import * as i1 from "./injection.context";
+/**
+ * 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 class AbstractForwardDbxInjectionContextDirective {
+    constructor(dbxInjectionContext) {
+        this.dbxInjectionContext = dbxInjectionContext;
+    }
+    // MARK: DbxInjectionContext
+    showContext(config) {
+        return this.dbxInjectionContext.showContext(config);
+    }
+    resetContext() {
+        return this.dbxInjectionContext.resetContext();
+    }
+}
+AbstractForwardDbxInjectionContextDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AbstractForwardDbxInjectionContextDirective, deps: [{ token: i1.DbxInjectionContext, host: true }], target: i0.ɵɵFactoryTarget.Directive });
+AbstractForwardDbxInjectionContextDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.2", type: AbstractForwardDbxInjectionContextDirective, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AbstractForwardDbxInjectionContextDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.DbxInjectionContext, decorators: [{
+                    type: Host
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/injection/injection.context.mjs

@@ -0,0 +1,18 @@
+/**
+ * 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 class DbxInjectionContext {
+}
+/**
+ * Allows a directive to provide a formly context and form.
+ */
+export function ProvideDbxInjectionContext(type) {
+    return [{
+            provide: DbxInjectionContext,
+            useExisting: type
+        }];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/injection/injection.directive.mjs

@@ -0,0 +1,33 @@
+import { Directive, Injector } from '@angular/core';
+import { DbxInjectionInstance as DbxInjectionInstance } from './injection.instance';
+import * as i0 from "@angular/core";
+/**
+ * Abstract directive that injects content based on the configuration into the view.
+ */
+export class AbstractDbxInjectionDirective {
+    constructor(_injector) {
+        this._injector = _injector;
+        this._instance = new DbxInjectionInstance(this._injector);
+    }
+    ngOnInit() {
+        this._instance.init();
+    }
+    ngOnDestroy() {
+        this._instance.destroy();
+    }
+    setConfig(config) {
+        this._instance.config = config;
+    }
+    setTemplate(template) {
+        this._instance.template = template;
+    }
+    setContent(content) {
+        this._instance.content = content;
+    }
+}
+AbstractDbxInjectionDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AbstractDbxInjectionDirective, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive });
+AbstractDbxInjectionDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.2", type: AbstractDbxInjectionDirective, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AbstractDbxInjectionDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/injection/injection.instance.mjs

@@ -0,0 +1,116 @@
+import { Injector } from '@angular/core';
+import { distinctUntilChanged, map, shareReplay } from 'rxjs/operators';
+import { BehaviorSubject, combineLatest } from 'rxjs';
+import { DBX_INJECTION_COMPONENT_DATA } from './injection';
+import { mergeArrayOrValueIntoArray } from '@dereekb/util';
+import { SubscriptionObject, filterMaybe, skipFirstMaybe } from '@dereekb/rxjs';
+/**
+ * Instance used by components to inject content based on the configuration into the view.
+ */
+export class DbxInjectionInstance {
+    constructor(_injector) {
+        this._injector = _injector;
+        this._subscriptionObject = new SubscriptionObject();
+        this._config = new BehaviorSubject(undefined);
+        this._template = new BehaviorSubject(undefined);
+        this._content = new BehaviorSubject(undefined);
+        this._componentRef = new BehaviorSubject(undefined);
+        this.config$ = this._config.pipe(distinctUntilChanged());
+        this.template$ = this._template.pipe(distinctUntilChanged());
+        this.content$ = this._content.pipe(filterMaybe(), distinctUntilChanged(), shareReplay(1));
+    }
+    get config() {
+        return this._config.value;
+    }
+    set config(config) {
+        this._config.next(config);
+    }
+    get template() {
+        return this._template.value;
+    }
+    set template(template) {
+        this._template.next(template);
+    }
+    get content() {
+        return this._content.value;
+    }
+    set content(content) {
+        this._content.next(content);
+    }
+    get componentRef() {
+        return this._componentRef.value;
+    }
+    set componentRef(componentRef) {
+        this._componentRef.next(componentRef);
+    }
+    init() {
+        // Wait until the first of either of the two inputs comes in as not defined, and then emit.
+        // We filter the first maybe here between the two items.
+        const configTemplateObs = combineLatest([this.config$, this.template$]).pipe(map(([config, template]) => {
+            if (config || template) {
+                return {
+                    config,
+                    template
+                };
+            }
+            else {
+                return undefined;
+            }
+        }), skipFirstMaybe());
+        this._subscriptionObject.subscription = combineLatest([configTemplateObs, this.content$]).subscribe(([inputConfig, content]) => {
+            const { config, template } = inputConfig ?? {};
+            this._reset(content);
+            if (config) {
+                this._initComponent(config, content);
+            }
+            else if (template) {
+                this._initTemplate(template, content);
+            }
+        });
+    }
+    destroy() {
+        this._config.complete();
+        this._template.complete();
+        this._content.complete();
+        this._componentRef.complete();
+    }
+    _initComponent(config, content) {
+        content.clear();
+        const { init, injector: inputInjector, providers, ngModuleRef, componentClass, data } = config;
+        let injector;
+        const parentInjector = inputInjector ?? this._injector;
+        if (Boolean(providers || data)) {
+            injector = Injector.create({
+                parent: parentInjector,
+                providers: mergeArrayOrValueIntoArray([{
+                        provide: DBX_INJECTION_COMPONENT_DATA,
+                        useValue: data
+                    }], providers ?? [])
+            });
+        }
+        const componentRef = content.createComponent(componentClass, { injector, ngModuleRef });
+        const instance = componentRef.instance;
+        if (init) {
+            init(instance);
+        }
+        this.componentRef = componentRef;
+    }
+    _initTemplate(config, content) {
+        content.clear();
+        const { templateRef, viewRef } = config;
+        if (templateRef) {
+            content.createEmbeddedView(templateRef);
+            // TODO: Figure out if these items need to be destroyed or not when this item is destroyed. If so, we need a reference to destroy.
+        }
+        else if (viewRef) {
+            content.insert(viewRef);
+        }
+    }
+    _reset(content) {
+        if (this.componentRef) {
+            content.clear();
+            this.componentRef = undefined;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"injection.instance.js","sourceRoot":"","sources":["../../../../../../packages/dbx-core/src/lib/injection/injection.instance.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentRef, Injector, ViewContainerRef } from '@angular/core';\nimport { distinctUntilChanged, map, shareReplay } from 'rxjs/operators';\nimport { BehaviorSubject, combineLatest } from 'rxjs';\nimport { DbxInjectionComponentConfig, DbxInjectionTemplateConfig, DBX_INJECTION_COMPONENT_DATA } from './injection';\nimport { Initialized, Destroyable, Maybe, mergeArrayOrValueIntoArray } from '@dereekb/util';\nimport { SubscriptionObject, filterMaybe, skipFirstMaybe } from '@dereekb/rxjs';\n\n/**\n * Instance used by components to inject content based on the configuration into the view.\n */\nexport class DbxInjectionInstance<T> implements Initialized, Destroyable {\n\n  private _subscriptionObject = new SubscriptionObject();\n\n  private _config = new BehaviorSubject<Maybe<DbxInjectionComponentConfig<T>>>(undefined);\n  private _template = new BehaviorSubject<Maybe<DbxInjectionTemplateConfig<T>>>(undefined);\n\n  private _content = new BehaviorSubject<Maybe<ViewContainerRef>>(undefined);\n  private _componentRef = new BehaviorSubject<Maybe<ComponentRef<T>>>(undefined);\n\n  readonly config$ = this._config.pipe(distinctUntilChanged());\n  readonly template$ = this._template.pipe(distinctUntilChanged());\n  readonly content$ = this._content.pipe(filterMaybe(), distinctUntilChanged(), shareReplay(1));\n\n  get config(): Maybe<DbxInjectionComponentConfig<T>> {\n    return this._config.value;\n  }\n\n  set config(config: Maybe<DbxInjectionComponentConfig<T>>) {\n    this._config.next(config);\n  }\n\n  get template(): Maybe<DbxInjectionTemplateConfig<T>> {\n    return this._template.value;\n  }\n\n  set template(template: Maybe<DbxInjectionTemplateConfig<T>>) {\n    this._template.next(template);\n  }\n\n  get content(): Maybe<Maybe<ViewContainerRef>> {\n    return this._content.value;\n  }\n\n  set content(content: Maybe<Maybe<ViewContainerRef>>) {\n    this._content.next(content);\n  }\n\n  get componentRef(): Maybe<ComponentRef<T>> {\n    return this._componentRef.value;\n  }\n\n  set componentRef(componentRef: Maybe<ComponentRef<T>>) {\n    this._componentRef.next(componentRef);\n  }\n\n  constructor(private readonly _injector: Injector) { }\n\n  init(): void {\n\n    // Wait until the first of either of the two inputs comes in as not defined, and then emit.\n    // We filter the first maybe here between the two items.\n    const configTemplateObs = combineLatest([this.config$, this.template$]).pipe(\n      map(([config, template]) => {\n        if (config || template) {\n          return {\n            config,\n            template\n          };\n        } else {\n          return undefined;\n        }\n      }),\n      skipFirstMaybe()\n    );\n\n    this._subscriptionObject.subscription = combineLatest([configTemplateObs, this.content$]).subscribe(([inputConfig, content]) => {\n      const { config, template } = inputConfig ?? {};\n      this._reset(content);\n\n      if (config) {\n        this._initComponent(config, content);\n      } else if (template) {\n        this._initTemplate(template, content);\n      }\n    });\n  }\n\n  destroy(): void {\n    this._config.complete();\n    this._template.complete();\n    this._content.complete();\n    this._componentRef.complete();\n  }\n\n  private _initComponent(config: DbxInjectionComponentConfig<T>, content: ViewContainerRef): void {\n    content.clear();\n\n    const { init, injector: inputInjector, providers, ngModuleRef, componentClass, data } = config;\n\n    let injector: Injector | undefined;\n    const parentInjector = inputInjector ?? this._injector;\n\n    if (Boolean(providers || data)) {\n      injector = Injector.create({\n        parent: parentInjector,\n        providers: mergeArrayOrValueIntoArray([{\n          provide: DBX_INJECTION_COMPONENT_DATA,\n          useValue: data\n        }], providers ?? [])\n      });\n    }\n\n    const componentRef: ComponentRef<T> = content.createComponent(componentClass, { injector, ngModuleRef });\n\n    const instance = componentRef.instance;\n\n    if (init) {\n      init(instance);\n    }\n\n    this.componentRef = componentRef;\n  }\n\n  private _initTemplate(config: DbxInjectionTemplateConfig<T>, content: ViewContainerRef): void {\n    content.clear();\n\n    const { templateRef, viewRef } = config;\n\n    if (templateRef) {\n      content.createEmbeddedView(templateRef);\n\n      // TODO: Figure out if these items need to be destroyed or not when this item is destroyed. If so, we need a reference to destroy.\n\n    } else if (viewRef) {\n      content.insert(viewRef)\n    }\n  }\n\n  private _reset(content: ViewContainerRef): void {\n    if (this.componentRef) {\n      content.clear();\n      this.componentRef = undefined;\n    }\n  }\n\n}\n"]}

package/esm2020/lib/injection/injection.mjs

@@ -0,0 +1,16 @@
+import { InjectionToken } from "@angular/core";
+import { filterMaybeValues, mergeArrays, mergeObjects } from "@dereekb/util";
+export const DBX_INJECTION_COMPONENT_DATA = new InjectionToken('DbxInjectionComponentConfigData');
+/**
+ * Merges multiple configurations into a single configuration.
+ *
+ * @param configs
+ * @returns
+ */
+export function mergeDbxInjectionComponentConfigs(configs) {
+    const providers = mergeArrays(filterMaybeValues(configs).map(x => x.providers));
+    const result = mergeObjects(configs);
+    result.providers = providers;
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/ngrx/index.mjs

@@ -0,0 +1,2 @@
+export * from './store.lockset';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtY29yZS9zcmMvbGliL25ncngvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc3RvcmUubG9ja3NldCc7XG4iXX0=

package/esm2020/lib/ngrx/store.lockset.mjs

@@ -0,0 +1,64 @@
+import { map } from 'rxjs';
+import { ComponentStore } from '@ngrx/component-store';
+import { Inject, Optional, Injectable } from '@angular/core';
+import { LockSet, asObservable } from '@dereekb/rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Abstract ComponentStore extension that provides a LockSet and OnDestroy delaying/cleanup.
+ */
+export class LockSetComponentStore extends ComponentStore {
+    constructor(initialState) {
+        super(initialState);
+        this.initialState = initialState;
+        this.lockSet = new LockSet();
+        this.lockSetDestroyDelayMs = 2000;
+        // MARK: State Changes
+        this.resetStore = this.updater(() => ({ ...this.initialState }));
+    }
+    // MARK: Locks
+    setupLockSet({ parent, locks }) {
+        if (parent) {
+            this.setParentLockSet(parent);
+        }
+        if (locks) {
+            for (const key in locks) {
+                if (locks[key]) {
+                    this.addLock(key, locks[key]);
+                }
+            }
+        }
+    }
+    setParentLockSet(obs) {
+        this.lockSet.setParentLockSet(asObservable(obs).pipe(map(x => x?.lockSet)));
+    }
+    addLock(key, obs) {
+        this.lockSet.addLock(key, obs);
+    }
+    // MARK: Cleanup
+    ngOnDestroy() {
+        // Wait for any actions to complete before destroying.
+        this.lockSet.destroyOnNextUnlock({
+            fn: () => {
+                this._destroyNow();
+            },
+            timeout: this.lockSetDestroyTimeoutMs,
+        }, this.lockSetDestroyDelayMs);
+    }
+    /**
+     * Completes the cleanup of the object.
+     */
+    _destroyNow() {
+        this.lockSet.destroy();
+    }
+}
+LockSetComponentStore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: LockSetComponentStore, deps: [{ token: null, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+LockSetComponentStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: LockSetComponentStore });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: LockSetComponentStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [null]
+                }, {
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/pipe/date/date.pipe.module.mjs

@@ -9,8 +9,8 @@ import { DateDistancePipe } from './datedistance.pipe';
 import * as i0 from "@angular/core";
 export class DbxDatePipeModule {
 }
-DbxDatePipeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: DbxDatePipeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-DbxDatePipeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: DbxDatePipeModule, declarations: [DateFromToTimePipe,
+DbxDatePipeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxDatePipeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DbxDatePipeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxDatePipeModule, declarations: [DateFromToTimePipe,
         DateFormatDistancePipe,
         MinutesStringPipe,
         TimeDistanceCountdownPipe,
@@ -25,8 +25,8 @@ DbxDatePipeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", versi
         DateDistancePipe,
         ToJsDatePipe,
         ToMinutesPipe] });
-DbxDatePipeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: DbxDatePipeModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: DbxDatePipeModule, decorators: [{
+DbxDatePipeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxDatePipeModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxDatePipeModule, decorators: [{
             type: NgModule,
             args: [{
                     exports: [

package/esm2020/lib/pipe/date/datedistance.pipe.mjs

@@ -33,9 +33,9 @@ export class DateDistancePipe {
         }
     }
 }
-DateDistancePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: DateDistancePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-DateDistancePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: DateDistancePipe, name: "dateDistance", pure: false });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: DateDistancePipe, decorators: [{
+DateDistancePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DateDistancePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+DateDistancePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DateDistancePipe, name: "dateDistance", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DateDistancePipe, decorators: [{
             type: Pipe,
             args: [{ name: 'dateDistance', pure: false }]
         }] });

package/esm2020/lib/pipe/date/dateformatdistance.pipe.mjs

@@ -25,9 +25,9 @@ export class DateFormatDistancePipe {
         return undefined;
     }
 }
-DateFormatDistancePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: DateFormatDistancePipe, deps: [{ token: LOCALE_ID }], target: i0.ɵɵFactoryTarget.Pipe });
-DateFormatDistancePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: DateFormatDistancePipe, name: "dateFormatDistance", pure: false });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: DateFormatDistancePipe, decorators: [{
+DateFormatDistancePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DateFormatDistancePipe, deps: [{ token: LOCALE_ID }], target: i0.ɵɵFactoryTarget.Pipe });
+DateFormatDistancePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DateFormatDistancePipe, name: "dateFormatDistance", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DateFormatDistancePipe, decorators: [{
             type: Pipe,
             args: [{ name: 'dateFormatDistance', pure: false }]
         }], ctorParameters: function () { return [{ type: undefined, decorators: [{

package/esm2020/lib/pipe/date/datefromtoformat.pipe.mjs

@@ -23,9 +23,9 @@ export class DateFromToTimePipe {
         return undefined;
     }
 }
-DateFromToTimePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: DateFromToTimePipe, deps: [{ token: LOCALE_ID }], target: i0.ɵɵFactoryTarget.Pipe });
-DateFromToTimePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: DateFromToTimePipe, name: "dateFromPlusTo" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: DateFromToTimePipe, decorators: [{
+DateFromToTimePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DateFromToTimePipe, deps: [{ token: LOCALE_ID }], target: i0.ɵɵFactoryTarget.Pipe });
+DateFromToTimePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DateFromToTimePipe, name: "dateFromPlusTo" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DateFromToTimePipe, decorators: [{
             type: Pipe,
             args: [{ name: 'dateFromPlusTo' }]
         }], ctorParameters: function () { return [{ type: undefined, decorators: [{

package/esm2020/lib/pipe/date/minutesstring.pipe.mjs

@@ -23,9 +23,9 @@ export class MinutesStringPipe {
         }
     }
 }
-MinutesStringPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: MinutesStringPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-MinutesStringPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: MinutesStringPipe, name: "minutesString", pure: false });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: MinutesStringPipe, decorators: [{
+MinutesStringPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: MinutesStringPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+MinutesStringPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: MinutesStringPipe, name: "minutesString", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: MinutesStringPipe, decorators: [{
             type: Pipe,
             args: [{ name: 'minutesString', pure: false }]
         }] });

package/esm2020/lib/pipe/date/timedistance.pipe.mjs

@@ -21,9 +21,9 @@ export class TimeDistanceCountdownPipe {
         }
     }
 }
-TimeDistanceCountdownPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: TimeDistanceCountdownPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-TimeDistanceCountdownPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: TimeDistanceCountdownPipe, name: "timeCountdownDistance", pure: false });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: TimeDistanceCountdownPipe, decorators: [{
+TimeDistanceCountdownPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: TimeDistanceCountdownPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+TimeDistanceCountdownPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: TimeDistanceCountdownPipe, name: "timeCountdownDistance", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: TimeDistanceCountdownPipe, decorators: [{
             type: Pipe,
             args: [{ name: 'timeCountdownDistance', pure: false }]
         }] });
@@ -40,9 +40,9 @@ export class TimeDistancePipe {
         }
     }
 }
-TimeDistancePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: TimeDistancePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-TimeDistancePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: TimeDistancePipe, name: "timeDistance", pure: false });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: TimeDistancePipe, decorators: [{
+TimeDistancePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: TimeDistancePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+TimeDistancePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: TimeDistancePipe, name: "timeDistance", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: TimeDistancePipe, decorators: [{
             type: Pipe,
             args: [{ name: 'timeDistance', pure: false }]
         }] });

package/esm2020/lib/pipe/date/tojsdate.pipe.mjs

@@ -1,18 +1,26 @@
+import { isValid } from 'date-fns';
 import { Pipe } from '@angular/core';
 import { toJsDate } from '@dereekb/date';
 import * as i0 from "@angular/core";
 export class ToJsDatePipe {
     static toJsDate(input) {
-        return (input) ? toJsDate(input) : undefined;
+        let date;
+        if (input != null) {
+            date = toJsDate(input);
+            if (!isValid(date)) {
+                date = undefined;
+            }
+        }
+        return date;
     }
     transform(input) {
         return ToJsDatePipe.toJsDate(input);
     }
 }
-ToJsDatePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: ToJsDatePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-ToJsDatePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: ToJsDatePipe, name: "toJsDate" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: ToJsDatePipe, decorators: [{
+ToJsDatePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: ToJsDatePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+ToJsDatePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: ToJsDatePipe, name: "toJsDate" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: ToJsDatePipe, decorators: [{
             type: Pipe,
             args: [{ name: 'toJsDate' }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9qc2RhdGUucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2RieC1jb3JlL3NyYy9saWIvcGlwZS9kYXRlL3RvanNkYXRlLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7QUFDcEQsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFJekMsTUFBTSxPQUFPLFlBQVk7SUFFaEIsTUFBTSxDQUFDLFFBQVEsQ0FBQyxLQUE4QjtRQUNuRCxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDO0lBQy9DLENBQUM7SUFFRCxTQUFTLENBQUMsS0FBOEI7UUFDdEMsT0FBTyxZQUFZLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ3RDLENBQUM7O3lHQVJVLFlBQVk7dUdBQVosWUFBWTsyRkFBWixZQUFZO2tCQUR4QixJQUFJO21CQUFDLEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IHRvSnNEYXRlIH0gZnJvbSAnQGRlcmVla2IvZGF0ZSc7XG5pbXBvcnQgeyBEYXRlT3JEYXRlU3RyaW5nLCBNYXliZSB9IGZyb20gJ0BkZXJlZWtiL3V0aWwnO1xuXG5AUGlwZSh7IG5hbWU6ICd0b0pzRGF0ZScgfSlcbmV4cG9ydCBjbGFzcyBUb0pzRGF0ZVBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcblxuICBwdWJsaWMgc3RhdGljIHRvSnNEYXRlKGlucHV0OiBNYXliZTxEYXRlT3JEYXRlU3RyaW5nPik6IE1heWJlPERhdGU+IHtcbiAgICByZXR1cm4gKGlucHV0KSA/IHRvSnNEYXRlKGlucHV0KSA6IHVuZGVmaW5lZDtcbiAgfVxuXG4gIHRyYW5zZm9ybShpbnB1dDogTWF5YmU8RGF0ZU9yRGF0ZVN0cmluZz4pOiBNYXliZTxEYXRlPiB7XG4gICAgcmV0dXJuIFRvSnNEYXRlUGlwZS50b0pzRGF0ZShpbnB1dCk7XG4gIH1cblxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9qc2RhdGUucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2RieC1jb3JlL3NyYy9saWIvcGlwZS9kYXRlL3RvanNkYXRlLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUNuQyxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQztBQUNwRCxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUl6QyxNQUFNLE9BQU8sWUFBWTtJQUVoQixNQUFNLENBQUMsUUFBUSxDQUFDLEtBQThCO1FBQ25ELElBQUksSUFBaUIsQ0FBQztRQUV0QixJQUFJLEtBQUssSUFBSSxJQUFJLEVBQUU7WUFDakIsSUFBSSxHQUFHLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUV2QixJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxFQUFFO2dCQUNsQixJQUFJLEdBQUcsU0FBUyxDQUFDO2FBQ2xCO1NBQ0Y7UUFFRCxPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7SUFFRCxTQUFTLENBQUMsS0FBOEI7UUFDdEMsT0FBTyxZQUFZLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ3RDLENBQUM7O3lHQWxCVSxZQUFZO3VHQUFaLFlBQVk7MkZBQVosWUFBWTtrQkFEeEIsSUFBSTttQkFBQyxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBpc1ZhbGlkIH0gZnJvbSAnZGF0ZS1mbnMnO1xuaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgdG9Kc0RhdGUgfSBmcm9tICdAZGVyZWVrYi9kYXRlJztcbmltcG9ydCB7IERhdGVPckRhdGVTdHJpbmcsIE1heWJlIH0gZnJvbSAnQGRlcmVla2IvdXRpbCc7XG5cbkBQaXBlKHsgbmFtZTogJ3RvSnNEYXRlJyB9KVxuZXhwb3J0IGNsYXNzIFRvSnNEYXRlUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuXG4gIHB1YmxpYyBzdGF0aWMgdG9Kc0RhdGUoaW5wdXQ6IE1heWJlPERhdGVPckRhdGVTdHJpbmc+KTogTWF5YmU8RGF0ZT4ge1xuICAgIGxldCBkYXRlOiBNYXliZTxEYXRlPjtcbiAgICBcbiAgICBpZiAoaW5wdXQgIT0gbnVsbCkge1xuICAgICAgZGF0ZSA9IHRvSnNEYXRlKGlucHV0KTtcblxuICAgICAgaWYgKCFpc1ZhbGlkKGRhdGUpKSB7XG4gICAgICAgIGRhdGUgPSB1bmRlZmluZWQ7XG4gICAgICB9XG4gICAgfVxuXG4gICAgcmV0dXJuIGRhdGU7XG4gIH1cblxuICB0cmFuc2Zvcm0oaW5wdXQ6IE1heWJlPERhdGVPckRhdGVTdHJpbmc+KTogTWF5YmU8RGF0ZT4ge1xuICAgIHJldHVybiBUb0pzRGF0ZVBpcGUudG9Kc0RhdGUoaW5wdXQpO1xuICB9XG5cbn1cbiJdfQ==