@dereekb/dbx-firebase 12.5.8 → 12.5.10

package/esm2022/lib/modules/storagefile/container/index.mjs

@@ -1,7 +1,8 @@
+export * from './storagefile.download.button.component';
 export * from './storagefile.upload.action.handler.directive';
 export * from './storagefile.upload.error';
 export * from './storagefile.upload.handler';
 export * from './storagefile.upload.initialize.document.directive';
 export * from './storagefile.upload.store.directive';
 export * from './storagefile.upload.sync.directive';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZmlyZWJhc2Uvc3JjL2xpYi9tb2R1bGVzL3N0b3JhZ2VmaWxlL2NvbnRhaW5lci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLCtDQUErQyxDQUFDO0FBQzlELGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLG9EQUFvRCxDQUFDO0FBQ25FLGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyxxQ0FBcUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc3RvcmFnZWZpbGUudXBsb2FkLmFjdGlvbi5oYW5kbGVyLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3N0b3JhZ2VmaWxlLnVwbG9hZC5lcnJvcic7XG5leHBvcnQgKiBmcm9tICcuL3N0b3JhZ2VmaWxlLnVwbG9hZC5oYW5kbGVyJztcbmV4cG9ydCAqIGZyb20gJy4vc3RvcmFnZWZpbGUudXBsb2FkLmluaXRpYWxpemUuZG9jdW1lbnQuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vc3RvcmFnZWZpbGUudXBsb2FkLnN0b3JlLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3N0b3JhZ2VmaWxlLnVwbG9hZC5zeW5jLmRpcmVjdGl2ZSc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZmlyZWJhc2Uvc3JjL2xpYi9tb2R1bGVzL3N0b3JhZ2VmaWxlL2NvbnRhaW5lci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlDQUF5QyxDQUFDO0FBQ3hELGNBQWMsK0NBQStDLENBQUM7QUFDOUQsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsb0RBQW9ELENBQUM7QUFDbkUsY0FBYyxzQ0FBc0MsQ0FBQztBQUNyRCxjQUFjLHFDQUFxQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zdG9yYWdlZmlsZS5kb3dubG9hZC5idXR0b24uY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vc3RvcmFnZWZpbGUudXBsb2FkLmFjdGlvbi5oYW5kbGVyLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3N0b3JhZ2VmaWxlLnVwbG9hZC5lcnJvcic7XG5leHBvcnQgKiBmcm9tICcuL3N0b3JhZ2VmaWxlLnVwbG9hZC5oYW5kbGVyJztcbmV4cG9ydCAqIGZyb20gJy4vc3RvcmFnZWZpbGUudXBsb2FkLmluaXRpYWxpemUuZG9jdW1lbnQuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vc3RvcmFnZWZpbGUudXBsb2FkLnN0b3JlLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3N0b3JhZ2VmaWxlLnVwbG9hZC5zeW5jLmRpcmVjdGl2ZSc7XG4iXX0=

package/esm2022/lib/modules/storagefile/container/storagefile.download.button.component.mjs

