@dereekb/dbx-core 0.0.1

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

@@ -0,0 +1,17 @@
+import { Maybe } from "@dereekb/util";
+export interface ClickableFunction {
+    onClick?: (event?: Maybe<MouseEvent>) => void;
+}
+/**
+ * Represents a clickable href/url configuration.
+ */
+export interface ClickableUrl {
+    /**
+     * href url
+     */
+    url?: string;
+    /**
+     * href target attribute.
+     */
+    target?: string;
+}

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

@@ -0,0 +1,3 @@
+export * from './anchor.directive';
+export * from './anchor';
+export * from './clickable';

package/lib/router/index.d.ts

@@ -0,0 +1,3 @@
+export * from './anchor';
+export * from './router';
+export * from './segue';

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

@@ -0,0 +1,3 @@
+export * from './provider';
+export * from './transition';
+export * from './service';

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

@@ -0,0 +1,17 @@
+import { DbNgxRouterService, DbNgxRouterTransitionService } from '../../service';
+import { SegueRef } from "../../../segue";
+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.
+ */
+export declare class DbNgxAngularRouterService implements DbNgxRouterService, DbNgxRouterTransitionService {
+    readonly router: Router;
+    readonly activatedRoute: ActivatedRoute;
+    readonly transitions$: import("rxjs").Observable<DbNgxRouterTransitionEvent>;
+    constructor(router: Router, activatedRoute: ActivatedRoute);
+    go(segueRef: SegueRef<NavigationExtras | NavigationBehaviorOptions>): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxAngularRouterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbNgxAngularRouterService>;
+}

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

@@ -0,0 +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>;
+}

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

@@ -0,0 +1,2 @@
+export * from './angular.router.service';
+export * from './angular.router.service.module';

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

@@ -0,0 +1,2 @@
+export * from './angular';
+export * from './uirouter';

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { SegueRef } from "../../segue";
+/**
+ * Router service definition that can route the app and provide routing details.
+ */
+export declare abstract class DbNgxRouterService {
+    /**
+     * Navigates to the target SegueRef.
+     *
+     * @param segueRef
+     */
+    abstract go(segueRef: SegueRef): Promise<boolean>;
+}

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

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+import { DbNgxRouterTransitionEvent } from '../transition/transition';
+/**
+ * Router service definition that provides high level information about router transitions.
+ */
+export declare abstract class DbNgxRouterTransitionService {
+    /**
+     * Observable that emits DbNgxRouterTransitionEvent values as transitions occur.
+     */
+    abstract readonly transitions$: Observable<DbNgxRouterTransitionEvent>;
+}

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

@@ -0,0 +1,2 @@
+export * from './transition';
+export * from './transition.watcher.directive';

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

@@ -0,0 +1,13 @@
+export declare enum DbNgxRouterTransitionEventType {
+    /**
+     * A transition started.
+     */
+    START = "start",
+    /**
+     * A transition ended.
+     */
+    SUCCESS = "ended"
+}
+export interface DbNgxRouterTransitionEvent {
+    type: DbNgxRouterTransitionEventType;
+}

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

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

package/lib/router/segue.d.ts

@@ -0,0 +1,28 @@
+import { Observable } from 'rxjs';
+export declare type SegueRefRouterLink = string | any[] | any;
+export interface SegueRefRawSegueParams {
+    [key: string]: any;
+}
+export interface SegueRefOptions<O = any> {
+    /**
+     * Raw parameters
+     */
+    refParams?: SegueRefRawSegueParams;
+    /**
+     * Custom Transition Options.
+     *
+     * For UIRouter, this is TransitionOptions.
+     */
+    refOptions?: O;
+}
+/**
+ * Represents a segue ref
+ */
+export interface SegueRef<O = any> extends SegueRefOptions<O> {
+    /**
+     * UI Sref reference value.
+     */
+    ref?: SegueRefRouterLink;
+}
+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/storage/index.d.ts

@@ -0,0 +1,8 @@
+export * from './storage.accessor.simple.factory';
+export * from './storage.accessor.simple';
+export * from './storage.accessor.string';
+export * from './storage.accessor';
+export * from './storage.di';
+export * from './storage.module';
+export * from './storage.object.localstorage';
+export * from './storage.object.memory';

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

