@dereekb/dbx-core 11.0.20 → 11.1.0

package/lib/router/model/id.param.redirect.d.ts

@@ -0,0 +1,51 @@
+import { Observable } from 'rxjs';
+import { Destroyable, Initialized, Maybe, ModelKey } from '@dereekb/util';
+import { MaybeObservableOrValueGetter, SwitchMapToDefaultFilterFunction } from '@dereekb/rxjs';
+import { DbxRouterService } from '../router/service';
+import { DbxRouteParamReader } from '../router/util';
+/**
+ * Default identifier used by dbxRouteModelIdParamRedirect() that corresponds to the id param of the model in the current route.
+ */
+export declare const DBX_ROUTE_MODEL_ID_PARAM_DEFAULT_ID_PARAM_KEY = "id";
+/**
+ * Default identifier used by dbxRouteModelIdParamRedirect() that corresponds to the key param of the model in the current route.
+ */
+export declare const DBX_ROUTE_MODEL_ID_PARAM_DEFAULT_KEY_PARAM_KEY = "key";
+/**
+ * Default value used by dbxRouteModelIdParamRedirect() for when a value is not available or provided.
+ */
+export declare const DBX_ROUTE_MODEL_ID_PARAM_DEFAULT_USE_PARAM_VALUE = "0";
+/**
+ * Used to read an id with a specific key from the current route.
+ *
+ * Can be configured to redirect to a default route if a specific value is seen.
+ */
+export interface DbxRouteModelIdParamRedirect extends DbxRouteParamReader<ModelKey> {
+    /**
+     * The id value as it is from the current state's params.
+     */
+    readonly idFromParams$: Observable<Maybe<ModelKey>>;
+    /**
+     * The id value as it is when considering the default value.
+     */
+    readonly id$: Observable<Maybe<ModelKey>>;
+    setRedirectEnabled(redirect: Maybe<boolean>): void;
+    setDecider(decider: string | SwitchMapToDefaultFilterFunction<ModelKey>): void;
+}
+/**
+ *DbxRouteModelIdParamRedirect instance
+ */
+export interface DbxRouteModelIdParamRedirectInstance extends DbxRouteModelIdParamRedirect, DbxRouteParamReader<ModelKey>, Initialized, Destroyable {
+    readonly paramValue$: Observable<Maybe<string>>;
+    readonly defaultValue$: Observable<Maybe<string>>;
+    readonly value$: Observable<Maybe<string>>;
+    readonly idFromParams$: Observable<Maybe<ModelKey>>;
+    readonly id$: Observable<Maybe<ModelKey>>;
+    setParamKey(paramKey: string): void;
+    setDefaultValue(defaultValue: MaybeObservableOrValueGetter<string>): void;
+    setRedirectEnabled(redirect: Maybe<boolean>): void;
+    setDecider(decider: string | SwitchMapToDefaultFilterFunction<ModelKey>): void;
+    setParamValue(value: MaybeObservableOrValueGetter<string>): void;
+}
+export declare function dbxRouteModelKeyParamRedirect(dbxRouterService: DbxRouterService, defaultParamKey?: string): DbxRouteModelIdParamRedirectInstance;
+export declare function dbxRouteModelIdParamRedirect(dbxRouterService: DbxRouterService, defaultParamKey?: string): DbxRouteModelIdParamRedirectInstance;

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

@@ -0,0 +1,6 @@
+export * from './id.param.redirect';
+export * from './model.module';
+export * from './model.router.uid.directive';
+export * from './model.router.id.directive';
+export * from './model.router.key.directive';
+export * from './model.router';

package/lib/router/model/model.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./model.router.id.directive";
+import * as i2 from "./model.router.key.directive";
+import * as i3 from "./model.router.uid.directive";
+export declare class DbxCoreRouterModelModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxCoreRouterModelModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxCoreRouterModelModule, [typeof i1.DbxRouteModelIdDirective, typeof i2.DbxRouteModelKeyDirective, typeof i3.DbxRouteModelIdFromAuthUserIdDirective], never, [typeof i1.DbxRouteModelIdDirective, typeof i2.DbxRouteModelKeyDirective, typeof i3.DbxRouteModelIdFromAuthUserIdDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxCoreRouterModelModule>;
+}

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