@@ -0,0 +1,210 @@
+import { ChangeDetectionStrategy, Component, computed, effect, inject, input, output, signal } from '@angular/core';
+import { DbxActionDialogDirective, DbxActionModule, DbxActionSnackbarErrorDirective, DbxAnchorComponent, DbxButtonComponent, DbxEmbedDialogComponent } from '@dereekb/dbx-web';
+import { dateFromDateOrTimeNumber, isPast, MS_IN_SECOND } from '@dereekb/util';
+import { DbxFirebaseStorageFileDownloadService } from '../service/storagefile.download.service';
+import { toObservable, toSignal } from '@angular/core/rxjs-interop';
+import { distinctUntilChanged, interval, map, of, shareReplay, switchMap } from 'rxjs';
+import { MatDialog } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+import * as i1 from "@dereekb/dbx-core";
+export class DbxFirebaseStorageFileDownloadButton {
+    dbxFirebaseStorageFileDownloadService = inject(DbxFirebaseStorageFileDownloadService);
+    matDialog = inject(MatDialog);
+    /**
+     * The StorageFileKey to set up the download button for.
+     */
+    storageFileKey = input();
+    /**
+     * The download URL to use for the download button.
+     */
+    storageFileDownloadUrl = input();
+    /**
+     * The MIME type to use the embed component.
+     */
+    embedMimeType = input();
+    /**
+     * Whether or not to show a preview button.
+     *
+     * Defaults to true.
+     */
+    showPreviewButton = input(true);
+    /**
+     * Output event emitted when the download URL changes.
+     */
+    downloadUrlChange = output();
+    config = input();
+    configSignal = computed(() => {
+        const config = this.config();
+        const result = {
+            buttonStyle: config?.buttonStyle,
+            previewButtonStyle: config?.previewButtonStyle,
+            icon: config?.icon ?? 'cloud_download',
+            text: config?.text ?? 'Start Download',
+            downloadReadyIcon: config?.downloadReadyIcon ?? 'download',
+            downloadReadyText: config?.downloadReadyText ?? 'Save File',
+            previewIcon: config?.previewIcon ?? 'preview',
+            previewText: config?.previewText ?? 'View File'
+        };
+        return result;
+    });
+    preloadSignal = computed(() => {
+        const config = this.configSignal();
+        return config.preload ?? false;
+    });
+    downloadUrlSignal = signal(undefined);
+    downloadUrlExpiresAtSignal = signal(undefined);
+    storageFileKey$ = toObservable(this.storageFileKey).pipe(distinctUntilChanged(), shareReplay(1));
+    hasDownloadUrlSignal = computed(() => Boolean(this.downloadUrlSignal()));
+    buttonStyleSignal = computed(() => {
+        const config = this.configSignal();
+        const result = {
+            type: 'raised',
+            ...config.buttonStyle
+        };
+        return result;
+    });
+    previewButtonStyleSignal = computed(() => {
+        const config = this.configSignal();
+        const result = {
+            type: 'raised',
+            ...config.previewButtonStyle
+        };
+        return result;
+    });
+    iconSignal = computed(() => {
+        const config = this.configSignal();
+        const hasDownloadUrl = this.hasDownloadUrlSignal();
+        return hasDownloadUrl ? (config.downloadReadyIcon ?? config.icon) : config.icon;
+    });
+    textSignal = computed(() => {
+        const config = this.configSignal();
+        const hasDownloadUrl = this.hasDownloadUrlSignal();
+        return hasDownloadUrl ? (config.downloadReadyText ?? config.text) : config.text;
+    });
+    previewIconSignal = computed(() => {
+        const config = this.configSignal();
+        return config.previewIcon;
+    });
+    previewTextSignal = computed(() => {
+        const config = this.configSignal();
+        return config.previewText;
+    });
+    anchorSignal = computed(() => {
+        const downloadUrl = this.downloadUrlSignal();
+        let result;
+        if (downloadUrl) {
+            result = {
+                url: downloadUrl
+            };
+        }
+        return result;
+    });
+    storageFileDownloadUrlEffect = effect(() => {
+        const downloadUrl = this.storageFileDownloadUrl();
+        if (downloadUrl || downloadUrl === null) {
+            this.downloadUrlSignal.set(downloadUrl);
+        }
+    }, {
+        allowSignalWrites: true
+    });
+    // Preview
+    showPreviewButtonSignal = computed(() => {
+        const config = this.configSignal();
+        const hasDownloadUrl = this.hasDownloadUrlSignal();
+        return hasDownloadUrl && (config.showPreviewButton ?? true);
+    });
+    handleOpenPreviewDialog = () => {
+        const srcUrl = this.downloadUrlSignal();
+        const embedMimeType = this.embedMimeType();
+        return DbxEmbedDialogComponent.openDialog(this.matDialog, {
+            srcUrl,
+            embedMimeType,
+            sanitizeUrl: true
+        });
+    };
+    // Cached Url Effect
+    // When the key changes, check the cache to see if it is already available, and populate the download url if it is.
+    cachedUrlForStorageFileKey$ = this.storageFileKey$.pipe(switchMap((key) => (key ? this.dbxFirebaseStorageFileDownloadService.getCachedDownloadPairForStorageFile(key) : of(null))), shareReplay(1));
+    cachedUrlForStorageFileKeySignal = toSignal(this.cachedUrlForStorageFileKey$);
+    cachedUrlEffect = effect(() => {
+        const cachedPair = this.cachedUrlForStorageFileKeySignal();
+        if (cachedPair) {
+            this.downloadUrlSignal.set(cachedPair.downloadUrl);
+            this.downloadUrlExpiresAtSignal.set(cachedPair.expiresAt);
+        }
+    }, {
+        allowSignalWrites: true
+    });
+    // Expiration Effect
+    downloadUrlExpiresAt$ = toObservable(this.downloadUrlExpiresAtSignal).pipe(map(dateFromDateOrTimeNumber), distinctUntilChanged(), shareReplay(1));
+    downloadUrlHasExpired$ = this.downloadUrlExpiresAt$.pipe(switchMap((x) => {
+        let obs;
+        if (x) {
+            obs = interval(MS_IN_SECOND).pipe(map(() => isPast(x)), distinctUntilChanged(), shareReplay(1));
+        }
+        else {
+            obs = of(false);
+        }
+        return obs;
+    }), distinctUntilChanged(), shareReplay(1));
+    downloadUrlHasExpiredSignal = toSignal(this.downloadUrlHasExpired$);
+    downloadUrlHasExpiredEffect = effect(() => {
+        const expired = this.downloadUrlHasExpiredSignal();
+        if (expired) {
+            this.downloadUrlSignal.set(undefined);
+            this.downloadUrlExpiresAtSignal.set(undefined);
+        }
+    }, {
+        allowSignalWrites: true
+    });
+    // Output Effect
+    downloadUrlChangeEffect = effect(() => {
+        const downloadUrl = this.downloadUrlSignal();
+        this.downloadUrlChange.emit(downloadUrl);
+    });
+    // Handlers
+    handleGetDownloadUrl = (value) => {
+        return this.dbxFirebaseStorageFileDownloadService.downloadPairForStorageFile(value);
+    };
+    handleGetDownloadUrlSuccess = (value) => {
+        this.downloadUrlSignal.set(value.downloadUrl);
+        this.downloadUrlExpiresAtSignal.set(value.expiresAt);
+    };
+    handleGetDownloadUrlError = (error) => {
+        this.downloadUrlSignal.set(undefined);
+        this.downloadUrlExpiresAtSignal.set(undefined);
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileDownloadButton, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: DbxFirebaseStorageFileDownloadButton, isStandalone: true, selector: "dbx-firebase-storagefile-download-button", inputs: { storageFileKey: { classPropertyName: "storageFileKey", publicName: "storageFileKey", isSignal: true, isRequired: false, transformFunction: null }, storageFileDownloadUrl: { classPropertyName: "storageFileDownloadUrl", publicName: "storageFileDownloadUrl", isSignal: true, isRequired: false, transformFunction: null }, embedMimeType: { classPropertyName: "embedMimeType", publicName: "embedMimeType", isSignal: true, isRequired: false, transformFunction: null }, showPreviewButton: { classPropertyName: "showPreviewButton", publicName: "showPreviewButton", isSignal: true, isRequired: false, transformFunction: null }, config: { classPropertyName: "config", publicName: "config", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { downloadUrlChange: "downloadUrlChange" }, ngImport: i0, template: `
+    <dbx-anchor dbxActionAnchor [anchor]="anchorSignal()" dbxAction [dbxActionAutoTrigger]="preloadSignal()" dbxActionSnackbarError [dbxActionDisabled]="!storageFileKey()" [dbxActionValue]="storageFileKey" [dbxActionHandler]="handleGetDownloadUrl" [dbxActionSuccessHandler]="handleGetDownloadUrlSuccess" [dbxActionErrorHandler]="handleGetDownloadUrlError">
+      <dbx-button dbxActionButton [buttonStyle]="buttonStyleSignal()" [icon]="iconSignal()" [text]="textSignal()"></dbx-button>
+    </dbx-anchor>
+    @if (showPreviewButtonSignal()) {
+      <ng-container dbxAction [dbxActionDialog]="handleOpenPreviewDialog" dbxActionHandlerValue>
+        <span class="dbx-button-spacer"></span>
+        <dbx-button dbxActionButton [buttonStyle]="previewButtonStyleSignal()" [icon]="previewIconSignal()" [text]="previewTextSignal()"></dbx-button>
+      </ng-container>
+    }
+  `, isInline: true, dependencies: [{ kind: "component", type: DbxButtonComponent, selector: "dbx-button", inputs: ["bar", "type", "buttonStyle", "color", "spinnerColor", "customButtonColor", "customTextColor", "customSpinnerColor", "basic", "raised", "stroked", "flat", "iconOnly", "fab", "mode"] }, { kind: "ngmodule", type: DbxActionModule }, { kind: "directive", type: i1.DbxActionDirective, selector: "dbx-action,[dbxAction],dbx-action-context,[dbxActionContext]", exportAs: ["action", "dbxAction"] }, { kind: "directive", type: i1.DbxActionHandlerDirective, selector: "[dbxActionHandler]", inputs: ["dbxActionHandler"] }, { kind: "directive", type: i1.DbxActionHandlerValueDirective, selector: "[dbxActionHandlerValue]", inputs: ["dbxActionHandlerValue"] }, { kind: "directive", type: i1.DbxActionDisabledDirective, selector: "[dbxActionDisabled]", inputs: ["dbxActionDisabled"] }, { kind: "directive", type: i1.DbxActionAutoTriggerDirective, selector: "dbxActionAutoTrigger,[dbxActionAutoTrigger]", inputs: ["triggerDebounce", "triggerThrottle", "triggerErrorThrottle", "maxErrorsForThrottle", "triggerLimit", "dbxActionAutoTrigger", "useFastTriggerPreset", "useInstantTriggerPreset"] }, { kind: "directive", type: i1.DbxActionValueDirective, selector: "dbxActionValue,[dbxActionValue]", inputs: ["dbxActionValue"] }, { kind: "directive", type: i1.DbxActionSuccessHandlerDirective, selector: "[dbxActionSuccessHandler]", inputs: ["dbxActionSuccessHandler"] }, { kind: "directive", type: i1.DbxActionErrorHandlerDirective, selector: "[dbxActionErrorHandler]", inputs: ["dbxActionErrorHandler"] }, { kind: "directive", type: i1.DbxActionButtonDirective, selector: "[dbxActionButton]" }, { kind: "directive", type: DbxActionSnackbarErrorDirective, selector: "[dbxActionSnackbarError]", inputs: ["dbxActionSnackbarError"] }, { kind: "directive", type: DbxActionDialogDirective, selector: "[dbxActionDialog]", inputs: ["dbxActionDialog", "dbxActionDialogIsModified", "dbxActionDialogIsEqual"], exportAs: ["dbxActionDialog"] }, { kind: "component", type: DbxAnchorComponent, selector: "dbx-anchor, [dbx-anchor]", inputs: ["block"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileDownloadButton, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-firebase-storagefile-download-button',
+                    template: `
+    <dbx-anchor dbxActionAnchor [anchor]="anchorSignal()" dbxAction [dbxActionAutoTrigger]="preloadSignal()" dbxActionSnackbarError [dbxActionDisabled]="!storageFileKey()" [dbxActionValue]="storageFileKey" [dbxActionHandler]="handleGetDownloadUrl" [dbxActionSuccessHandler]="handleGetDownloadUrlSuccess" [dbxActionErrorHandler]="handleGetDownloadUrlError">
+      <dbx-button dbxActionButton [buttonStyle]="buttonStyleSignal()" [icon]="iconSignal()" [text]="textSignal()"></dbx-button>
+    </dbx-anchor>
+    @if (showPreviewButtonSignal()) {
+      <ng-container dbxAction [dbxActionDialog]="handleOpenPreviewDialog" dbxActionHandlerValue>
+        <span class="dbx-button-spacer"></span>
+        <dbx-button dbxActionButton [buttonStyle]="previewButtonStyleSignal()" [icon]="previewIconSignal()" [text]="previewTextSignal()"></dbx-button>
+      </ng-container>
+    }
+  `,
+                    imports: [DbxButtonComponent, DbxActionModule, DbxActionSnackbarErrorDirective, DbxActionDialogDirective, DbxAnchorComponent],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storagefile.download.button.component.js","sourceRoot":"","sources":["../../../../../../../../packages/dbx-firebase/src/lib/modules/storagefile/container/storagefile.download.button.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, computed, effect, inject, input, output, signal } from '@angular/core';\nimport { DbxActionDialogDirective, DbxActionDialogFunction, DbxActionModule, DbxActionSnackbarErrorDirective, DbxAnchorComponent, DbxButtonComponent, DbxButtonStyle, DbxEmbedDialogComponent } from '@dereekb/dbx-web';\nimport { StorageFileKey, StorageFilePublicDownloadUrl, StorageFileSignedDownloadUrl } from '@dereekb/firebase';\nimport { ContentTypeMimeType, dateFromDateOrTimeNumber, DateOrUnixTimeNumber, isPast, Maybe, MS_IN_SECOND } from '@dereekb/util';\nimport { DbxFirebaseStorageFileDownloadService } from '../service/storagefile.download.service';\nimport { ClickableAnchor } from '@dereekb/dbx-core';\nimport { WorkUsingObservable } from '@dereekb/rxjs';\nimport { toObservable, toSignal } from '@angular/core/rxjs-interop';\nimport { distinctUntilChanged, interval, map, Observable, of, shareReplay, switchMap } from 'rxjs';\nimport { DbxFirebaseStorageFileDownloadUrlPair } from '../service/storagefile.download.storage.service';\nimport { MatDialog } from '@angular/material/dialog';\n\n/**\n * Configuration for the DbxFirebaseStorageFileDownloadButton.\n */\nexport interface DbxFirebaseStorageFileDownloadButtonConfig {\n  readonly buttonStyle?: Maybe<DbxButtonStyle>;\n  readonly previewButtonStyle?: Maybe<DbxButtonStyle>;\n  /**\n   * Whether or not to pre-load the download url from the source.\n   */\n  readonly preload?: Maybe<boolean>;\n  /**\n   * Whether or not to show a preview button.\n   */\n  readonly showPreviewButton?: Maybe<boolean>;\n  readonly icon?: Maybe<string>;\n  readonly text?: Maybe<string>;\n  readonly downloadReadyIcon?: Maybe<string>;\n  readonly downloadReadyText?: Maybe<string>;\n  readonly previewIcon?: Maybe<string>;\n  readonly previewText?: Maybe<string>;\n}\n\n@Component({\n  selector: 'dbx-firebase-storagefile-download-button',\n  template: `\n    <dbx-anchor dbxActionAnchor [anchor]=\"anchorSignal()\" dbxAction [dbxActionAutoTrigger]=\"preloadSignal()\" dbxActionSnackbarError [dbxActionDisabled]=\"!storageFileKey()\" [dbxActionValue]=\"storageFileKey\" [dbxActionHandler]=\"handleGetDownloadUrl\" [dbxActionSuccessHandler]=\"handleGetDownloadUrlSuccess\" [dbxActionErrorHandler]=\"handleGetDownloadUrlError\">\n      <dbx-button dbxActionButton [buttonStyle]=\"buttonStyleSignal()\" [icon]=\"iconSignal()\" [text]=\"textSignal()\"></dbx-button>\n    </dbx-anchor>\n    @if (showPreviewButtonSignal()) {\n      <ng-container dbxAction [dbxActionDialog]=\"handleOpenPreviewDialog\" dbxActionHandlerValue>\n        <span class=\"dbx-button-spacer\"></span>\n        <dbx-button dbxActionButton [buttonStyle]=\"previewButtonStyleSignal()\" [icon]=\"previewIconSignal()\" [text]=\"previewTextSignal()\"></dbx-button>\n      </ng-container>\n    }\n  `,\n  imports: [DbxButtonComponent, DbxActionModule, DbxActionSnackbarErrorDirective, DbxActionDialogDirective, DbxAnchorComponent],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true\n})\nexport class DbxFirebaseStorageFileDownloadButton {\n  readonly dbxFirebaseStorageFileDownloadService = inject(DbxFirebaseStorageFileDownloadService);\n  readonly matDialog = inject(MatDialog);\n\n  /**\n   * The StorageFileKey to set up the download button for.\n   */\n  readonly storageFileKey = input<Maybe<StorageFileKey>>();\n\n  /**\n   * The download URL to use for the download button.\n   */\n  readonly storageFileDownloadUrl = input<Maybe<StorageFileSignedDownloadUrl | StorageFilePublicDownloadUrl>>();\n\n  /**\n   * The MIME type to use the embed component.\n   */\n  readonly embedMimeType = input<Maybe<ContentTypeMimeType | string>>();\n\n  /**\n   * Whether or not to show a preview button.\n   *\n   * Defaults to true.\n   */\n  readonly showPreviewButton = input<Maybe<boolean>>(true);\n\n  /**\n   * Output event emitted when the download URL changes.\n   */\n  readonly downloadUrlChange = output<Maybe<StorageFileSignedDownloadUrl>>();\n\n  readonly config = input<Maybe<DbxFirebaseStorageFileDownloadButtonConfig>>();\n\n  readonly configSignal = computed(() => {\n    const config = this.config();\n\n    const result: DbxFirebaseStorageFileDownloadButtonConfig = {\n      buttonStyle: config?.buttonStyle,\n      previewButtonStyle: config?.previewButtonStyle,\n      icon: config?.icon ?? 'cloud_download',\n      text: config?.text ?? 'Start Download',\n      downloadReadyIcon: config?.downloadReadyIcon ?? 'download',\n      downloadReadyText: config?.downloadReadyText ?? 'Save File',\n      previewIcon: config?.previewIcon ?? 'preview',\n      previewText: config?.previewText ?? 'View File'\n    };\n\n    return result;\n  });\n\n  readonly preloadSignal = computed(() => {\n    const config = this.configSignal();\n    return config.preload ?? false;\n  });\n\n  readonly downloadUrlSignal = signal<Maybe<StorageFileSignedDownloadUrl>>(undefined);\n  readonly downloadUrlExpiresAtSignal = signal<Maybe<DateOrUnixTimeNumber>>(undefined);\n\n  readonly storageFileKey$ = toObservable(this.storageFileKey).pipe(distinctUntilChanged(), shareReplay(1));\n\n  readonly hasDownloadUrlSignal = computed(() => Boolean(this.downloadUrlSignal()));\n\n  readonly buttonStyleSignal = computed(() => {\n    const config = this.configSignal();\n\n    const result: DbxButtonStyle = {\n      type: 'raised',\n      ...config.buttonStyle\n    };\n\n    return result;\n  });\n\n  readonly previewButtonStyleSignal = computed(() => {\n    const config = this.configSignal();\n\n    const result: DbxButtonStyle = {\n      type: 'raised',\n      ...config.previewButtonStyle\n    };\n\n    return result;\n  });\n\n  readonly iconSignal = computed(() => {\n    const config = this.configSignal();\n    const hasDownloadUrl = this.hasDownloadUrlSignal();\n    return hasDownloadUrl ? (config.downloadReadyIcon ?? config.icon) : config.icon;\n  });\n\n  readonly textSignal = computed(() => {\n    const config = this.configSignal();\n    const hasDownloadUrl = this.hasDownloadUrlSignal();\n    return hasDownloadUrl ? (config.downloadReadyText ?? config.text) : config.text;\n  });\n\n  readonly previewIconSignal = computed(() => {\n    const config = this.configSignal();\n    return config.previewIcon;\n  });\n\n  readonly previewTextSignal = computed(() => {\n    const config = this.configSignal();\n    return config.previewText;\n  });\n\n  readonly anchorSignal = computed(() => {\n    const downloadUrl = this.downloadUrlSignal();\n\n    let result: Maybe<ClickableAnchor>;\n\n    if (downloadUrl) {\n      result = {\n        url: downloadUrl\n      };\n    }\n\n    return result;\n  });\n\n  readonly storageFileDownloadUrlEffect = effect(\n    () => {\n      const downloadUrl = this.storageFileDownloadUrl();\n\n      if (downloadUrl || downloadUrl === null) {\n        this.downloadUrlSignal.set(downloadUrl);\n      }\n    },\n    {\n      allowSignalWrites: true\n    }\n  );\n\n  // Preview\n  readonly showPreviewButtonSignal = computed(() => {\n    const config = this.configSignal();\n    const hasDownloadUrl = this.hasDownloadUrlSignal();\n    return hasDownloadUrl && (config.showPreviewButton ?? true);\n  });\n\n  readonly handleOpenPreviewDialog: DbxActionDialogFunction = () => {\n    const srcUrl = this.downloadUrlSignal() as string;\n    const embedMimeType = this.embedMimeType();\n\n    return DbxEmbedDialogComponent.openDialog(this.matDialog, {\n      srcUrl,\n      embedMimeType,\n      sanitizeUrl: true\n    });\n  };\n\n  // Cached Url Effect\n  // When the key changes, check the cache to see if it is already available, and populate the download url if it is.\n  readonly cachedUrlForStorageFileKey$ = this.storageFileKey$.pipe(\n    switchMap((key) => (key ? this.dbxFirebaseStorageFileDownloadService.getCachedDownloadPairForStorageFile(key) : of(null))),\n    shareReplay(1)\n  );\n  readonly cachedUrlForStorageFileKeySignal = toSignal(this.cachedUrlForStorageFileKey$);\n\n  readonly cachedUrlEffect = effect(\n    () => {\n      const cachedPair = this.cachedUrlForStorageFileKeySignal();\n\n      if (cachedPair) {\n        this.downloadUrlSignal.set(cachedPair.downloadUrl);\n        this.downloadUrlExpiresAtSignal.set(cachedPair.expiresAt);\n      }\n    },\n    {\n      allowSignalWrites: true\n    }\n  );\n\n  // Expiration Effect\n  readonly downloadUrlExpiresAt$ = toObservable(this.downloadUrlExpiresAtSignal).pipe(map(dateFromDateOrTimeNumber), distinctUntilChanged(), shareReplay(1));\n\n  readonly downloadUrlHasExpired$ = this.downloadUrlExpiresAt$.pipe(\n    switchMap((x) => {\n      let obs: Observable<boolean>;\n\n      if (x) {\n        obs = interval(MS_IN_SECOND).pipe(\n          map(() => isPast(x)),\n          distinctUntilChanged(),\n          shareReplay(1)\n        );\n      } else {\n        obs = of(false);\n      }\n\n      return obs;\n    }),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly downloadUrlHasExpiredSignal = toSignal(this.downloadUrlHasExpired$);\n  readonly downloadUrlHasExpiredEffect = effect(\n    () => {\n      const expired = this.downloadUrlHasExpiredSignal();\n\n      if (expired) {\n        this.downloadUrlSignal.set(undefined);\n        this.downloadUrlExpiresAtSignal.set(undefined);\n      }\n    },\n    {\n      allowSignalWrites: true\n    }\n  );\n\n  // Output Effect\n  readonly downloadUrlChangeEffect = effect(() => {\n    const downloadUrl = this.downloadUrlSignal();\n    this.downloadUrlChange.emit(downloadUrl);\n  });\n\n  // Handlers\n  readonly handleGetDownloadUrl: WorkUsingObservable<StorageFileKey, DbxFirebaseStorageFileDownloadUrlPair> = (value: StorageFileKey) => {\n    return this.dbxFirebaseStorageFileDownloadService.downloadPairForStorageFile(value);\n  };\n\n  readonly handleGetDownloadUrlSuccess = (value: DbxFirebaseStorageFileDownloadUrlPair) => {\n    this.downloadUrlSignal.set(value.downloadUrl);\n    this.downloadUrlExpiresAtSignal.set(value.expiresAt);\n  };\n\n  readonly handleGetDownloadUrlError = (error: unknown) => {\n    this.downloadUrlSignal.set(undefined);\n    this.downloadUrlExpiresAtSignal.set(undefined);\n  };\n}\n"]}

package/esm2022/lib/modules/storagefile/index.mjs

@@ -1,4 +1,6 @@
 export * from './container';
 export * from './store';
+export * from './service';
 export * from './storagefile.upload.module';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZmlyZWJhc2Uvc3JjL2xpYi9tb2R1bGVzL3N0b3JhZ2VmaWxlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NvbnRhaW5lcic7XG5leHBvcnQgKiBmcm9tICcuL3N0b3JlJztcbmV4cG9ydCAqIGZyb20gJy4vc3RvcmFnZWZpbGUudXBsb2FkLm1vZHVsZSc7XG4iXX0=
+export * from './storagefile.providers';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZmlyZWJhc2Uvc3JjL2xpYi9tb2R1bGVzL3N0b3JhZ2VmaWxlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29udGFpbmVyJztcbmV4cG9ydCAqIGZyb20gJy4vc3RvcmUnO1xuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc3RvcmFnZWZpbGUudXBsb2FkLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL3N0b3JhZ2VmaWxlLnByb3ZpZGVycyc7XG4iXX0=

package/esm2022/lib/modules/storagefile/service/index.mjs

@@ -0,0 +1,3 @@
+export * from './storagefile.download.service';
+export * from './storagefile.download.storage.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZmlyZWJhc2Uvc3JjL2xpYi9tb2R1bGVzL3N0b3JhZ2VmaWxlL3NlcnZpY2UvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLHdDQUF3QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zdG9yYWdlZmlsZS5kb3dubG9hZC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc3RvcmFnZWZpbGUuZG93bmxvYWQuc3RvcmFnZS5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/lib/modules/storagefile/service/storagefile.download.service.mjs

@@ -0,0 +1,120 @@
+import { inject, Injectable } from '@angular/core';
+import { StorageFileFunctions, firestoreModelId, firestoreModelKey, storageFileIdentity } from '@dereekb/firebase';
+import { addMilliseconds, MS_IN_DAY, MS_IN_HOUR, MS_IN_MINUTE, SECONDS_IN_MINUTE, unixTimeNumberForNow, unixTimeNumberFromDate } from '@dereekb/util';
+import { DbxFirebaseStorageFileDownloadStorage } from './storagefile.download.storage.service';
+import { distinctUntilChanged, filter, first, from, interval, map, of, shareReplay, startWith, switchMap, tap } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Service used for retrieving download links for StorageFiles.
+ */
+export class DbxFirebaseStorageFileDownloadService {
+    /**
+     * Expiration duration for cached download URLs.
+     */
+    _expiresAfterTime = 3 * MS_IN_DAY;
+    /**
+     * When reading cached values, this buffer is added to the expiration time to prevent the URL from expiring while it is being used.
+     */
+    _expiresAfterTimeBuffer = SECONDS_IN_MINUTE * 10;
+    storageFileFunctions = inject(StorageFileFunctions);
+    storageFileDownloadStorage = inject(DbxFirebaseStorageFileDownloadStorage);
+    // MARK: Config
+    getExpiresAfterTime() {
+        return this._expiresAfterTime;
+    }
+    setExpiresAfterTime(expiresAfter) {
+        const maxAllowed = MS_IN_DAY * 20;
+        if (expiresAfter > maxAllowed) {
+            throw new Error(`Expires after time cannot be greater than 20 days.`);
+        }
+        else if (expiresAfter < MS_IN_HOUR) {
+            throw new Error(`Expires after time cannot be less than 1 hour.`);
+        }
+        this._expiresAfterTime = expiresAfter;
+    }
+    // MARK: Download
+    /**
+     * Returns an observable that returns the cached download URL pair for the StorageFile, and emits null once it expires.
+     *
+     * @param storageFileIdOrKey
+     * @returns
+     */
+    getCachedDownloadPairForStorageFile(storageFileIdOrKey) {
+        const storageFileId = firestoreModelId(storageFileIdOrKey);
+        return this.storageFileDownloadStorage.getDownloadUrlPair(storageFileId).pipe(switchMap((pair) => {
+            let result;
+            if (pair) {
+                const expiresAt = pair.expiresAt - this._expiresAfterTimeBuffer;
+                // every minute emit the result again
+                result = interval(MS_IN_MINUTE)
+                    .pipe(map(() => {
+                    const now = unixTimeNumberForNow();
+                    const isExpired = now > expiresAt;
+                    return isExpired ? null : pair; // emit null once expired
+                }))
+                    .pipe(filter((x) => x == null), first(), startWith(pair), distinctUntilChanged(), shareReplay(1));
+            }
+            else {
+                result = of(null);
+            }
+            return result;
+        }));
+    }
+    /**
+     * Retrieves the download URL for the StorageFile using the default parameters.
+     *
+     * These URLs are cached locally to prevent extra/redundant calls to the server.
+     *
+     * @param storageFileIdOrKey
+     * @returns
+     */
+    downloadPairForStorageFile(storageFileIdOrKey) {
+        const storageFileId = firestoreModelId(storageFileIdOrKey);
+        const obs = this.getCachedDownloadPairForStorageFile(storageFileId).pipe(switchMap((cachedPair) => {
+            let result;
+            const downloadAndCacheResult = () => {
+                const expiresAt = addMilliseconds(new Date(), this._expiresAfterTime);
+                return from(this.createDownloadPairForStorageFile(storageFileIdOrKey, { expiresAt })).pipe(tap((downloadUrlPair) => {
+                    // add to the cache
+                    this.storageFileDownloadStorage.addDownloadUrl(downloadUrlPair).pipe(first()).subscribe();
+                }));
+            };
+            if (cachedPair) {
+                result = of(cachedPair);
+            }
+            else {
+                result = downloadAndCacheResult();
+            }
+            return result;
+        }), first(), shareReplay(1));
+        return obs;
+    }
+    /**
+     * Creates a new download URL for the StorageFile.
+     *
+     * @param storageFileIdOrKey
+     * @param inputParams
+     * @returns
+     */
+    createDownloadPairForStorageFile(storageFileIdOrKey, inputParams) {
+        const storageFileId = firestoreModelId(storageFileIdOrKey);
+        const expiresAt = inputParams?.expiresAt ?? addMilliseconds(new Date(), this._expiresAfterTime);
+        const params = {
+            ...inputParams,
+            key: firestoreModelKey(storageFileIdentity, storageFileId)
+        };
+        return this.storageFileFunctions.storageFile.readStorageFile.download(params).then((x) => {
+            return {
+                id: storageFileId,
+                downloadUrl: x.url,
+                expiresAt: unixTimeNumberFromDate(expiresAt)
+            };
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileDownloadService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileDownloadService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileDownloadService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storagefile.download.service.js","sourceRoot":"","sources":["../../../../../../../../packages/dbx-firebase/src/lib/modules/storagefile/service/storagefile.download.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { StorageFileFunctions, DownloadStorageFileParams, StorageFileKey, StorageFileId, firestoreModelId, firestoreModelKey, storageFileIdentity } from '@dereekb/firebase';\nimport { addMilliseconds, Maybe, Milliseconds, MS_IN_DAY, MS_IN_HOUR, MS_IN_MINUTE, Seconds, SECONDS_IN_MINUTE, unixTimeNumberForNow, unixTimeNumberFromDate } from '@dereekb/util';\nimport { DbxFirebaseStorageFileDownloadStorage, DbxFirebaseStorageFileDownloadUrlPair } from './storagefile.download.storage.service';\nimport { distinctUntilChanged, filter, first, from, interval, map, Observable, of, shareReplay, startWith, switchMap, tap } from 'rxjs';\n\n/**\n * Service used for retrieving download links for StorageFiles.\n */\n@Injectable()\nexport class DbxFirebaseStorageFileDownloadService {\n  /**\n   * Expiration duration for cached download URLs.\n   */\n  protected _expiresAfterTime: Milliseconds = 3 * MS_IN_DAY;\n\n  /**\n   * When reading cached values, this buffer is added to the expiration time to prevent the URL from expiring while it is being used.\n   */\n  protected _expiresAfterTimeBuffer: Seconds = SECONDS_IN_MINUTE * 10;\n\n  readonly storageFileFunctions = inject(StorageFileFunctions);\n  readonly storageFileDownloadStorage = inject(DbxFirebaseStorageFileDownloadStorage);\n\n  // MARK: Config\n  getExpiresAfterTime(): number {\n    return this._expiresAfterTime;\n  }\n\n  setExpiresAfterTime(expiresAfter: number): void {\n    const maxAllowed = MS_IN_DAY * 20;\n\n    if (expiresAfter > maxAllowed) {\n      throw new Error(`Expires after time cannot be greater than 20 days.`);\n    } else if (expiresAfter < MS_IN_HOUR) {\n      throw new Error(`Expires after time cannot be less than 1 hour.`);\n    }\n\n    this._expiresAfterTime = expiresAfter;\n  }\n\n  // MARK: Download\n  /**\n   * Returns an observable that returns the cached download URL pair for the StorageFile, and emits null once it expires.\n   *\n   * @param storageFileIdOrKey\n   * @returns\n   */\n  getCachedDownloadPairForStorageFile(storageFileIdOrKey: StorageFileId | StorageFileKey): Observable<Maybe<DbxFirebaseStorageFileDownloadUrlPair>> {\n    const storageFileId = firestoreModelId(storageFileIdOrKey);\n    return this.storageFileDownloadStorage.getDownloadUrlPair(storageFileId).pipe(\n      switchMap((pair) => {\n        let result: Observable<Maybe<DbxFirebaseStorageFileDownloadUrlPair>>;\n\n        if (pair) {\n          const expiresAt = pair.expiresAt - this._expiresAfterTimeBuffer;\n\n          // every minute emit the result again\n          result = interval(MS_IN_MINUTE)\n            .pipe(\n              map(() => {\n                const now = unixTimeNumberForNow();\n                const isExpired = now > expiresAt;\n                return isExpired ? null : pair; // emit null once expired\n              })\n            )\n            .pipe(\n              filter((x) => x == null),\n              first(),\n              startWith(pair),\n              distinctUntilChanged(),\n              shareReplay(1)\n            );\n        } else {\n          result = of(null);\n        }\n\n        return result;\n      })\n    );\n  }\n\n  /**\n   * Retrieves the download URL for the StorageFile using the default parameters.\n   *\n   * These URLs are cached locally to prevent extra/redundant calls to the server.\n   *\n   * @param storageFileIdOrKey\n   * @returns\n   */\n  downloadPairForStorageFile(storageFileIdOrKey: StorageFileId | StorageFileKey): Observable<DbxFirebaseStorageFileDownloadUrlPair> {\n    const storageFileId = firestoreModelId(storageFileIdOrKey);\n    const obs: Observable<DbxFirebaseStorageFileDownloadUrlPair> = this.getCachedDownloadPairForStorageFile(storageFileId).pipe(\n      switchMap((cachedPair) => {\n        let result: Observable<DbxFirebaseStorageFileDownloadUrlPair>;\n\n        const downloadAndCacheResult = () => {\n          const expiresAt = addMilliseconds(new Date(), this._expiresAfterTime);\n          return from(this.createDownloadPairForStorageFile(storageFileIdOrKey, { expiresAt })).pipe(\n            tap((downloadUrlPair) => {\n              // add to the cache\n              this.storageFileDownloadStorage.addDownloadUrl(downloadUrlPair).pipe(first()).subscribe();\n            })\n          );\n        };\n\n        if (cachedPair) {\n          result = of(cachedPair);\n        } else {\n          result = downloadAndCacheResult();\n        }\n\n        return result;\n      }),\n      first(),\n      shareReplay(1)\n    );\n\n    return obs;\n  }\n\n  /**\n   * Creates a new download URL for the StorageFile.\n   *\n   * @param storageFileIdOrKey\n   * @param inputParams\n   * @returns\n   */\n  createDownloadPairForStorageFile(storageFileIdOrKey: StorageFileId | StorageFileKey, inputParams?: Omit<DownloadStorageFileParams, 'key'>): Promise<DbxFirebaseStorageFileDownloadUrlPair> {\n    const storageFileId = firestoreModelId(storageFileIdOrKey);\n    const expiresAt = inputParams?.expiresAt ?? addMilliseconds(new Date(), this._expiresAfterTime);\n\n    const params: DownloadStorageFileParams = {\n      ...inputParams,\n      key: firestoreModelKey(storageFileIdentity, storageFileId)\n    };\n\n    return this.storageFileFunctions.storageFile.readStorageFile.download(params).then((x) => {\n      return {\n        id: storageFileId,\n        downloadUrl: x.url,\n        expiresAt: unixTimeNumberFromDate(expiresAt)\n      };\n    });\n  }\n}\n"]}

package/esm2022/lib/modules/storagefile/service/storagefile.download.storage.service.mjs

@@ -0,0 +1,89 @@
+import { Injectable, InjectionToken, inject } from '@angular/core';
+import { map, mergeMap, catchError, of, switchMap, first } from 'rxjs';
+import { firestoreModelId } from '@dereekb/firebase';
+import { DbxFirebaseAuthService } from '../../../auth/service/firebase.auth.service';
+import * as i0 from "@angular/core";
+/**
+ * Token that corresponds to a StorageAccessor<DbxFirebaseStorageFileDownloadUserCache> that is used by DbxModelViewTrackerStorage.
+ */
+export const DBX_FIREBASE_STORAGEFILE_DOWNLOAD_STORAGE_ACCESSOR_TOKEN = new InjectionToken('DbxFirebaseStorageFileDownloadStorageAccessor');
+/**
+ * Used for managing DbxModelViewTrackerEvent storage.
+ */
+export class DbxFirebaseStorageFileDownloadStorage {
+    static DEFAULT_MAX_DOWNLOAD_URLS = 100;
+    authService = inject(DbxFirebaseAuthService);
+    storageAccessor = inject(DBX_FIREBASE_STORAGEFILE_DOWNLOAD_STORAGE_ACCESSOR_TOKEN);
+    addDownloadUrl({ id, downloadUrl, expiresAt }) {
+        return this.getCurrentUserDownloadCache().pipe(mergeMap((cache) => {
+            const { uid, pairs: currentPairs } = cache;
+            const storageKey = this.getStorageKeyForUid(uid);
+            const pairs = {
+                ...currentPairs,
+                [id]: `${expiresAt}_${downloadUrl}`
+            };
+            return this.storageAccessor.set(storageKey, {
+                uid,
+                pairs
+            });
+        }), first());
+    }
+    /**
+     * Returns the cached download URL pair for the given key.
+     *
+     * The pair may be expired.
+     *
+     * @param key
+     * @returns
+     */
+    getDownloadUrlPair(input) {
+        const id = firestoreModelId(input);
+        return this.authService.uid$.pipe(switchMap((uid) => {
+            return this.getUserDownloadCache(uid).pipe(map((cache) => {
+                const pair = cache?.pairs[id];
+                let result;
+                if (pair) {
+                    const [expiresAt, downloadUrl] = pair.split('_', 2);
+                    result = {
+                        id,
+                        downloadUrl,
+                        expiresAt: Number(expiresAt)
+                    };
+                }
+                return result;
+            }));
+        }), first());
+    }
+    getAllDownloadUrlPairsRecord(uid) {
+        return this.getUserDownloadCache(uid).pipe(map((x) => x.pairs));
+    }
+    getCurrentUserDownloadCache() {
+        return this.authService.uid$.pipe(switchMap((uid) => this.getUserDownloadCache(uid)));
+    }
+    getUserDownloadCache(uid) {
+        const storageKey = this.getStorageKeyForUid(uid);
+        return this._getUserDownloadCacheForStorageKey(storageKey, uid);
+    }
+    clearCurrentUserDownloadCache() {
+        return this.authService.uid$.pipe(switchMap((uid) => this.clearUserDownloadCache(uid)));
+    }
+    clearUserDownloadCache(uid) {
+        const storageKey = this.getStorageKeyForUid(uid);
+        return this.storageAccessor.remove(storageKey);
+    }
+    _getUserDownloadCacheForStorageKey(storageKey, uid) {
+        return this.storageAccessor.get(storageKey).pipe(catchError((e) => {
+            return of(undefined);
+        }), map((result) => result ?? { uid, pairs: {} }));
+    }
+    getStorageKeyForUid(uid) {
+        const storageKey = `sf_dl_cache_${uid}`;
+        return storageKey;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileDownloadStorage, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileDownloadStorage });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileDownloadStorage, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storagefile.download.storage.service.js","sourceRoot":"","sources":["../../../../../../../../packages/dbx-firebase/src/lib/modules/storagefile/service/storagefile.download.storage.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEnE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,UAAU,EAAc,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AACnF,OAAO,EAAsB,gBAAgB,EAAsE,MAAM,mBAAmB,CAAC;AAC7I,OAAO,EAAE,sBAAsB,EAAE,MAAM,6CAA6C,CAAC;;AAqBrF;;GAEG;AACH,MAAM,CAAC,MAAM,wDAAwD,GAAG,IAAI,cAAc,CAAC,+CAA+C,CAAC,CAAC;AAE5I;;GAEG;AAEH,MAAM,OAAO,qCAAqC;IAChD,MAAM,CAAU,yBAAyB,GAAG,GAAG,CAAC;IAEvC,WAAW,GAAG,MAAM,CAAC,sBAAsB,CAAC,CAAC;IAC7C,eAAe,GAAG,MAAM,CAA2D,wDAAwD,CAAC,CAAC;IAEtJ,cAAc,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,SAAS,EAAyC;QAClF,OAAO,IAAI,CAAC,2BAA2B,EAAE,CAAC,IAAI,CAC5C,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAE;YACjB,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,KAAK,CAAC;YAE3C,MAAM,UAAU,GAAG,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC;YACjD,MAAM,KAAK,GAAiD;gBAC1D,GAAG,YAAY;gBACf,CAAC,EAAE,CAAC,EAAE,GAAG,SAAS,IAAI,WAAW,EAAE;aACpC,CAAC;YAEF,OAAO,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,UAAU,EAAE;gBAC1C,GAAG;gBACH,KAAK;aACN,CAAC,CAAC;QACL,CAAC,CAAC,EACF,KAAK,EAAE,CACR,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACH,kBAAkB,CAAC,KAA4B;QAC7C,MAAM,EAAE,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;QACnC,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAC/B,SAAS,CAAC,CAAC,GAAG,EAAE,EAAE;YAChB,OAAO,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC,IAAI,CACxC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;gBACZ,MAAM,IAAI,GAAG,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC;gBAE9B,IAAI,MAAyD,CAAC;gBAE9D,IAAI,IAAI,EAAE,CAAC;oBACT,MAAM,CAAC,SAAS,EAAE,WAAW,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;oBAEpD,MAAM,GAAG;wBACP,EAAE;wBACF,WAAW;wBACX,SAAS,EAAE,MAAM,CAAC,SAAS,CAAC;qBAC7B,CAAC;gBACJ,CAAC;gBAED,OAAO,MAAM,CAAC;YAChB,CAAC,CAAC,CACH,CAAC;QACJ,CAAC,CAAC,EACF,KAAK,EAAE,CACR,CAAC;IACJ,CAAC;IAED,4BAA4B,CAAC,GAAuB;QAClD,OAAO,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IAClE,CAAC;IAED,2BAA2B;QACzB,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IACxF,CAAC;IAED,oBAAoB,CAAC,GAAuB;QAC1C,MAAM,UAAU,GAAG,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC;QACjD,OAAO,IAAI,CAAC,kCAAkC,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;IAClE,CAAC;IAED,6BAA6B;QAC3B,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC1F,CAAC;IAED,sBAAsB,CAAC,GAAuB;QAC5C,MAAM,UAAU,GAAG,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC;QACjD,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IACjD,CAAC;IAEO,kCAAkC,CAAC,UAAkB,EAAE,GAAuB;QACpF,OAAO,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,IAAI,CAC9C,UAAU,CAAC,CAAC,CAAC,EAAE,EAAE;YACf,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC;QACvB,CAAC,CAAC,EACF,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAC9C,CAAC;IACJ,CAAC;IAED,mBAAmB,CAAC,GAAuB;QACzC,MAAM,UAAU,GAAG,eAAe,GAAG,EAAE,CAAC;QACxC,OAAO,UAAU,CAAC;IACpB,CAAC;wGAhGU,qCAAqC;4GAArC,qCAAqC;;4FAArC,qCAAqC;kBADjD,UAAU","sourcesContent":["import { Injectable, InjectionToken, inject } from '@angular/core';\nimport { StorageAccessor } from '@dereekb/dbx-core';\nimport { map, mergeMap, catchError, Observable, of, switchMap, first } from 'rxjs';\nimport { FirebaseAuthUserId, firestoreModelId, FirestoreModelIdInput, StorageFileId, StorageFileSignedDownloadUrl } from '@dereekb/firebase';\nimport { DbxFirebaseAuthService } from '../../../auth/service/firebase.auth.service';\nimport { UnixTimeNumber } from '@dereekb/util';\n\nexport interface DbxFirebaseStorageFileDownloadUrlPair {\n  readonly id: StorageFileId;\n  readonly downloadUrl: StorageFileSignedDownloadUrl;\n  /**\n   * Expiration in seconds since epoch.\n   */\n  readonly expiresAt: UnixTimeNumber;\n}\n\nexport type DbxFirebaseStorageFileDownloadUrlPairString = `${UnixTimeNumber}_${StorageFileSignedDownloadUrl}`;\n\nexport type DbxFirebaseStorageFileDownloadUrlPairsRecord = Record<StorageFileId, DbxFirebaseStorageFileDownloadUrlPairString>;\n\nexport interface DbxFirebaseStorageFileDownloadUserCache {\n  readonly uid: FirebaseAuthUserId;\n  readonly pairs: DbxFirebaseStorageFileDownloadUrlPairsRecord;\n}\n\n/**\n * Token that corresponds to a StorageAccessor<DbxFirebaseStorageFileDownloadUserCache> that is used by DbxModelViewTrackerStorage.\n */\nexport const DBX_FIREBASE_STORAGEFILE_DOWNLOAD_STORAGE_ACCESSOR_TOKEN = new InjectionToken('DbxFirebaseStorageFileDownloadStorageAccessor');\n\n/**\n * Used for managing DbxModelViewTrackerEvent storage.\n */\n@Injectable()\nexport class DbxFirebaseStorageFileDownloadStorage {\n  static readonly DEFAULT_MAX_DOWNLOAD_URLS = 100;\n\n  readonly authService = inject(DbxFirebaseAuthService);\n  readonly storageAccessor = inject<StorageAccessor<DbxFirebaseStorageFileDownloadUserCache>>(DBX_FIREBASE_STORAGEFILE_DOWNLOAD_STORAGE_ACCESSOR_TOKEN);\n\n  addDownloadUrl({ id, downloadUrl, expiresAt }: DbxFirebaseStorageFileDownloadUrlPair): Observable<void> {\n    return this.getCurrentUserDownloadCache().pipe(\n      mergeMap((cache) => {\n        const { uid, pairs: currentPairs } = cache;\n\n        const storageKey = this.getStorageKeyForUid(uid);\n        const pairs: DbxFirebaseStorageFileDownloadUrlPairsRecord = {\n          ...currentPairs,\n          [id]: `${expiresAt}_${downloadUrl}`\n        };\n\n        return this.storageAccessor.set(storageKey, {\n          uid,\n          pairs\n        });\n      }),\n      first()\n    );\n  }\n\n  /**\n   * Returns the cached download URL pair for the given key.\n   *\n   * The pair may be expired.\n   *\n   * @param key\n   * @returns\n   */\n  getDownloadUrlPair(input: FirestoreModelIdInput): Observable<DbxFirebaseStorageFileDownloadUrlPair | undefined> {\n    const id = firestoreModelId(input);\n    return this.authService.uid$.pipe(\n      switchMap((uid) => {\n        return this.getUserDownloadCache(uid).pipe(\n          map((cache) => {\n            const pair = cache?.pairs[id];\n\n            let result: DbxFirebaseStorageFileDownloadUrlPair | undefined;\n\n            if (pair) {\n              const [expiresAt, downloadUrl] = pair.split('_', 2);\n\n              result = {\n                id,\n                downloadUrl,\n                expiresAt: Number(expiresAt)\n              };\n            }\n\n            return result;\n          })\n        );\n      }),\n      first()\n    );\n  }\n\n  getAllDownloadUrlPairsRecord(uid: FirebaseAuthUserId): Observable<DbxFirebaseStorageFileDownloadUrlPairsRecord> {\n    return this.getUserDownloadCache(uid).pipe(map((x) => x.pairs));\n  }\n\n  getCurrentUserDownloadCache(): Observable<DbxFirebaseStorageFileDownloadUserCache> {\n    return this.authService.uid$.pipe(switchMap((uid) => this.getUserDownloadCache(uid)));\n  }\n\n  getUserDownloadCache(uid: FirebaseAuthUserId): Observable<DbxFirebaseStorageFileDownloadUserCache> {\n    const storageKey = this.getStorageKeyForUid(uid);\n    return this._getUserDownloadCacheForStorageKey(storageKey, uid);\n  }\n\n  clearCurrentUserDownloadCache(): Observable<void> {\n    return this.authService.uid$.pipe(switchMap((uid) => this.clearUserDownloadCache(uid)));\n  }\n\n  clearUserDownloadCache(uid: FirebaseAuthUserId): Observable<void> {\n    const storageKey = this.getStorageKeyForUid(uid);\n    return this.storageAccessor.remove(storageKey);\n  }\n\n  private _getUserDownloadCacheForStorageKey(storageKey: string, uid: FirebaseAuthUserId): Observable<DbxFirebaseStorageFileDownloadUserCache> {\n    return this.storageAccessor.get(storageKey).pipe(\n      catchError((e) => {\n        return of(undefined);\n      }),\n      map((result) => result ?? { uid, pairs: {} })\n    );\n  }\n\n  getStorageKeyForUid(uid: FirebaseAuthUserId): string {\n    const storageKey = `sf_dl_cache_${uid}`;\n    return storageKey;\n  }\n}\n"]}

package/esm2022/lib/modules/storagefile/storagefile.providers.mjs

@@ -0,0 +1,33 @@
+import { makeEnvironmentProviders } from '@angular/core';
+import { SimpleStorageAccessorFactory } from '@dereekb/dbx-core';
+import { DBX_FIREBASE_STORAGEFILE_DOWNLOAD_STORAGE_ACCESSOR_TOKEN, DbxFirebaseStorageFileDownloadStorage } from './service/storagefile.download.storage.service';
+import { DbxFirebaseStorageFileDownloadService } from './service/storagefile.download.service';
+/**
+ * Factory function for creating a StorageAccessor for the model view tracker.
+ */
+export function defaultDbxFirebaseStorageFileDownloadStorageAccessorFactory(storageAccessorFactory) {
+    const accessor = storageAccessorFactory.createStorageAccessor({
+        prefix: 'sfds'
+    });
+    return accessor;
+}
+/**
+ * Creates EnvironmentProviders for providing DbxModelTrackerService, DbxModelObjectStateService and sets up the NgRx store for DbxModelTrackerEffects.
+ *
+ * @returns EnvironmentProviders
+ */
+export function provideDbxFirebaseStorageFileService() {
+    const providers = [
+        // Storage accessor
+        {
+            provide: DBX_FIREBASE_STORAGEFILE_DOWNLOAD_STORAGE_ACCESSOR_TOKEN,
+            useFactory: defaultDbxFirebaseStorageFileDownloadStorageAccessorFactory,
+            deps: [SimpleStorageAccessorFactory]
+        },
+        // Service
+        DbxFirebaseStorageFileDownloadStorage,
+        DbxFirebaseStorageFileDownloadService
+    ];
+    return makeEnvironmentProviders(providers);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZWZpbGUucHJvdmlkZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZGJ4LWZpcmViYXNlL3NyYy9saWIvbW9kdWxlcy9zdG9yYWdlZmlsZS9zdG9yYWdlZmlsZS5wcm92aWRlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUE0Qyx3QkFBd0IsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNuRyxPQUFPLEVBQUUsNEJBQTRCLEVBQXdCLE1BQU0sbUJBQW1CLENBQUM7QUFDdkYsT0FBTyxFQUFFLHdEQUF3RCxFQUFFLHFDQUFxQyxFQUFnRCxNQUFNLGdEQUFnRCxDQUFDO0FBQy9NLE9BQU8sRUFBRSxxQ0FBcUMsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBRS9GOztHQUVHO0FBQ0gsTUFBTSxVQUFVLDJEQUEyRCxDQUFDLHNCQUFvRDtJQUM5SCxNQUFNLFFBQVEsR0FBRyxzQkFBc0IsQ0FBQyxxQkFBcUIsQ0FBMEM7UUFDckcsTUFBTSxFQUFFLE1BQU07S0FDZixDQUFDLENBQUM7SUFFSCxPQUFPLFFBQVEsQ0FBQztBQUNsQixDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxvQ0FBb0M7SUFDbEQsTUFBTSxTQUFTLEdBQXdDO1FBQ3JELG1CQUFtQjtRQUNuQjtZQUNFLE9BQU8sRUFBRSx3REFBd0Q7WUFDakUsVUFBVSxFQUFFLDJEQUEyRDtZQUN2RSxJQUFJLEVBQUUsQ0FBQyw0QkFBNEIsQ0FBQztTQUNyQztRQUNELFVBQVU7UUFDVixxQ0FBcUM7UUFDckMscUNBQXFDO0tBQ3RDLENBQUM7SUFFRixPQUFPLHdCQUF3QixDQUFDLFNBQVMsQ0FBQyxDQUFDO0FBQzdDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyB0eXBlIEVudmlyb25tZW50UHJvdmlkZXJzLCB0eXBlIFByb3ZpZGVyLCBtYWtlRW52aXJvbm1lbnRQcm92aWRlcnMgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFNpbXBsZVN0b3JhZ2VBY2Nlc3NvckZhY3RvcnksIHR5cGUgU3RvcmFnZUFjY2Vzc29yIH0gZnJvbSAnQGRlcmVla2IvZGJ4LWNvcmUnO1xuaW1wb3J0IHsgREJYX0ZJUkVCQVNFX1NUT1JBR0VGSUxFX0RPV05MT0FEX1NUT1JBR0VfQUNDRVNTT1JfVE9LRU4sIERieEZpcmViYXNlU3RvcmFnZUZpbGVEb3dubG9hZFN0b3JhZ2UsIHR5cGUgRGJ4RmlyZWJhc2VTdG9yYWdlRmlsZURvd25sb2FkVXNlckNhY2hlIH0gZnJvbSAnLi9zZXJ2aWNlL3N0b3JhZ2VmaWxlLmRvd25sb2FkLnN0b3JhZ2Uuc2VydmljZSc7XG5pbXBvcnQgeyBEYnhGaXJlYmFzZVN0b3JhZ2VGaWxlRG93bmxvYWRTZXJ2aWNlIH0gZnJvbSAnLi9zZXJ2aWNlL3N0b3JhZ2VmaWxlLmRvd25sb2FkLnNlcnZpY2UnO1xuXG4vKipcbiAqIEZhY3RvcnkgZnVuY3Rpb24gZm9yIGNyZWF0aW5nIGEgU3RvcmFnZUFjY2Vzc29yIGZvciB0aGUgbW9kZWwgdmlldyB0cmFja2VyLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZGVmYXVsdERieEZpcmViYXNlU3RvcmFnZUZpbGVEb3dubG9hZFN0b3JhZ2VBY2Nlc3NvckZhY3Rvcnkoc3RvcmFnZUFjY2Vzc29yRmFjdG9yeTogU2ltcGxlU3RvcmFnZUFjY2Vzc29yRmFjdG9yeSk6IFN0b3JhZ2VBY2Nlc3NvcjxEYnhGaXJlYmFzZVN0b3JhZ2VGaWxlRG93bmxvYWRVc2VyQ2FjaGU+IHtcbiAgY29uc3QgYWNjZXNzb3IgPSBzdG9yYWdlQWNjZXNzb3JGYWN0b3J5LmNyZWF0ZVN0b3JhZ2VBY2Nlc3NvcjxEYnhGaXJlYmFzZVN0b3JhZ2VGaWxlRG93bmxvYWRVc2VyQ2FjaGU+KHtcbiAgICBwcmVmaXg6ICdzZmRzJ1xuICB9KTtcblxuICByZXR1cm4gYWNjZXNzb3I7XG59XG5cbi8qKlxuICogQ3JlYXRlcyBFbnZpcm9ubWVudFByb3ZpZGVycyBmb3IgcHJvdmlkaW5nIERieE1vZGVsVHJhY2tlclNlcnZpY2UsIERieE1vZGVsT2JqZWN0U3RhdGVTZXJ2aWNlIGFuZCBzZXRzIHVwIHRoZSBOZ1J4IHN0b3JlIGZvciBEYnhNb2RlbFRyYWNrZXJFZmZlY3RzLlxuICpcbiAqIEByZXR1cm5zIEVudmlyb25tZW50UHJvdmlkZXJzXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBwcm92aWRlRGJ4RmlyZWJhc2VTdG9yYWdlRmlsZVNlcnZpY2UoKTogRW52aXJvbm1lbnRQcm92aWRlcnMge1xuICBjb25zdCBwcm92aWRlcnM6IChQcm92aWRlciB8IEVudmlyb25tZW50UHJvdmlkZXJzKVtdID0gW1xuICAgIC8vIFN0b3JhZ2UgYWNjZXNzb3JcbiAgICB7XG4gICAgICBwcm92aWRlOiBEQlhfRklSRUJBU0VfU1RPUkFHRUZJTEVfRE9XTkxPQURfU1RPUkFHRV9BQ0NFU1NPUl9UT0tFTixcbiAgICAgIHVzZUZhY3Rvcnk6IGRlZmF1bHREYnhGaXJlYmFzZVN0b3JhZ2VGaWxlRG93bmxvYWRTdG9yYWdlQWNjZXNzb3JGYWN0b3J5LFxuICAgICAgZGVwczogW1NpbXBsZVN0b3JhZ2VBY2Nlc3NvckZhY3RvcnldXG4gICAgfSxcbiAgICAvLyBTZXJ2aWNlXG4gICAgRGJ4RmlyZWJhc2VTdG9yYWdlRmlsZURvd25sb2FkU3RvcmFnZSxcbiAgICBEYnhGaXJlYmFzZVN0b3JhZ2VGaWxlRG93bmxvYWRTZXJ2aWNlXG4gIF07XG5cbiAgcmV0dXJuIG1ha2VFbnZpcm9ubWVudFByb3ZpZGVycyhwcm92aWRlcnMpO1xufVxuIl19

package/esm2022/lib/modules/storagefile/store/storagefile.document.store.mjs

@@ -1,5 +1,5 @@
 import { Injectable, inject } from '@angular/core';
-import { AbstractDbxFirebaseDocumentStore, firebaseDocumentStoreCreateFunction, firebaseDocumentStoreCrudFunction, firebaseDocumentStoreDeleteFunction, firebaseDocumentStoreUpdateFunction } from '../../../model/modules/store';
+import { AbstractDbxFirebaseDocumentStore, firebaseDocumentStoreCreateFunction, firebaseDocumentStoreCrudFunction, firebaseDocumentStoreDeleteFunction, firebaseDocumentStoreReadFunction, firebaseDocumentStoreUpdateFunction } from '../../../model/modules/store';
 import { StorageFileFirestoreCollections, StorageFileFunctions } from '@dereekb/firebase';
 import * as i0 from "@angular/core";
 export class StorageFileDocumentStore extends AbstractDbxFirebaseDocumentStore {
@@ -13,10 +13,11 @@ export class StorageFileDocumentStore extends AbstractDbxFirebaseDocumentStore {
     updateStorageFile = firebaseDocumentStoreUpdateFunction(this, this.storageFileFunctions.storageFile.updateStorageFile.update);
     processStorageFile = firebaseDocumentStoreUpdateFunction(this, this.storageFileFunctions.storageFile.updateStorageFile.process);
     deleteStorageFile = firebaseDocumentStoreDeleteFunction(this, this.storageFileFunctions.storageFile.deleteStorageFile.delete);
+    downloadStorageFile = firebaseDocumentStoreReadFunction(this, this.storageFileFunctions.storageFile.readStorageFile.download);
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StorageFileDocumentStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StorageFileDocumentStore });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StorageFileDocumentStore, decorators: [{
             type: Injectable
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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