@@ -0,0 +1,35 @@
+import { Maybe } from '@dereekb/util';
+import { Observable } from 'rxjs';
+/**
+ * Stored object accessor that can get/set/remove via a key, or be cleared entirely.
+ */
+export declare abstract class LimitedStorageAccessor<T> {
+    /**
+     * Attempts to get the value. Throws a DataDoesNotExistError if not available.
+     */
+    abstract get(key: string): Observable<Maybe<T>>;
+    abstract set(key: string, value: Maybe<T>): Observable<void>;
+    abstract remove(key: string): Observable<void>;
+    abstract clear(): Observable<{}>;
+}
+/**
+ * LimitedStorageAccessor extension that has knowledge of all stored keys.
+ */
+export declare abstract class StorageAccessor<T> extends LimitedStorageAccessor<T> {
+    /**
+     * Returns all values. Filtered by keys of a given prefix.
+     */
+    abstract all(prefix?: string): Observable<T[]>;
+    /**
+     * Returns all keys. Filtered by keys of a given prefix.
+     */
+    abstract allKeys(prefix?: string): Observable<string[]>;
+}
+/**
+ * StorageAccessor-like object that has immediate/synchronous functionality for get/set.
+ */
+export declare abstract class InstantStorageAccessor<T> {
+    abstract getNow(key: string): T | undefined;
+    abstract setNow(key: string, value: T): void;
+    abstract removeNow(key: string): void;
+}

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

@@ -0,0 +1,75 @@
+import { Observable } from 'rxjs';
+import { ReadStoredData, StoredData, StoredDataStorageKey, StoredDataString, Maybe } from '@dereekb/util';
+import { StorageAccessor } from './storage.accessor';
+export interface SimpleStorageAccessorConverter<T> {
+    /**
+     * Converts the input value to a string.
+     */
+    stringifyValue(value: T): StoredDataString;
+    /**
+     * Converts the data string into a value.
+     */
+    parseValue(data: StoredDataString): T;
+}
+/**
+ * SimpleStorageAccessor delegate.
+ */
+export interface SimpleStorageAccessorDelegate<T> extends SimpleStorageAccessorConverter<T>, StorageAccessor<StoredDataString> {
+}
+export declare class StringifySimpleStorageAccessorConverter<T> implements SimpleStorageAccessorConverter<T> {
+    stringifyValue(value: T): StoredDataString;
+    parseValue(data: StoredDataString): T;
+}
+export declare class WrapperSimpleStorageAccessorDelegate<T> implements SimpleStorageAccessorDelegate<T> {
+    private _delegate;
+    private _converter;
+    constructor(_delegate: StorageAccessor<StoredDataString>, _converter: SimpleStorageAccessorConverter<T>);
+    get(key: string): Observable<Maybe<StoredDataString>>;
+    set(key: string, value: StoredDataString): Observable<void>;
+    remove(key: string): Observable<void>;
+    clear(): Observable<{}>;
+    all(prefix?: string): Observable<string[]>;
+    allKeys(prefix?: string): Observable<string[]>;
+    stringifyValue(value: T): StoredDataString;
+    parseValue(data: StoredDataString): T;
+}
+export interface SimpleStorageAccessorConfig {
+    /**
+     * Storage Key Prefix
+     */
+    readonly prefix: string;
+    /**
+     * Optional prefix/value splitter.
+     */
+    readonly prefixSplitter?: string;
+    /**
+     * Number in milliseconds that objects stored will expire in.
+     */
+    readonly expiresIn?: number;
+}
+/**
+ * LimitedStorageAccessor implementation that uses a Delegate
+ */
+export declare class SimpleStorageAccessor<T> implements StorageAccessor<T> {
+    private readonly _delegate;
+    static readonly PREFIX_SPLITTER = "::";
+    protected readonly _config: SimpleStorageAccessorConfig & {
+        fullPrefix: string;
+    };
+    constructor(_delegate: SimpleStorageAccessorDelegate<T>, config: SimpleStorageAccessorConfig);
+    get(inputKey: string): Observable<T>;
+    set(inputKey: string, inputValue: T): Observable<void>;
+    remove(key: string): Observable<void>;
+    all(): Observable<T[]>;
+    allKeys(): Observable<string[]>;
+    clear(): Observable<{}>;
+    protected readStoredData(storedDataString: StoredDataString): ReadStoredData<T>;
+    protected buildStoredData(value: T): StoredData;
+    protected isExpiredStoredData(storeData: StoredData): boolean;
+    protected assertValidStorageKeyPrefix(prefix: string, prefixSplitter: string): void;
+    protected isValidStorageKeyPrefix(prefix: string, prefixSpltter: string): boolean;
+    protected makeStorageKey(key: string): StoredDataStorageKey;
+    protected isKeyOfAccessor(storageKey: StoredDataStorageKey): boolean;
+    protected decodeStorageKey(storageKey: StoredDataStorageKey): string;
+    protected stringifyValue(value: T): string;
+}

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