@@ -0,0 +1,35 @@
+import { Type, Provider } from '@angular/core';
+import { Maybe, ModelKey } from '@dereekb/util';
+import { Observable, Subscription } from 'rxjs';
+/**
+ * DbxRouteModelIdDirective delegate that can recieve an observable of the model id from the route.
+ */
+export declare abstract class DbxRouteModelIdDirectiveDelegate {
+    /**
+     * Passes the param value and computed value from the DbxRouteModelIdDirective to this delegate.
+     *
+     * @param idFromParamsObs
+     * @param computedIdObs
+     */
+    abstract useRouteModelIdParamsObservable(idFromParamsObs: Observable<Maybe<ModelKey>>, computedIdObs: Observable<Maybe<ModelKey>>): Subscription;
+}
+/**
+ * Configures providers for a DbxRouteModelIdDirectiveDelegate.
+ */
+export declare function provideDbxRouteModelIdDirectiveDelegate<S extends DbxRouteModelIdDirectiveDelegate>(sourceType: Type<S>): Provider[];
+/**
+ * DbxRouteModelKeyDirective delegate that can recieve an observable of the model id from the route.
+ */
+export declare abstract class DbxRouteModelKeyDirectiveDelegate {
+    /**
+     * Passes the param value and computed value from the DbxRouteModelKeyDirective to this delegate.
+     *
+     * @param keyFromParamsObs
+     * @param computedKeyObs
+     */
+    abstract useRouteModelKeyParamsObservable(keyFromParamsObs: Observable<Maybe<ModelKey>>, computedKeyObs: Observable<Maybe<ModelKey>>): Subscription;
+}
+/**
+ * Configures providers for a DbxRouteModelKeyDirectiveDelegate.
+ */
+export declare function provideDbxRouteModelKeyDirectiveDelegate<S extends DbxRouteModelKeyDirectiveDelegate>(sourceType: Type<S>): Provider[];

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