@@ -0,0 +1,18 @@
+import { StorageAccessor } from './storage.accessor';
+import { SimpleStorageAccessorConfig, SimpleStorageAccessor, SimpleStorageAccessorConverter } from './storage.accessor.simple';
+import { FullStorageObject, StoredDataString } from '@dereekb/util';
+import * as i0 from "@angular/core";
+export interface StorageAccessorFactoryConfig<T> extends SimpleStorageAccessorConfig {
+    storage?: StorageAccessor<StoredDataString>;
+    converter?: SimpleStorageAccessorConverter<T>;
+}
+/**
+ * Used for building SimpleStorageAccessor instances from SimpleStorageAccessorConfig.
+ */
+export declare class SimpleStorageAccessorFactory {
+    readonly storageObject: FullStorageObject;
+    constructor(storageObject: FullStorageObject);
+    createStorageAccessor<T>(config: StorageAccessorFactoryConfig<T>): SimpleStorageAccessor<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleStorageAccessorFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SimpleStorageAccessorFactory>;
+}

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

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+import { StorageAccessor } from './storage.accessor';
+import { StoredDataString, FullStorageObject, Maybe } from '@dereekb/util';
+/**
+ * Simple StorageAccessor implementation that wraps a FullStorageObject.
+ */
+export declare class StringStorageAccessor implements StorageAccessor<StoredDataString> {
+    private readonly _storage;
+    constructor(_storage: FullStorageObject);
+    get(key: string): Observable<Maybe<StoredDataString>>;
+    set(key: string, value: StoredDataString): Observable<void>;
+    remove(key: string): Observable<void>;
+    clear(): Observable<StoredDataString[]>;
+    all(): Observable<StoredDataString[]>;
+    allKeys(): Observable<string[]>;
+}

package/lib/storage/storage.di.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export declare const DEFAULT_STORAGE_OBJECT_TOKEN: InjectionToken<unknown>;
+export declare const DEFAULT_STORAGE_ACCESSOR_FACTORY_TOKEN: InjectionToken<unknown>;

package/lib/storage/storage.module.d.ts

@@ -0,0 +1,10 @@
+import { ModuleWithProviders } from '@angular/core';
+import { FullStorageObject } from '@dereekb/util';
+import * as i0 from "@angular/core";
+export declare function defaultStorageObjectFactory(): FullStorageObject;
+export declare class AppStorageModule {
+    static forRoot(): ModuleWithProviders<AppStorageModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppStorageModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppStorageModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppStorageModule>;
+}

package/lib/storage/storage.object.localstorage.d.ts

@@ -0,0 +1,16 @@
+import { FullStorageObject, Maybe, StorageObject, StoredDataStorageKey } from '@dereekb/util';
+/**
+ * StorageObject using LocalStorage.
+ */
+export declare class FullLocalStorageObject implements FullStorageObject {
+    private _localStorage;
+    constructor(_localStorage: StorageObject);
+    get isPersistant(): boolean;
+    get isAvailable(): boolean;
+    get length(): number;
+    getItem(key: StoredDataStorageKey): Maybe<string>;
+    setItem(key: StoredDataStorageKey, item: string): void;
+    removeItem(key: StoredDataStorageKey): void;
+    key(index: number): string | null;
+    removeAll(): string[];
+}

package/lib/storage/storage.object.memory.d.ts

@@ -0,0 +1,9 @@
+import { FullLocalStorageObject } from './storage.object.localstorage';
+/**
+ * FullStorageObject implementation that uses a localstorage that entirely resides in memory.
+ */
+export declare class MemoryStorageObject extends FullLocalStorageObject {
+    get isLastingStorage(): boolean;
+    get isAvailable(): boolean;
+    constructor();
+}

package/lib/subscription/index.d.ts

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

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

@@ -0,0 +1,25 @@
+import { OnDestroy } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { LockSet } from '@dereekb/rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Abstract component that contains a SubscriptionObject and will clean it up automatically.
+ */
+export declare abstract class AbstractSubscriptionDirective implements OnDestroy {
+    private _subscriptionObject;
+    constructor(subscription?: Subscription);
+    ngOnDestroy(): void;
+    protected set sub(subscription: Subscription | undefined);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractSubscriptionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractSubscriptionDirective, never, never, {}, {}, never>;
+}
+/**
+ * AbstractSubscriptionDirective extension that prevents the OnDestroy from occuring until the lockset is unlocked.
+ */
+export declare abstract class AbstractLockSetSubscriptionDirective extends AbstractSubscriptionDirective implements OnDestroy {
+    readonly lockSet: LockSet;
+    ngOnDestroy(): void;
+    protected onLockSetDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractLockSetSubscriptionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractLockSetSubscriptionDirective, never, never, {}, {}, never>;
+}

package/lib/util/index.d.ts

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

package/lib/util/view.d.ts

@@ -0,0 +1,22 @@
+import { ChangeDetectorRef, ElementRef } from "@angular/core";
+import { Maybe } from "@dereekb/util";
+/**
+ * Triggers a detection change on the input view as long as the view has not been destroyed.
+ *
+ * @param cdRef
+ */
+export declare function safeDetectChanges(cdRef: ChangeDetectorRef): 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
+ * passed content is empty.
+ *
+ * TS:
+ * @ViewChild('customLoading', { static: false }) customCustom: ElementRef;
+ *
+ * HTML:
+ * <div #customContent>
+ *  <ng-content select="[content]"></ng-content>
+ * </div>
+ */
+export declare function checkNgContentWrapperHasContent(ref: Maybe<ElementRef<Element>>): boolean;

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@dereekb/dbx-core",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "@angular/common": "^13.1.0",
+    "@angular/core": "^13.1.0",
+    "@ngrx/component-store": "^13.0.2",
+    "@ngrx/data": "^13.0.2",
+    "@ngrx/effects": "^13.0.2",
+    "@ngrx/entity": "^13.0.2",
+    "@ngrx/store": "^13.0.2",
+    "@ngrx/store-devtools": "^13.0.2",
+    "rxjs": "^7.5.2",
+    "@dereekb/util": "0.0.1",
+    "extra-set": "^2.2.11",
+    "@dereekb/rxjs": "0.0.1",
+    "ms": "^3.0.0-canary.1",
+    "@angular/platform-browser": "13.2.0",
+    "date-fns": "2.28.0",
+    "@dereekb/date": "0.0.1",
+    "date-fns-tz": "1.2.2",
+    "class-transformer": "0.5.1",
+    "class-validator": "0.13.2",
+    "reflect-metadata": "0.1.13",
+    "rrule": "dereekb/rrule#17adf5708d6567b4d01a3a8afd106261421ea492",
+    "@angular/router": "13.2.0",
+    "@uirouter/core": "^6.0.8"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "module": "fesm2015/dereekb-dbx-core.mjs",
+  "es2020": "fesm2020/dereekb-dbx-core.mjs",
+  "esm2020": "esm2020/dereekb-dbx-core.mjs",
+  "fesm2020": "fesm2020/dereekb-dbx-core.mjs",
+  "fesm2015": "fesm2015/dereekb-dbx-core.mjs",
+  "typings": "dereekb-dbx-core.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./dereekb-dbx-core.d.ts",
+      "esm2020": "./esm2020/dereekb-dbx-core.mjs",
+      "es2020": "./fesm2020/dereekb-dbx-core.mjs",
+      "es2015": "./fesm2015/dereekb-dbx-core.mjs",
+      "node": "./fesm2015/dereekb-dbx-core.mjs",
+      "default": "./fesm2020/dereekb-dbx-core.mjs"
+    }
+  },
+  "sideEffects": false
+}