@@ -0,0 +1,30 @@
+import { Observable } from 'rxjs';
+import { OnDestroy, OnInit } from '@angular/core';
+import { Maybe, ModelKey } from '@dereekb/util';
+import { MaybeObservableOrValueGetter, SwitchMapToDefaultFilterFunction } from '@dereekb/rxjs';
+import { AbstractSubscriptionDirective } from '../../subscription/subscription.directive';
+import { DbxRouterService } from '../router/service/router.service';
+import { DbxRouteModelIdDirectiveDelegate } from './model.router';
+import * as i0 from "@angular/core";
+/**
+ * Used for retrieving the model's id from the current route using the configured parameter and passes it to its delegate.
+ */
+export declare class DbxRouteModelIdDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+    readonly dbxRouterService: DbxRouterService;
+    readonly dbxRouteModelIdDelegate: DbxRouteModelIdDirectiveDelegate;
+    private readonly _redirectInstance;
+    readonly idFromParams$: Observable<Maybe<ModelKey>>;
+    readonly id$: Observable<Maybe<ModelKey>>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get idParam(): string;
+    set idParam(idParam: string);
+    set dbxRouteModelIdDefault(defaultValue: MaybeObservableOrValueGetter<ModelKey>);
+    /**
+     * Whether or not to enable the redirection. Is enabled by default.
+     */
+    set dbxRouteModelIdDefaultRedirect(redirect: Maybe<boolean> | '');
+    set dbxRouteModelIdDefaultDecision(decider: string | SwitchMapToDefaultFilterFunction<ModelKey>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxRouteModelIdDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxRouteModelIdDirective, "[dbxRouteModelId]", never, { "idParam": { "alias": "dbxRouteModelId"; "required": false; }; "dbxRouteModelIdDefault": { "alias": "dbxRouteModelIdDefault"; "required": false; }; "dbxRouteModelIdDefaultRedirect": { "alias": "dbxRouteModelIdDefaultRedirect"; "required": false; }; "dbxRouteModelIdDefaultDecision": { "alias": "dbxRouteModelIdDefaultDecision"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,32 @@
+import { Observable } from 'rxjs';
+import { OnDestroy, OnInit } from '@angular/core';
+import { Maybe, ModelKey } from '@dereekb/util';
+import { MaybeObservableOrValueGetter, SwitchMapToDefaultFilterFunction } from '@dereekb/rxjs';
+import { AbstractSubscriptionDirective } from '../../subscription/subscription.directive';
+import { DbxRouterService } from '../router/service/router.service';
+import { DbxRouteModelKeyDirectiveDelegate } from './model.router';
+import * as i0 from "@angular/core";
+/**
+ * Used for retrieving the model's key from the current route using the configured parameter and passes it to its delegate.
+ *
+ * If the key does not exist in the params, then the p
+ */
+export declare class DbxRouteModelKeyDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+    readonly dbxRouterService: DbxRouterService;
+    readonly dbxRouteModelKeyDelegate: DbxRouteModelKeyDirectiveDelegate;
+    private readonly _redirectInstance;
+    readonly keyFromParams$: Observable<Maybe<ModelKey>>;
+    readonly key$: Observable<Maybe<ModelKey>>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get keyParam(): string;
+    set keyParam(idParam: string);
+    set dbxRouteModelKeyDefault(defaultValue: MaybeObservableOrValueGetter<ModelKey>);
+    /**
+     * Whether or not to enable the redirection. Is enabled by default.
+     */
+    set dbxRouteModelKeyDefaultRedirect(redirect: Maybe<boolean> | '');
+    set dbxRouteModelKeyDefaultDecision(decider: string | SwitchMapToDefaultFilterFunction<ModelKey>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxRouteModelKeyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxRouteModelKeyDirective, "[dbxRouteModelKey]", never, { "keyParam": { "alias": "dbxRouteModelKey"; "required": false; }; "dbxRouteModelKeyDefault": { "alias": "dbxRouteModelKeyDefault"; "required": false; }; "dbxRouteModelKeyDefaultRedirect": { "alias": "dbxRouteModelKeyDefaultRedirect"; "required": false; }; "dbxRouteModelKeyDefaultDecision": { "alias": "dbxRouteModelKeyDefaultDecision"; "required": false; }; }, {}, never, never, false, never>;
+}

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

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

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

@@ -1,4 +1,4 @@
-import { Maybe } from '@dereekb/util';
+import { type Maybe } from '@dereekb/util';
 import { Observable, OperatorFunction } from 'rxjs';
 import { SegueRefOrSegueRefRouterLink } from '../../segue';
 import { DbxRouterTransitionEvent, DbxRouterTransitionEventType } from '../transition';

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

@@ -1,5 +1,5 @@
 import { MaybeObservableOrValueGetter } from '@dereekb/rxjs';
-import { Destroyable, Maybe } from '@dereekb/util';
+import { Destroyable, type Maybe } from '@dereekb/util';
 import { Observable } from 'rxjs';
 import { DbxRouterService } from '../service/router.service';
 /**
@@ -15,7 +15,7 @@ export interface DbxRouteParamReader<T> {
      */
     readonly defaultValue$: Observable<Maybe<T>>;
     /**
-     * The final computed value
+     * The current value given the paramValue and the defaultValue.
      */
     readonly value$: Observable<Maybe<T>>;
     /**

package/lib/router/segue.d.ts

@@ -1,4 +1,4 @@
-import { ArrayOrValue, Maybe } from '@dereekb/util';
+import { ArrayOrValue, type Maybe } from '@dereekb/util';
 import { Observable } from 'rxjs';
 export type SegueRefRouterLink = string | ArrayOrValue<object>;
 export interface SegueRefRawSegueParams {

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

@@ -1,4 +1,4 @@
-import { Maybe } from '@dereekb/util';
+import { type Maybe } from '@dereekb/util';
 import { Observable } from 'rxjs';
 /**
  * Stored object accessor that can get/set/remove via a key, or be cleared entirely.

package/lib/storage/storage.accessor.string.d.ts

@@ -1,4 +1,4 @@
-import { StoredDataString, FullStorageObject, Maybe } from '@dereekb/util';
+import { StoredDataString, FullStorageObject, type Maybe } from '@dereekb/util';
 import { Observable } from 'rxjs';
 import { StorageAccessor } from './storage.accessor';
 /**

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

@@ -1,7 +1,7 @@
 import { OnDestroy } from '@angular/core';
 import { Subscription } from 'rxjs';
 import { LockSet } from '@dereekb/rxjs';
-import { Maybe } from '@dereekb/util';
+import { type Maybe } from '@dereekb/util';
 import * as i0 from "@angular/core";
 /**
  * Abstract component that contains a SubscriptionObject and will clean it up automatically.

package/lib/util/view.d.ts

@@ -1,6 +1,6 @@
 import { MonoTypeOperatorFunction } from 'rxjs';
 import { ChangeDetectorRef, ElementRef } from '@angular/core';
-import { Maybe } from '@dereekb/util';
+import { type Maybe } from '@dereekb/util';
 /**
  * Convenience function used within observables for views that need to detect changes after a value changes.
  *

package/package.json

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