@dereekb/dbx-firebase 12.4.5 → 12.5.1

package/esm2022/lib/modules/storagefile/container/storagefile.upload.handler.mjs

@@ -0,0 +1,260 @@
+import { catchError, map, Observable, of, shareReplay } from 'rxjs';
+import { runAsyncTasksForValues, separateValues } from '@dereekb/util';
+import { MultiSubscriptionObject } from '@dereekb/rxjs';
+/**
+ * Default implementation of StorageFileUploadHandler.
+ */
+export function storageFileUploadHandler(config) {
+    const { storageService, storageFileUploadConfigFactory } = config;
+    let resumable;
+    return {
+        uploadFile: async (file) => {
+            const storageFileUploadConfig = await storageFileUploadConfigFactory(file);
+            const { storagePath } = storageFileUploadConfig;
+            const storageAccessorFile = storageService.file(storagePath);
+            const upload = new Observable((x) => {
+                if (storageAccessorFile.uploadResumable) {
+                    resumable = storageAccessorFile.uploadResumable(file);
+                    // subscribe to the event by piping this observable to it
+                    resumable
+                        .streamSnapshotEvents()
+                        .pipe(map((x) => {
+                        const { bytesTransferred, totalBytes } = x;
+                        const progress = {
+                            file,
+                            fileRef: storageAccessorFile,
+                            uploadRef: resumable,
+                            bytesTransferred,
+                            totalBytes,
+                            progress: bytesTransferred / totalBytes
+                        };
+                        return progress;
+                    }))
+                        .pipe(catchError((error) => {
+                        // if an error occurs, catch it and emit it as a progress
+                        const progress = {
+                            file,
+                            fileRef: storageAccessorFile,
+                            uploadRef: resumable,
+                            error,
+                            failed: true
+                        };
+                        return of(progress);
+                    }))
+                        .subscribe(x);
+                }
+                else {
+                    throw new Error('uploadResumable() function was unavailable.');
+                }
+            }).pipe(shareReplay(1));
+            const instance = {
+                upload,
+                taskRef: storageAccessorFile,
+                pause: () => resumable?.pause() ?? false,
+                resume: () => resumable?.resume() ?? false,
+                cancel: () => resumable?.cancel() ?? false
+            };
+            return instance;
+        }
+    };
+}
+/**
+ * Uploads files using the provided upload handler and files.
+ *
+ * An observable is returned that emits the latest file events from any file that is being uploaded.
+ *
+ * @param input
+ * @returns
+ */
+export function storageFileUploadFiles(input) {
+    const { uploadHandler, files, maxParallelUploads: inputMaxParallelUploads } = input;
+    const maxParallelTasks = inputMaxParallelUploads ?? 3;
+    const multiUploadsSubscriptionObject = new MultiSubscriptionObject();
+    // begin the upload for each file
+    const allFiles = Array.from(files);
+    // unsubscribe from all previous uploads
+    multiUploadsSubscriptionObject.unsub();
+    const allFilesAndLatestProgress = new Array(allFiles.length);
+    const allFilesAndDetails = allFiles.map((file) => ({ file }));
+    const overallProgressPerCompletedFile = (1 / allFilesAndLatestProgress.length);
+    /**
+     * Once set, any new file upload task that hits this will return an cancel failure.
+     */
+    let flaggedCancel = false;
+    const cancel = () => {
+        flaggedCancel = true;
+    };
+    const upload = new Observable((subscriber) => {
+        const overallStartTime = new Date();
+        const incompleteFileFileIndexes = new Set(allFiles.map((_, index) => index));
+        const activeFileIndexes = new Set();
+        const doneFileIndexes = new Set();
+        let latestOverallProgress = 0;
+        function onStartFileUpload(index, uploadInstance) {
+            activeFileIndexes.add(index);
+            allFilesAndDetails[index].startTime = new Date();
+            allFilesAndDetails[index].uploadInstance = uploadInstance;
+            allFilesAndDetails[index].fileRef = uploadInstance.taskRef;
+        }
+        function onStartFileUploadFlaggedCancelled(index) {
+            allFilesAndDetails[index].startTime = new Date();
+            // immediately mark it done
+            _markFileUploadDone(index, true);
+            // emit new progress event
+            _emitEvent();
+        }
+        function _markFileUploadDone(fileIndex, finalError) {
+            doneFileIndexes.add(fileIndex); // add to done file indexes
+            activeFileIndexes.delete(fileIndex); // remove from active file indexes if it exists
+            incompleteFileFileIndexes.delete(fileIndex); // remove from incomplete file indexes
+            // update details
+            allFilesAndDetails[fileIndex].endTime = new Date();
+            const error = finalError ?? allFilesAndDetails[fileIndex].error;
+            allFilesAndDetails[fileIndex].success = !error;
+            allFilesAndDetails[fileIndex].error = error;
+        }
+        function updateUploadProgress(input) {
+            const { index: fileIndex, nextProgress, fileUploadTaskDone: inputFileUploadTaskDone, nonProgressError } = input;
+            const error = nonProgressError ?? nextProgress?.error;
+            const fileUploadTaskDone = inputFileUploadTaskDone ?? Boolean(error);
+            // the task may already be done, as after a progress-related error the complete task can get called.
+            const isTaskAlreadyDone = allFilesAndDetails[fileIndex].endTime != null;
+            if (!isTaskAlreadyDone) {
+                let nextOverallProgress = latestOverallProgress;
+                const nextProgressPercent = fileUploadTaskDone ? 100 : (nextProgress?.progress ?? 0) * 100;
+                // update the overall progress percentage
+                if (nextProgressPercent) {
+                    // update the overall percentage
+                    const previousProgress = allFilesAndLatestProgress[fileIndex];
+                    const previousProgressPercent = previousProgress?.progress != null ? previousProgress.progress * 100 : 0;
+                    const progressPercentChange = nextProgressPercent - previousProgressPercent;
+                    // increase overall progress by the change
+                    nextOverallProgress += progressPercentChange * overallProgressPerCompletedFile;
+                }
+                // update the file progress
+                if (nextProgress) {
+                    // update the latest FileProgress
+                    allFilesAndLatestProgress[fileIndex] = nextProgress;
+                    // only set fileRef once
+                    if (!allFilesAndDetails[fileIndex].fileRef) {
+                        allFilesAndDetails[fileIndex].fileRef = nextProgress.fileRef;
+                    }
+                }
+                // if complete, update the indexes and details
+                if (fileUploadTaskDone) {
+                    _markFileUploadDone(fileIndex, error);
+                }
+                // update the overall progress
+                latestOverallProgress = nextOverallProgress;
+                // emit the event to send it
+                _emitEvent(nextProgress);
+            }
+        }
+        function _emitEvent(nextProgress) {
+            const isComplete = incompleteFileFileIndexes.size === 0;
+            let overallProgress = latestOverallProgress;
+            let result = undefined;
+            if (isComplete) {
+                overallProgress = 100; // set to 100%
+                const overallEndTime = new Date();
+                const fileResults = allFiles.map((file, index) => {
+                    const result = {
+                        startTime: allFilesAndDetails[index].startTime,
+                        endTime: allFilesAndDetails[index].endTime,
+                        file,
+                        fileRef: allFilesAndDetails[index].fileRef,
+                        success: !allFilesAndDetails[index].error,
+                        error: allFilesAndDetails[index].error
+                    };
+                    return result;
+                });
+                const { included: successFileResults, excluded: errorFileResults } = separateValues(fileResults, (x) => x.success);
+                // all are done, set the result on the next event
+                result = {
+                    startTime: overallStartTime,
+                    endTime: overallEndTime,
+                    successFileResults,
+                    errorFileResults,
+                    fileResults
+                };
+            }
+            const nextEvent = {
+                allFiles,
+                isComplete,
+                overallProgress,
+                uploadProgress: nextProgress,
+                incompleteFileCount: incompleteFileFileIndexes.size,
+                activeFileCount: activeFileIndexes.size,
+                doneFileCount: doneFileIndexes.size,
+                result
+            };
+            subscriber.next(nextEvent);
+        }
+        async function runUploadTaskForFile([file, index]) {
+            if (flaggedCancel) {
+                onStartFileUploadFlaggedCancelled(index);
+                return Promise.resolve();
+            }
+            return new Promise((resolve) => {
+                const updateFileUploadProgress = (nextProgress) => {
+                    // update the progress
+                    updateUploadProgress({
+                        index,
+                        nextProgress
+                    });
+                };
+                const updateFileUploadProgressWithUncaughtError = (error) => {
+                    // error occurred, update the progress with the error
+                    updateUploadProgress({
+                        index,
+                        nonProgressError: error,
+                        fileUploadTaskDone: true
+                    });
+                    // always resolve, never reject
+                    resolve();
+                };
+                const completeFileUploadProgress = () => {
+                    updateUploadProgress({
+                        index,
+                        fileUploadTaskDone: true
+                    });
+                    resolve();
+                };
+                // upload the file, subscribe to the progress
+                try {
+                    uploadHandler
+                        .uploadFile(file)
+                        .then((uploadInstance) => {
+                        // add to active file indexes
+                        onStartFileUpload(index, uploadInstance);
+                        const uploadSubscription = uploadInstance.upload.subscribe({
+                            next: updateFileUploadProgress,
+                            error: updateFileUploadProgressWithUncaughtError,
+                            complete: completeFileUploadProgress
+                        });
+                        multiUploadsSubscriptionObject.addSubs(uploadSubscription);
+                    })
+                        .catch(updateFileUploadProgressWithUncaughtError);
+                }
+                catch (error) {
+                    updateFileUploadProgressWithUncaughtError(error);
+                }
+            });
+        }
+        // run upload task for each file
+        const fileTuples = allFiles.map((file, index) => [file, index]);
+        runAsyncTasksForValues(fileTuples, runUploadTaskForFile, {
+            maxParallelTasks,
+            retriesAllowed: 0 // no retries allowed
+        }).then(() => {
+            // all tasks are finished. Complete the subscriber.
+            subscriber.complete();
+        });
+    }).pipe(shareReplay(1));
+    const instance = {
+        cancel,
+        upload
+    };
+    return instance;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storagefile.upload.handler.js","sourceRoot":"","sources":["../../../../../../../../packages/dbx-firebase/src/lib/modules/storagefile/container/storagefile.upload.handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,EAAE,EAAE,EAAE,WAAW,EAAE,MAAM,MAAM,CAAC;AAGpE,OAAO,EAAqE,sBAAsB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC1I,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAqExD;;GAEG;AACH,MAAM,UAAU,wBAAwB,CAAC,MAAsC;IAC7E,MAAM,EAAE,cAAc,EAAE,8BAA8B,EAAE,GAAG,MAAM,CAAC;IAElE,IAAI,SAAmC,CAAC;IAExC,OAAO;QACL,UAAU,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;YACzB,MAAM,uBAAuB,GAAG,MAAM,8BAA8B,CAAC,IAAI,CAAC,CAAC;YAE3E,MAAM,EAAE,WAAW,EAAE,GAAG,uBAAuB,CAAC;YAChD,MAAM,mBAAmB,GAAG,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAE7D,MAAM,MAAM,GAAG,IAAI,UAAU,CAAgD,CAAC,CAAC,EAAE,EAAE;gBACjF,IAAI,mBAAmB,CAAC,eAAe,EAAE,CAAC;oBACxC,SAAS,GAAG,mBAAmB,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;oBAEtD,yDAAyD;oBACzD,SAAS;yBACN,oBAAoB,EAAE;yBACtB,IAAI,CACH,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;wBACR,MAAM,EAAE,gBAAgB,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;wBAE3C,MAAM,QAAQ,GAAkD;4BAC9D,IAAI;4BACJ,OAAO,EAAE,mBAAmB;4BAC5B,SAAS,EAAE,SAAS;4BACpB,gBAAgB;4BAChB,UAAU;4BACV,QAAQ,EAAE,gBAAgB,GAAG,UAAU;yBACxC,CAAC;wBAEF,OAAO,QAAQ,CAAC;oBAClB,CAAC,CAAC,CACH;yBACA,IAAI,CACH,UAAU,CAAC,CAAC,KAAK,EAAE,EAAE;wBACnB,yDAAyD;wBACzD,MAAM,QAAQ,GAAkD;4BAC9D,IAAI;4BACJ,OAAO,EAAE,mBAAmB;4BAC5B,SAAS,EAAE,SAAS;4BACpB,KAAK;4BACL,MAAM,EAAE,IAAI;yBACb,CAAC;wBAEF,OAAO,EAAE,CAAC,QAAQ,CAAC,CAAC;oBACtB,CAAC,CAAC,CACH;yBACA,SAAS,CAAC,CAAC,CAAC,CAAC;gBAClB,CAAC;qBAAM,CAAC;oBACN,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;gBACjE,CAAC;YACH,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;YAExB,MAAM,QAAQ,GAAqC;gBACjD,MAAM;gBACN,OAAO,EAAE,mBAAmB;gBAC5B,KAAK,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE,KAAK,EAAE,IAAI,KAAK;gBACxC,MAAM,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,KAAK;gBAC1C,MAAM,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,KAAK;aAC3C,CAAC;YAEF,OAAO,QAAQ,CAAC;QAClB,CAAC;KACF,CAAC;AACJ,CAAC;AAkHD;;;;;;;GAOG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAkC;IACvE,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,GAAG,KAAK,CAAC;IACpF,MAAM,gBAAgB,GAAG,uBAAuB,IAAI,CAAC,CAAC;IAEtD,MAAM,8BAA8B,GAAG,IAAI,uBAAuB,EAAE,CAAC;IAErE,iCAAiC;IACjC,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAEnC,wCAAwC;IACxC,8BAA8B,CAAC,KAAK,EAAE,CAAC;IA+CvC,MAAM,yBAAyB,GAA2D,IAAI,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IACrH,MAAM,kBAAkB,GAAwB,QAAQ,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IACnF,MAAM,+BAA+B,GAAmB,CAAC,CAAC,GAAG,yBAAyB,CAAC,MAAM,CAAmB,CAAC;IAEjH;;OAEG;IACH,IAAI,aAAa,GAAG,KAAK,CAAC;IAE1B,MAAM,MAAM,GAAG,GAAG,EAAE;QAClB,aAAa,GAAG,IAAI,CAAC;IACvB,CAAC,CAAC;IAEF,MAAM,MAAM,GAAG,IAAI,UAAU,CAA8B,CAAC,UAAU,EAAE,EAAE;QACxE,MAAM,gBAAgB,GAAG,IAAI,IAAI,EAAE,CAAC;QAEpC,MAAM,yBAAyB,GAAG,IAAI,GAAG,CAAc,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;QAC1F,MAAM,iBAAiB,GAAG,IAAI,GAAG,EAAe,CAAC;QACjD,MAAM,eAAe,GAAG,IAAI,GAAG,EAAe,CAAC;QAC/C,IAAI,qBAAqB,GAAkB,CAAC,CAAC;QAE7C,SAAS,iBAAiB,CAAC,KAAkB,EAAE,cAAgD;YAC7F,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YAC7B,kBAAkB,CAAC,KAAK,CAAC,CAAC,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC;YACjD,kBAAkB,CAAC,KAAK,CAAC,CAAC,cAAc,GAAG,cAAc,CAAC;YAC1D,kBAAkB,CAAC,KAAK,CAAC,CAAC,OAAO,GAAG,cAAc,CAAC,OAAO,CAAC;QAC7D,CAAC;QAED,SAAS,iCAAiC,CAAC,KAAkB;YAC3D,kBAAkB,CAAC,KAAK,CAAC,CAAC,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC;YAEjD,2BAA2B;YAC3B,mBAAmB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;YAEjC,0BAA0B;YAC1B,UAAU,EAAE,CAAC;QACf,CAAC;QAED,SAAS,mBAAmB,CAAC,SAAsB,EAAE,UAA2B;YAC9E,eAAe,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,2BAA2B;YAC3D,iBAAiB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,+CAA+C;YACpF,yBAAyB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,sCAAsC;YAEnF,iBAAiB;YACjB,kBAAkB,CAAC,SAAS,CAAC,CAAC,OAAO,GAAG,IAAI,IAAI,EAAE,CAAC;YAEnD,MAAM,KAAK,GAAG,UAAU,IAAI,kBAAkB,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC;YAChE,kBAAkB,CAAC,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,KAAK,CAAC;YAC/C,kBAAkB,CAAC,SAAS,CAAC,CAAC,KAAK,GAAG,KAAK,CAAC;QAC9C,CAAC;QAED,SAAS,oBAAoB,CAAC,KAAgC;YAC5D,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,GAAG,KAAK,CAAC;YAChH,MAAM,KAAK,GAAG,gBAAgB,IAAI,YAAY,EAAE,KAAK,CAAC;YACtD,MAAM,kBAAkB,GAAG,uBAAuB,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC;YAErE,oGAAoG;YACpG,MAAM,iBAAiB,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC,OAAO,IAAI,IAAI,CAAC;YAExE,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACvB,IAAI,mBAAmB,GAAG,qBAAqB,CAAC;gBAChD,MAAM,mBAAmB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,EAAE,QAAQ,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC;gBAE3F,yCAAyC;gBACzC,IAAI,mBAAmB,EAAE,CAAC;oBACxB,gCAAgC;oBAChC,MAAM,gBAAgB,GAAG,yBAAyB,CAAC,SAAS,CAAC,CAAC;oBAC9D,MAAM,uBAAuB,GAAG,gBAAgB,EAAE,QAAQ,IAAI,IAAI,CAAC,CAAC,CAAC,gBAAgB,CAAC,QAAQ,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;oBACzG,MAAM,qBAAqB,GAAG,mBAAmB,GAAG,uBAAuB,CAAC;oBAE5E,0CAA0C;oBAC1C,mBAAmB,IAAI,qBAAqB,GAAG,+BAA+B,CAAC;gBACjF,CAAC;gBAED,2BAA2B;gBAC3B,IAAI,YAAY,EAAE,CAAC;oBACjB,iCAAiC;oBACjC,yBAAyB,CAAC,SAAS,CAAC,GAAG,YAAY,CAAC;oBAEpD,wBAAwB;oBACxB,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,CAAC;wBAC3C,kBAAkB,CAAC,SAAS,CAAC,CAAC,OAAO,GAAG,YAAY,CAAC,OAAO,CAAC;oBAC/D,CAAC;gBACH,CAAC;gBAED,8CAA8C;gBAC9C,IAAI,kBAAkB,EAAE,CAAC;oBACvB,mBAAmB,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;gBACxC,CAAC;gBAED,8BAA8B;gBAC9B,qBAAqB,GAAG,mBAAmB,CAAC;gBAE5C,4BAA4B;gBAC5B,UAAU,CAAC,YAAY,CAAC,CAAC;YAC3B,CAAC;QACH,CAAC;QAED,SAAS,UAAU,CAAC,YAAmE;YACrF,MAAM,UAAU,GAAG,yBAAyB,CAAC,IAAI,KAAK,CAAC,CAAC;YAExD,IAAI,eAAe,GAAG,qBAAqB,CAAC;YAC5C,IAAI,MAAM,GAA6C,SAAS,CAAC;YAEjE,IAAI,UAAU,EAAE,CAAC;gBACf,eAAe,GAAG,GAAG,CAAC,CAAC,cAAc;gBACrC,MAAM,cAAc,GAAG,IAAI,IAAI,EAAE,CAAC;gBAElC,MAAM,WAAW,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;oBAC/C,MAAM,MAAM,GAA0C;wBACpD,SAAS,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAC,SAAiB;wBACtD,OAAO,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAC,OAAe;wBAClD,IAAI;wBACJ,OAAO,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAC,OAAO;wBAC1C,OAAO,EAAE,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,KAAK;wBACzC,KAAK,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAC,KAAK;qBACvC,CAAC;oBAEF,OAAO,MAAM,CAAC;gBAChB,CAAC,CAAC,CAAC;gBAEH,MAAM,EAAE,QAAQ,EAAE,kBAAkB,EAAE,QAAQ,EAAE,gBAAgB,EAAE,GAAG,cAAc,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;gBAEnH,iDAAiD;gBACjD,MAAM,GAAG;oBACP,SAAS,EAAE,gBAAgB;oBAC3B,OAAO,EAAE,cAAc;oBACvB,kBAAkB;oBAClB,gBAAgB;oBAChB,WAAW;iBACZ,CAAC;YACJ,CAAC;YAED,MAAM,SAAS,GAAgC;gBAC7C,QAAQ;gBACR,UAAU;gBACV,eAAe;gBACf,cAAc,EAAE,YAAY;gBAC5B,mBAAmB,EAAE,yBAAyB,CAAC,IAAI;gBACnD,eAAe,EAAE,iBAAiB,CAAC,IAAI;gBACvC,aAAa,EAAE,eAAe,CAAC,IAAI;gBACnC,MAAM;aACP,CAAC;YAEF,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC7B,CAAC;QAED,KAAK,UAAU,oBAAoB,CAAC,CAAC,IAAI,EAAE,KAAK,CAA+B;YAC7E,IAAI,aAAa,EAAE,CAAC;gBAClB,iCAAiC,CAAC,KAAK,CAAC,CAAC;gBACzC,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;YAC3B,CAAC;YAED,OAAO,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;gBACnC,MAAM,wBAAwB,GAAG,CAAC,YAA2D,EAAE,EAAE;oBAC/F,sBAAsB;oBACtB,oBAAoB,CAAC;wBACnB,KAAK;wBACL,YAAY;qBACb,CAAC,CAAC;gBACL,CAAC,CAAC;gBAEF,MAAM,yCAAyC,GAAG,CAAC,KAAc,EAAE,EAAE;oBACnE,qDAAqD;oBACrD,oBAAoB,CAAC;wBACnB,KAAK;wBACL,gBAAgB,EAAE,KAAK;wBACvB,kBAAkB,EAAE,IAAI;qBACzB,CAAC,CAAC;oBAEH,+BAA+B;oBAC/B,OAAO,EAAE,CAAC;gBACZ,CAAC,CAAC;gBAEF,MAAM,0BAA0B,GAAG,GAAG,EAAE;oBACtC,oBAAoB,CAAC;wBACnB,KAAK;wBACL,kBAAkB,EAAE,IAAI;qBACzB,CAAC,CAAC;oBAEH,OAAO,EAAE,CAAC;gBACZ,CAAC,CAAC;gBAEF,6CAA6C;gBAC7C,IAAI,CAAC;oBACH,aAAa;yBACV,UAAU,CAAC,IAAI,CAAC;yBAChB,IAAI,CAAC,CAAC,cAAc,EAAE,EAAE;wBACvB,6BAA6B;wBAC7B,iBAAiB,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;wBAEzC,MAAM,kBAAkB,GAAG,cAAc,CAAC,MAAM,CAAC,SAAS,CAAC;4BACzD,IAAI,EAAE,wBAAwB;4BAC9B,KAAK,EAAE,yCAAyC;4BAChD,QAAQ,EAAE,0BAA0B;yBACrC,CAAC,CAAC;wBAEH,8BAA8B,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC;oBAC7D,CAAC,CAAC;yBACD,KAAK,CAAC,yCAAyC,CAAC,CAAC;gBACtD,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,yCAAyC,CAAC,KAAK,CAAC,CAAC;gBACnD,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC;QAED,gCAAgC;QAChC,MAAM,UAAU,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,KAAK,CAAU,CAAC,CAAC;QAEzE,sBAAsB,CAAC,UAAU,EAAE,oBAAoB,EAAE;YACvD,gBAAgB;YAChB,cAAc,EAAE,CAAC,CAAC,qBAAqB;SACxC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;YACX,mDAAmD;YACnD,UAAU,CAAC,QAAQ,EAAE,CAAC;QACxB,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IAExB,MAAM,QAAQ,GAAmC;QAC/C,MAAM;QACN,MAAM;KACP,CAAC;IAEF,OAAO,QAAQ,CAAC;AAClB,CAAC","sourcesContent":["import { catchError, map, Observable, of, shareReplay } from 'rxjs';\nimport { DbxFirebaseStorageFileUploadStoreFileProgress } from '../store';\nimport { DbxFirebaseStorageService } from '../../../storage/firebase.storage.service';\nimport { IndexNumber, Maybe, PercentDecimal, PercentNumber, PromiseOrValue, runAsyncTasksForValues, separateValues } from '@dereekb/util';\nimport { MultiSubscriptionObject } from '@dereekb/rxjs';\nimport { FirebaseStorageAccessorFile, StorageCustomMetadata, StoragePathInput, StorageUploadOptions, StorageUploadTask } from '@dereekb/firebase';\n\n/**\n * Creates a new observable for uploading a file.\n */\nexport type StorageFileUploadHandlerFunction = (file: File) => Promise<StorageFileUploadHandlerInstance>;\n\nexport interface StorageFileUploadHandlerInstance extends Pick<StorageUploadTask<FirebaseStorageAccessorFile>, 'taskRef' | 'pause' | 'resume' | 'cancel'> {\n  /**\n   * The upload observable.\n   *\n   * Must be subscribed to in order for the upload to begin.\n   */\n  readonly upload: Observable<DbxFirebaseStorageFileUploadStoreFileProgress>;\n}\n\n/**\n * Handles uploading files.\n */\nexport interface StorageFileUploadHandler {\n  /**\n   * Uploads a file, and returns the file progress as it is uploading.\n   */\n  readonly uploadFile: StorageFileUploadHandlerFunction;\n}\n\n/**\n * Configuration for a single file upload.\n */\nexport interface StorageFileUploadConfig {\n  /**\n   * Path for where to upload the file to\n   */\n  readonly storagePath: StoragePathInput;\n  /**\n   * Upload options for the file.\n   *\n   * Resumable is not supported.\n   */\n  readonly uploadOptions?: StorageFileUploadConfigOptions;\n  /**\n   * Custom metadata for the file.\n   *\n   * Is merged with uploadOptions's metadata.\n   */\n  readonly customMetadata?: StorageCustomMetadata;\n}\n\n/**\n * StorageFileUploadConfig upload options.\n */\nexport type StorageFileUploadConfigOptions = Omit<StorageUploadOptions, 'resumable'>;\n\n/**\n * Function used to generate file names for the uploaded files.\n *\n * If not set, the file name will be used as is.\n */\nexport type StorageFileUploadConfigFactory = (file: File) => PromiseOrValue<StorageFileUploadConfig>;\n\n/**\n * Configuration for StorageFileUploadHandler().\n */\nexport interface StorageFileUploadHandlerConfig {\n  readonly storageService: DbxFirebaseStorageService;\n  readonly storageFileUploadConfigFactory: StorageFileUploadConfigFactory;\n}\n\n/**\n * Default implementation of StorageFileUploadHandler.\n */\nexport function storageFileUploadHandler(config: StorageFileUploadHandlerConfig): StorageFileUploadHandler {\n  const { storageService, storageFileUploadConfigFactory } = config;\n\n  let resumable: Maybe<StorageUploadTask>;\n\n  return {\n    uploadFile: async (file) => {\n      const storageFileUploadConfig = await storageFileUploadConfigFactory(file);\n\n      const { storagePath } = storageFileUploadConfig;\n      const storageAccessorFile = storageService.file(storagePath);\n\n      const upload = new Observable<DbxFirebaseStorageFileUploadStoreFileProgress>((x) => {\n        if (storageAccessorFile.uploadResumable) {\n          resumable = storageAccessorFile.uploadResumable(file);\n\n          // subscribe to the event by piping this observable to it\n          resumable\n            .streamSnapshotEvents()\n            .pipe(\n              map((x) => {\n                const { bytesTransferred, totalBytes } = x;\n\n                const progress: DbxFirebaseStorageFileUploadStoreFileProgress = {\n                  file,\n                  fileRef: storageAccessorFile,\n                  uploadRef: resumable,\n                  bytesTransferred,\n                  totalBytes,\n                  progress: bytesTransferred / totalBytes\n                };\n\n                return progress;\n              })\n            )\n            .pipe(\n              catchError((error) => {\n                // if an error occurs, catch it and emit it as a progress\n                const progress: DbxFirebaseStorageFileUploadStoreFileProgress = {\n                  file,\n                  fileRef: storageAccessorFile,\n                  uploadRef: resumable,\n                  error,\n                  failed: true\n                };\n\n                return of(progress);\n              })\n            )\n            .subscribe(x);\n        } else {\n          throw new Error('uploadResumable() function was unavailable.');\n        }\n      }).pipe(shareReplay(1));\n\n      const instance: StorageFileUploadHandlerInstance = {\n        upload,\n        taskRef: storageAccessorFile,\n        pause: () => resumable?.pause() ?? false,\n        resume: () => resumable?.resume() ?? false,\n        cancel: () => resumable?.cancel() ?? false\n      };\n\n      return instance;\n    }\n  };\n}\n\n// MARK: Upload Files\nexport interface StorageFileUploadFilesInput {\n  readonly uploadHandler: StorageFileUploadHandler;\n  /**\n   * Files to upload\n   */\n  readonly files: File[];\n  /**\n   * The number of max parallel uploads to perform at a time.\n   *\n   * Defaults to 3\n   */\n  readonly maxParallelUploads?: number;\n}\n\nexport interface StorageFileUploadFilesInstance {\n  /**\n   * Cancels the upload of the remaining files.\n   */\n  cancel(): void;\n  /**\n   * The upload observable.\n   *\n   * Must be subscribed to in order for the upload to begin.\n   */\n  readonly upload: Observable<StorageFileUploadFilesEvent>;\n}\n\nexport interface StorageFileUploadFilesEvent {\n  /**\n   * All files being uploaded\n   */\n  readonly allFiles: File[];\n  /**\n   * Returns true if all files have been uploaded.\n   *\n   * The result value should be available.\n   */\n  readonly isComplete: boolean;\n  /**\n   * Returns true if the upload was canceled.\n   */\n  readonly isCanceled?: Maybe<boolean>;\n  /**\n   * The overall progress of all files being uploaded.\n   */\n  readonly overallProgress: PercentNumber;\n  /**\n   * The upload progress that triggered this event.\n   */\n  readonly uploadProgress?: Maybe<DbxFirebaseStorageFileUploadStoreFileProgress>;\n  /**\n   * The final result.\n   *\n   * Set when the final file has been uploaded or failed.\n   */\n  readonly result?: StorageFileUploadFilesFinalResult;\n  /**\n   * The number of files that are still uploading or queued for upload.\n   */\n  readonly incompleteFileCount: number;\n  /**\n   * The number of files that are active.\n   */\n  readonly activeFileCount: number;\n  /**\n   * The number of files that are done.\n   */\n  readonly doneFileCount: number;\n}\n\nexport interface StorageFileUploadFilesFinalResult {\n  readonly startTime: Date;\n  readonly endTime: Date;\n  readonly fileResults: StorageFileUploadFilesFinalFileResult[];\n  readonly successFileResults: StorageFileUploadFilesFinalFileResult[];\n  readonly errorFileResults: StorageFileUploadFilesFinalFileResult[];\n}\n\nexport interface StorageFileUploadFilesFinalFileResult {\n  /**\n   * The start time of the file upload.\n   */\n  readonly startTime: Date;\n  /**\n   * The end time of the file upload, or when it failed or was canceled.\n   */\n  readonly endTime: Date;\n  /**\n   * The file that was uploaded.\n   */\n  readonly file: File;\n  /**\n   * The accessor file for the file, if available.\n   *\n   * Is generally available if success is true.\n   */\n  readonly fileRef?: Maybe<FirebaseStorageAccessorFile>;\n  /**\n   * True if the file was uploaded successfully.\n   */\n  readonly success: boolean;\n  /**\n   * Error if the file failed to upload.\n   */\n  readonly error?: Maybe<unknown>;\n  /**\n   * True if the file upload was cancelled.\n   */\n  readonly canceled?: Maybe<boolean>;\n}\n\n/**\n * Uploads files using the provided upload handler and files.\n *\n * An observable is returned that emits the latest file events from any file that is being uploaded.\n *\n * @param input\n * @returns\n */\nexport function storageFileUploadFiles(input: StorageFileUploadFilesInput): StorageFileUploadFilesInstance {\n  const { uploadHandler, files, maxParallelUploads: inputMaxParallelUploads } = input;\n  const maxParallelTasks = inputMaxParallelUploads ?? 3;\n\n  const multiUploadsSubscriptionObject = new MultiSubscriptionObject();\n\n  // begin the upload for each file\n  const allFiles = Array.from(files);\n\n  // unsubscribe from all previous uploads\n  multiUploadsSubscriptionObject.unsub();\n\n  interface UpdateUploadProgressInput {\n    /**\n     * The file index number.\n     */\n    readonly index: IndexNumber;\n    /**\n     * The next progress event, if applicable.\n     */\n    readonly nextProgress?: Maybe<DbxFirebaseStorageFileUploadStoreFileProgress>;\n    /**\n     * An error that occured outside of the nextProgress, if applicable.\n     *\n     * These are typically \"uncaught\" errors.\n     */\n    readonly nonProgressError?: Maybe<unknown>;\n    /**\n     * Passed as true when the upload task is done.\n     *\n     * This is also inferred as true when a progress error occurs for an upload.\n     *\n     * Does not specify whether or not success was achieved or not.\n     */\n    readonly fileUploadTaskDone?: boolean;\n    /**\n     * True if the upload was canceled.\n     */\n    readonly canceled?: boolean;\n  }\n\n  interface FileUploadDetails {\n    readonly file: File;\n    /**\n     * The current upload instance for the file.\n     *\n     * Set if the file is currently uploading.\n     */\n    uploadInstance?: StorageFileUploadHandlerInstance;\n    fileRef?: Maybe<FirebaseStorageAccessorFile>;\n    startTime?: Date;\n    endTime?: Date;\n    success?: boolean;\n    canceled?: Maybe<boolean>;\n    error?: Maybe<unknown>;\n  }\n\n  const allFilesAndLatestProgress: Maybe<DbxFirebaseStorageFileUploadStoreFileProgress>[] = new Array(allFiles.length);\n  const allFilesAndDetails: FileUploadDetails[] = allFiles.map((file) => ({ file }));\n  const overallProgressPerCompletedFile: PercentDecimal = (1 / allFilesAndLatestProgress.length) as PercentDecimal;\n\n  /**\n   * Once set, any new file upload task that hits this will return an cancel failure.\n   */\n  let flaggedCancel = false;\n\n  const cancel = () => {\n    flaggedCancel = true;\n  };\n\n  const upload = new Observable<StorageFileUploadFilesEvent>((subscriber) => {\n    const overallStartTime = new Date();\n\n    const incompleteFileFileIndexes = new Set<IndexNumber>(allFiles.map((_, index) => index));\n    const activeFileIndexes = new Set<IndexNumber>();\n    const doneFileIndexes = new Set<IndexNumber>();\n    let latestOverallProgress: PercentNumber = 0;\n\n    function onStartFileUpload(index: IndexNumber, uploadInstance: StorageFileUploadHandlerInstance) {\n      activeFileIndexes.add(index);\n      allFilesAndDetails[index].startTime = new Date();\n      allFilesAndDetails[index].uploadInstance = uploadInstance;\n      allFilesAndDetails[index].fileRef = uploadInstance.taskRef;\n    }\n\n    function onStartFileUploadFlaggedCancelled(index: IndexNumber) {\n      allFilesAndDetails[index].startTime = new Date();\n\n      // immediately mark it done\n      _markFileUploadDone(index, true);\n\n      // emit new progress event\n      _emitEvent();\n    }\n\n    function _markFileUploadDone(fileIndex: IndexNumber, finalError?: Maybe<unknown>) {\n      doneFileIndexes.add(fileIndex); // add to done file indexes\n      activeFileIndexes.delete(fileIndex); // remove from active file indexes if it exists\n      incompleteFileFileIndexes.delete(fileIndex); // remove from incomplete file indexes\n\n      // update details\n      allFilesAndDetails[fileIndex].endTime = new Date();\n\n      const error = finalError ?? allFilesAndDetails[fileIndex].error;\n      allFilesAndDetails[fileIndex].success = !error;\n      allFilesAndDetails[fileIndex].error = error;\n    }\n\n    function updateUploadProgress(input: UpdateUploadProgressInput) {\n      const { index: fileIndex, nextProgress, fileUploadTaskDone: inputFileUploadTaskDone, nonProgressError } = input;\n      const error = nonProgressError ?? nextProgress?.error;\n      const fileUploadTaskDone = inputFileUploadTaskDone ?? Boolean(error);\n\n      // the task may already be done, as after a progress-related error the complete task can get called.\n      const isTaskAlreadyDone = allFilesAndDetails[fileIndex].endTime != null;\n\n      if (!isTaskAlreadyDone) {\n        let nextOverallProgress = latestOverallProgress;\n        const nextProgressPercent = fileUploadTaskDone ? 100 : (nextProgress?.progress ?? 0) * 100;\n\n        // update the overall progress percentage\n        if (nextProgressPercent) {\n          // update the overall percentage\n          const previousProgress = allFilesAndLatestProgress[fileIndex];\n          const previousProgressPercent = previousProgress?.progress != null ? previousProgress.progress * 100 : 0;\n          const progressPercentChange = nextProgressPercent - previousProgressPercent;\n\n          // increase overall progress by the change\n          nextOverallProgress += progressPercentChange * overallProgressPerCompletedFile;\n        }\n\n        // update the file progress\n        if (nextProgress) {\n          // update the latest FileProgress\n          allFilesAndLatestProgress[fileIndex] = nextProgress;\n\n          // only set fileRef once\n          if (!allFilesAndDetails[fileIndex].fileRef) {\n            allFilesAndDetails[fileIndex].fileRef = nextProgress.fileRef;\n          }\n        }\n\n        // if complete, update the indexes and details\n        if (fileUploadTaskDone) {\n          _markFileUploadDone(fileIndex, error);\n        }\n\n        // update the overall progress\n        latestOverallProgress = nextOverallProgress;\n\n        // emit the event to send it\n        _emitEvent(nextProgress);\n      }\n    }\n\n    function _emitEvent(nextProgress?: Maybe<DbxFirebaseStorageFileUploadStoreFileProgress>) {\n      const isComplete = incompleteFileFileIndexes.size === 0;\n\n      let overallProgress = latestOverallProgress;\n      let result: Maybe<StorageFileUploadFilesFinalResult> = undefined;\n\n      if (isComplete) {\n        overallProgress = 100; // set to 100%\n        const overallEndTime = new Date();\n\n        const fileResults = allFiles.map((file, index) => {\n          const result: StorageFileUploadFilesFinalFileResult = {\n            startTime: allFilesAndDetails[index].startTime as Date,\n            endTime: allFilesAndDetails[index].endTime as Date,\n            file,\n            fileRef: allFilesAndDetails[index].fileRef,\n            success: !allFilesAndDetails[index].error,\n            error: allFilesAndDetails[index].error\n          };\n\n          return result;\n        });\n\n        const { included: successFileResults, excluded: errorFileResults } = separateValues(fileResults, (x) => x.success);\n\n        // all are done, set the result on the next event\n        result = {\n          startTime: overallStartTime,\n          endTime: overallEndTime,\n          successFileResults,\n          errorFileResults,\n          fileResults\n        };\n      }\n\n      const nextEvent: StorageFileUploadFilesEvent = {\n        allFiles,\n        isComplete,\n        overallProgress,\n        uploadProgress: nextProgress,\n        incompleteFileCount: incompleteFileFileIndexes.size,\n        activeFileCount: activeFileIndexes.size,\n        doneFileCount: doneFileIndexes.size,\n        result\n      };\n\n      subscriber.next(nextEvent);\n    }\n\n    async function runUploadTaskForFile([file, index]: readonly [File, IndexNumber]) {\n      if (flaggedCancel) {\n        onStartFileUploadFlaggedCancelled(index);\n        return Promise.resolve();\n      }\n\n      return new Promise<void>((resolve) => {\n        const updateFileUploadProgress = (nextProgress: DbxFirebaseStorageFileUploadStoreFileProgress) => {\n          // update the progress\n          updateUploadProgress({\n            index,\n            nextProgress\n          });\n        };\n\n        const updateFileUploadProgressWithUncaughtError = (error: unknown) => {\n          // error occurred, update the progress with the error\n          updateUploadProgress({\n            index,\n            nonProgressError: error,\n            fileUploadTaskDone: true\n          });\n\n          // always resolve, never reject\n          resolve();\n        };\n\n        const completeFileUploadProgress = () => {\n          updateUploadProgress({\n            index,\n            fileUploadTaskDone: true\n          });\n\n          resolve();\n        };\n\n        // upload the file, subscribe to the progress\n        try {\n          uploadHandler\n            .uploadFile(file)\n            .then((uploadInstance) => {\n              // add to active file indexes\n              onStartFileUpload(index, uploadInstance);\n\n              const uploadSubscription = uploadInstance.upload.subscribe({\n                next: updateFileUploadProgress,\n                error: updateFileUploadProgressWithUncaughtError,\n                complete: completeFileUploadProgress\n              });\n\n              multiUploadsSubscriptionObject.addSubs(uploadSubscription);\n            })\n            .catch(updateFileUploadProgressWithUncaughtError);\n        } catch (error) {\n          updateFileUploadProgressWithUncaughtError(error);\n        }\n      });\n    }\n\n    // run upload task for each file\n    const fileTuples = allFiles.map((file, index) => [file, index] as const);\n\n    runAsyncTasksForValues(fileTuples, runUploadTaskForFile, {\n      maxParallelTasks,\n      retriesAllowed: 0 // no retries allowed\n    }).then(() => {\n      // all tasks are finished. Complete the subscriber.\n      subscriber.complete();\n    });\n  }).pipe(shareReplay(1));\n\n  const instance: StorageFileUploadFilesInstance = {\n    cancel,\n    upload\n  };\n\n  return instance;\n}\n"]}

package/esm2022/lib/modules/storagefile/container/storagefile.upload.initialize.document.directive.mjs

@@ -0,0 +1,39 @@
+import { Directive, inject } from '@angular/core';
+import { DbxFirebaseStorageFileUploadStore, StorageFileDocumentStore } from '../store';
+import { AbstractSubscriptionDirective } from '@dereekb/dbx-core';
+import * as i0 from "@angular/core";
+/**
+ * Directive that passes the upload result to a StorageFileDocumentStore to initialize the document immediately.
+ */
+export class DbxFirebaseStorageFileUploadInitializeDocumentDirective extends AbstractSubscriptionDirective {
+    uploadStore = inject(DbxFirebaseStorageFileUploadStore);
+    storageFileDocumentStore = inject(StorageFileDocumentStore);
+    constructor() {
+        super();
+        this.sub = this.uploadStore.uploadResult$.subscribe(async (result) => {
+            const successFileResult = result.successFileResults.find((x) => x.fileRef != null);
+            if (successFileResult) {
+                const fileRef = successFileResult.fileRef;
+                if (fileRef) {
+                    this.storageFileDocumentStore
+                        .initializeStorageFileFromUpload({
+                        pathString: fileRef.storagePath.pathString,
+                        bucketId: fileRef.storagePath.bucketId
+                    })
+                        .subscribe();
+                }
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileUploadInitializeDocumentDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: DbxFirebaseStorageFileUploadInitializeDocumentDirective, isStandalone: true, selector: "[dbxFirebaseStorageFileUploadInitializeDocument]", exportAs: ["dbxFirebaseStorageFileUploadInitializeDocument"], usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileUploadInitializeDocumentDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxFirebaseStorageFileUploadInitializeDocument]',
+                    exportAs: 'dbxFirebaseStorageFileUploadInitializeDocument',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZWZpbGUudXBsb2FkLmluaXRpYWxpemUuZG9jdW1lbnQuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZGJ4LWZpcmViYXNlL3NyYy9saWIvbW9kdWxlcy9zdG9yYWdlZmlsZS9jb250YWluZXIvc3RvcmFnZWZpbGUudXBsb2FkLmluaXRpYWxpemUuZG9jdW1lbnQuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFhLE1BQU0sZUFBZSxDQUFDO0FBQzdELE9BQU8sRUFBRSxpQ0FBaUMsRUFBRSx3QkFBd0IsRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUN2RixPQUFPLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQzs7QUFHbEU7O0dBRUc7QUFNSCxNQUFNLE9BQU8sdURBQXdELFNBQVEsNkJBQTZCO0lBQy9GLFdBQVcsR0FBRyxNQUFNLENBQUMsaUNBQWlDLENBQUMsQ0FBQztJQUN4RCx3QkFBd0IsR0FBRyxNQUFNLENBQUMsd0JBQXdCLENBQUMsQ0FBQztJQUVyRTtRQUNFLEtBQUssRUFBRSxDQUFDO1FBRVIsSUFBSSxDQUFDLEdBQUcsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLGFBQWEsQ0FBQyxTQUFTLENBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRSxFQUFFO1lBQ25FLE1BQU0saUJBQWlCLEdBQUcsTUFBTSxDQUFDLGtCQUFrQixDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLE9BQU8sSUFBSSxJQUFJLENBQUMsQ0FBQztZQUVuRixJQUFJLGlCQUFpQixFQUFFLENBQUM7Z0JBQ3RCLE1BQU0sT0FBTyxHQUFHLGlCQUFpQixDQUFDLE9BQXNDLENBQUM7Z0JBRXpFLElBQUksT0FBTyxFQUFFLENBQUM7b0JBQ1osSUFBSSxDQUFDLHdCQUF3Qjt5QkFDMUIsK0JBQStCLENBQUM7d0JBQy9CLFVBQVUsRUFBRSxPQUFPLENBQUMsV0FBVyxDQUFDLFVBQVU7d0JBQzFDLFFBQVEsRUFBRSxPQUFPLENBQUMsV0FBVyxDQUFDLFFBQVE7cUJBQ3ZDLENBQUM7eUJBQ0QsU0FBUyxFQUFFLENBQUM7Z0JBQ2pCLENBQUM7WUFDSCxDQUFDO1FBQ0gsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO3dHQXZCVSx1REFBdUQ7NEZBQXZELHVEQUF1RDs7NEZBQXZELHVEQUF1RDtrQkFMbkUsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsa0RBQWtEO29CQUM1RCxRQUFRLEVBQUUsZ0RBQWdEO29CQUMxRCxVQUFVLEVBQUUsSUFBSTtpQkFDakIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIGluamVjdCwgT25EZXN0cm95IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEYnhGaXJlYmFzZVN0b3JhZ2VGaWxlVXBsb2FkU3RvcmUsIFN0b3JhZ2VGaWxlRG9jdW1lbnRTdG9yZSB9IGZyb20gJy4uL3N0b3JlJztcbmltcG9ydCB7IEFic3RyYWN0U3Vic2NyaXB0aW9uRGlyZWN0aXZlIH0gZnJvbSAnQGRlcmVla2IvZGJ4LWNvcmUnO1xuaW1wb3J0IHsgRmlyZWJhc2VTdG9yYWdlQWNjZXNzb3JGaWxlIH0gZnJvbSAnQGRlcmVla2IvZmlyZWJhc2UnO1xuXG4vKipcbiAqIERpcmVjdGl2ZSB0aGF0IHBhc3NlcyB0aGUgdXBsb2FkIHJlc3VsdCB0byBhIFN0b3JhZ2VGaWxlRG9jdW1lbnRTdG9yZSB0byBpbml0aWFsaXplIHRoZSBkb2N1bWVudCBpbW1lZGlhdGVseS5cbiAqL1xuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW2RieEZpcmViYXNlU3RvcmFnZUZpbGVVcGxvYWRJbml0aWFsaXplRG9jdW1lbnRdJyxcbiAgZXhwb3J0QXM6ICdkYnhGaXJlYmFzZVN0b3JhZ2VGaWxlVXBsb2FkSW5pdGlhbGl6ZURvY3VtZW50JyxcbiAgc3RhbmRhbG9uZTogdHJ1ZVxufSlcbmV4cG9ydCBjbGFzcyBEYnhGaXJlYmFzZVN0b3JhZ2VGaWxlVXBsb2FkSW5pdGlhbGl6ZURvY3VtZW50RGlyZWN0aXZlIGV4dGVuZHMgQWJzdHJhY3RTdWJzY3JpcHRpb25EaXJlY3RpdmUgaW1wbGVtZW50cyBPbkRlc3Ryb3kge1xuICByZWFkb25seSB1cGxvYWRTdG9yZSA9IGluamVjdChEYnhGaXJlYmFzZVN0b3JhZ2VGaWxlVXBsb2FkU3RvcmUpO1xuICByZWFkb25seSBzdG9yYWdlRmlsZURvY3VtZW50U3RvcmUgPSBpbmplY3QoU3RvcmFnZUZpbGVEb2N1bWVudFN0b3JlKTtcblxuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcigpO1xuXG4gICAgdGhpcy5zdWIgPSB0aGlzLnVwbG9hZFN0b3JlLnVwbG9hZFJlc3VsdCQuc3Vic2NyaWJlKGFzeW5jIChyZXN1bHQpID0+IHtcbiAgICAgIGNvbnN0IHN1Y2Nlc3NGaWxlUmVzdWx0ID0gcmVzdWx0LnN1Y2Nlc3NGaWxlUmVzdWx0cy5maW5kKCh4KSA9PiB4LmZpbGVSZWYgIT0gbnVsbCk7XG5cbiAgICAgIGlmIChzdWNjZXNzRmlsZVJlc3VsdCkge1xuICAgICAgICBjb25zdCBmaWxlUmVmID0gc3VjY2Vzc0ZpbGVSZXN1bHQuZmlsZVJlZiBhcyBGaXJlYmFzZVN0b3JhZ2VBY2Nlc3NvckZpbGU7XG5cbiAgICAgICAgaWYgKGZpbGVSZWYpIHtcbiAgICAgICAgICB0aGlzLnN0b3JhZ2VGaWxlRG9jdW1lbnRTdG9yZVxuICAgICAgICAgICAgLmluaXRpYWxpemVTdG9yYWdlRmlsZUZyb21VcGxvYWQoe1xuICAgICAgICAgICAgICBwYXRoU3RyaW5nOiBmaWxlUmVmLnN0b3JhZ2VQYXRoLnBhdGhTdHJpbmcsXG4gICAgICAgICAgICAgIGJ1Y2tldElkOiBmaWxlUmVmLnN0b3JhZ2VQYXRoLmJ1Y2tldElkXG4gICAgICAgICAgICB9KVxuICAgICAgICAgICAgLnN1YnNjcmliZSgpO1xuICAgICAgICB9XG4gICAgICB9XG4gICAgfSk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/modules/storagefile/container/storagefile.upload.store.directive.mjs

@@ -0,0 +1,38 @@
+import { Directive, inject, input } from '@angular/core';
+import { skipAllInitialMaybe, SubscriptionObject } from '@dereekb/rxjs';
+import { DbxFirebaseStorageFileUploadStore } from '../store';
+import { toObservable } from '@angular/core/rxjs-interop';
+import { shareReplay } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Directive that provides a DbxFirebaseStorageFileUploadStore, and sync's the inputs to the store.
+ */
+export class DbxFirebaseStorageFileUploadStoreDirective {
+    _allowedSub = new SubscriptionObject();
+    _multiSub = new SubscriptionObject();
+    uploadStore = inject(DbxFirebaseStorageFileUploadStore);
+    multipleUpload = input();
+    fileTypesAccepted = input();
+    fileTypesAccepted$ = toObservable(this.fileTypesAccepted).pipe(skipAllInitialMaybe(), shareReplay(1));
+    isMultiUploadAllowed$ = toObservable(this.multipleUpload).pipe(skipAllInitialMaybe(), shareReplay(1));
+    constructor() {
+        this._allowedSub.subscription = this.fileTypesAccepted$.subscribe((x) => this.uploadStore.setFileTypesAccepted(x));
+        this._multiSub.subscription = this.isMultiUploadAllowed$.subscribe((x) => this.uploadStore.setIsMultiUploadAllowed(x));
+    }
+    ngOnDestroy() {
+        this._allowedSub.destroy();
+        this._multiSub.destroy();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileUploadStoreDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.13", type: DbxFirebaseStorageFileUploadStoreDirective, isStandalone: true, selector: "[dbxFirebaseStorageFileUploadStore]", inputs: { multipleUpload: { classPropertyName: "multipleUpload", publicName: "multipleUpload", isSignal: true, isRequired: false, transformFunction: null }, fileTypesAccepted: { classPropertyName: "fileTypesAccepted", publicName: "fileTypesAccepted", isSignal: true, isRequired: false, transformFunction: null } }, providers: [DbxFirebaseStorageFileUploadStore], exportAs: ["dbxFirebaseStorageFileUploadStore"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileUploadStoreDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxFirebaseStorageFileUploadStore]',
+                    exportAs: 'dbxFirebaseStorageFileUploadStore',
+                    providers: [DbxFirebaseStorageFileUploadStore],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modules/storagefile/container/storagefile.upload.sync.directive.mjs

@@ -0,0 +1,36 @@
+import { Directive, inject } from '@angular/core';
+import { SubscriptionObject } from '@dereekb/rxjs';
+import { DbxFirebaseStorageFileUploadStore } from '../store';
+import { DbxFileUploadComponent } from '@dereekb/dbx-web';
+import * as i0 from "@angular/core";
+/**
+ * Directive that syncs a DbxFirebaseStorageFileUploadStore's configuration to a DbxFileUploadComponent.
+ */
+export class DbxFirebaseStorageFileUploadSyncDirective {
+    _allowedSub = new SubscriptionObject();
+    _multiSub = new SubscriptionObject();
+    _filesSub = new SubscriptionObject();
+    uploadStore = inject(DbxFirebaseStorageFileUploadStore);
+    uploadComponent = inject(DbxFileUploadComponent);
+    constructor() {
+        this._allowedSub.subscription = this.uploadStore.fileTypesAllowed$.subscribe((x) => this.uploadComponent.setAccept(x));
+        this._multiSub.subscription = this.uploadStore.isMultiUploadAllowed$.subscribe((x) => this.uploadComponent.setMultiple(x));
+        this._filesSub.subscription = this.uploadComponent.filesChanged.subscribe((files) => this.uploadStore.setFiles(files.matchResult.accepted));
+    }
+    ngOnDestroy() {
+        this._allowedSub.destroy();
+        this._multiSub.destroy();
+        this._filesSub.destroy();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileUploadSyncDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: DbxFirebaseStorageFileUploadSyncDirective, isStandalone: true, selector: "[dbxFirebaseStorageFileUploadSync]", exportAs: ["dbxFirebaseStorageFileUploadSync"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileUploadSyncDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxFirebaseStorageFileUploadSync]',
+                    exportAs: 'dbxFirebaseStorageFileUploadSync',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZWZpbGUudXBsb2FkLnN5bmMuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZGJ4LWZpcmViYXNlL3NyYy9saWIvbW9kdWxlcy9zdG9yYWdlZmlsZS9jb250YWluZXIvc3RvcmFnZWZpbGUudXBsb2FkLnN5bmMuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFhLE1BQU0sZUFBZSxDQUFDO0FBQzdELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNuRCxPQUFPLEVBQUUsaUNBQWlDLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFDN0QsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7O0FBRTFEOztHQUVHO0FBTUgsTUFBTSxPQUFPLHlDQUF5QztJQUNuQyxXQUFXLEdBQUcsSUFBSSxrQkFBa0IsRUFBRSxDQUFDO0lBQ3ZDLFNBQVMsR0FBRyxJQUFJLGtCQUFrQixFQUFFLENBQUM7SUFDckMsU0FBUyxHQUFHLElBQUksa0JBQWtCLEVBQUUsQ0FBQztJQUU3QyxXQUFXLEdBQUcsTUFBTSxDQUFDLGlDQUFpQyxDQUFDLENBQUM7SUFDeEQsZUFBZSxHQUFHLE1BQU0sQ0FBQyxzQkFBc0IsQ0FBQyxDQUFDO0lBRTFEO1FBQ0UsSUFBSSxDQUFDLFdBQVcsQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBQyxpQkFBaUIsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDdkgsSUFBSSxDQUFDLFNBQVMsQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBQyxxQkFBcUIsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDM0gsSUFBSSxDQUFDLFNBQVMsQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDLGVBQWUsQ0FBQyxZQUFZLENBQUMsU0FBUyxDQUFDLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsV0FBVyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7SUFDOUksQ0FBQztJQUVELFdBQVc7UUFDVCxJQUFJLENBQUMsV0FBVyxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQzNCLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDekIsSUFBSSxDQUFDLFNBQVMsQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUMzQixDQUFDO3dHQWxCVSx5Q0FBeUM7NEZBQXpDLHlDQUF5Qzs7NEZBQXpDLHlDQUF5QztrQkFMckQsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsb0NBQW9DO29CQUM5QyxRQUFRLEVBQUUsa0NBQWtDO29CQUM1QyxVQUFVLEVBQUUsSUFBSTtpQkFDakIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIGluamVjdCwgT25EZXN0cm95IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBTdWJzY3JpcHRpb25PYmplY3QgfSBmcm9tICdAZGVyZWVrYi9yeGpzJztcbmltcG9ydCB7IERieEZpcmViYXNlU3RvcmFnZUZpbGVVcGxvYWRTdG9yZSB9IGZyb20gJy4uL3N0b3JlJztcbmltcG9ydCB7IERieEZpbGVVcGxvYWRDb21wb25lbnQgfSBmcm9tICdAZGVyZWVrYi9kYngtd2ViJztcblxuLyoqXG4gKiBEaXJlY3RpdmUgdGhhdCBzeW5jcyBhIERieEZpcmViYXNlU3RvcmFnZUZpbGVVcGxvYWRTdG9yZSdzIGNvbmZpZ3VyYXRpb24gdG8gYSBEYnhGaWxlVXBsb2FkQ29tcG9uZW50LlxuICovXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbZGJ4RmlyZWJhc2VTdG9yYWdlRmlsZVVwbG9hZFN5bmNdJyxcbiAgZXhwb3J0QXM6ICdkYnhGaXJlYmFzZVN0b3JhZ2VGaWxlVXBsb2FkU3luYycsXG4gIHN0YW5kYWxvbmU6IHRydWVcbn0pXG5leHBvcnQgY2xhc3MgRGJ4RmlyZWJhc2VTdG9yYWdlRmlsZVVwbG9hZFN5bmNEaXJlY3RpdmUgaW1wbGVtZW50cyBPbkRlc3Ryb3kge1xuICBwcml2YXRlIHJlYWRvbmx5IF9hbGxvd2VkU3ViID0gbmV3IFN1YnNjcmlwdGlvbk9iamVjdCgpO1xuICBwcml2YXRlIHJlYWRvbmx5IF9tdWx0aVN1YiA9IG5ldyBTdWJzY3JpcHRpb25PYmplY3QoKTtcbiAgcHJpdmF0ZSByZWFkb25seSBfZmlsZXNTdWIgPSBuZXcgU3Vic2NyaXB0aW9uT2JqZWN0KCk7XG5cbiAgcmVhZG9ubHkgdXBsb2FkU3RvcmUgPSBpbmplY3QoRGJ4RmlyZWJhc2VTdG9yYWdlRmlsZVVwbG9hZFN0b3JlKTtcbiAgcmVhZG9ubHkgdXBsb2FkQ29tcG9uZW50ID0gaW5qZWN0KERieEZpbGVVcGxvYWRDb21wb25lbnQpO1xuXG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIHRoaXMuX2FsbG93ZWRTdWIuc3Vic2NyaXB0aW9uID0gdGhpcy51cGxvYWRTdG9yZS5maWxlVHlwZXNBbGxvd2VkJC5zdWJzY3JpYmUoKHgpID0+IHRoaXMudXBsb2FkQ29tcG9uZW50LnNldEFjY2VwdCh4KSk7XG4gICAgdGhpcy5fbXVsdGlTdWIuc3Vic2NyaXB0aW9uID0gdGhpcy51cGxvYWRTdG9yZS5pc011bHRpVXBsb2FkQWxsb3dlZCQuc3Vic2NyaWJlKCh4KSA9PiB0aGlzLnVwbG9hZENvbXBvbmVudC5zZXRNdWx0aXBsZSh4KSk7XG4gICAgdGhpcy5fZmlsZXNTdWIuc3Vic2NyaXB0aW9uID0gdGhpcy51cGxvYWRDb21wb25lbnQuZmlsZXNDaGFuZ2VkLnN1YnNjcmliZSgoZmlsZXMpID0+IHRoaXMudXBsb2FkU3RvcmUuc2V0RmlsZXMoZmlsZXMubWF0Y2hSZXN1bHQuYWNjZXB0ZWQpKTtcbiAgfVxuXG4gIG5nT25EZXN0cm95KCk6IHZvaWQge1xuICAgIHRoaXMuX2FsbG93ZWRTdWIuZGVzdHJveSgpO1xuICAgIHRoaXMuX211bHRpU3ViLmRlc3Ryb3koKTtcbiAgICB0aGlzLl9maWxlc1N1Yi5kZXN0cm95KCk7XG4gIH1cbn1cbiJdfQ==

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

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

package/esm2022/lib/modules/storagefile/storagefile.upload.module.mjs

@@ -0,0 +1,83 @@
+import { DbxActionLoadingContextDirective, DbxActionModule, DbxActionSnackbarErrorDirective, DbxFileUploadComponent, DbxFileUploadActionSyncDirective, DbxLoadingComponent } from '@dereekb/dbx-web';
+import { DbxFirebaseStorageFileUploadActionHandlerDirective, DbxFirebaseStorageFileUploadStoreDirective, DbxFirebaseStorageFileUploadSyncDirective, DbxFirebaseStorageFileUploadInitializeDocumentDirective } from './container';
+import { NgModule } from '@angular/core';
+import { DbxFirebaseStorageFileDocumentStoreDirective } from './store/storagefile.document.store.directive';
+import { DbxFirebaseStorageFileCollectionStoreDirective } from './store';
+import * as i0 from "@angular/core";
+export const importsAndExports = [
+    // dbx-core/dbx-web modules/components
+    DbxActionModule,
+    DbxLoadingComponent,
+    DbxActionLoadingContextDirective,
+    DbxActionSnackbarErrorDirective,
+    DbxFileUploadComponent,
+    DbxFileUploadActionSyncDirective,
+    // containers
+    DbxFirebaseStorageFileUploadActionHandlerDirective,
+    DbxFirebaseStorageFileUploadStoreDirective,
+    DbxFirebaseStorageFileUploadSyncDirective,
+    DbxFirebaseStorageFileUploadInitializeDocumentDirective,
+    // stores
+    DbxFirebaseStorageFileCollectionStoreDirective,
+    DbxFirebaseStorageFileDocumentStoreDirective
+];
+/**
+ * Convenience module for importing various modules/components that are relevant to the storage file upload feature.
+ *
+ * - DbxActionModule
+ * - DbxFileUploadComponent
+ * - DbxFirebaseStorageFileUploadActionHandlerDirective
+ * - DbxFirebaseStorageFileUploadStoreDirective
+ * - DbxFirebaseStorageFileUploadSyncDirective
+ * - DbxFirebaseStorageFileUploadInitializeDocumentDirective
+ * - DbxFirebaseStorageFileUploadStore
+ */
+export class DbxFirebaseStorageFileUploadModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileUploadModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileUploadModule, imports: [
+            // dbx-core/dbx-web modules/components
+            DbxActionModule,
+            DbxLoadingComponent,
+            DbxActionLoadingContextDirective,
+            DbxActionSnackbarErrorDirective,
+            DbxFileUploadComponent,
+            DbxFileUploadActionSyncDirective,
+            // containers
+            DbxFirebaseStorageFileUploadActionHandlerDirective,
+            DbxFirebaseStorageFileUploadStoreDirective,
+            DbxFirebaseStorageFileUploadSyncDirective,
+            DbxFirebaseStorageFileUploadInitializeDocumentDirective,
+            // stores
+            DbxFirebaseStorageFileCollectionStoreDirective,
+            DbxFirebaseStorageFileDocumentStoreDirective], exports: [
+            // dbx-core/dbx-web modules/components
+            DbxActionModule,
+            DbxLoadingComponent,
+            DbxActionLoadingContextDirective,
+            DbxActionSnackbarErrorDirective,
+            DbxFileUploadComponent,
+            DbxFileUploadActionSyncDirective,
+            // containers
+            DbxFirebaseStorageFileUploadActionHandlerDirective,
+            DbxFirebaseStorageFileUploadStoreDirective,
+            DbxFirebaseStorageFileUploadSyncDirective,
+            DbxFirebaseStorageFileUploadInitializeDocumentDirective,
+            // stores
+            DbxFirebaseStorageFileCollectionStoreDirective,
+            DbxFirebaseStorageFileDocumentStoreDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileUploadModule, imports: [
+            // dbx-core/dbx-web modules/components
+            DbxActionModule,
+            DbxLoadingComponent,
+            DbxFileUploadComponent,
+            // dbx-core/dbx-web modules/components
+            DbxActionModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileUploadModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: importsAndExports,
+                    exports: importsAndExports
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZWZpbGUudXBsb2FkLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2RieC1maXJlYmFzZS9zcmMvbGliL21vZHVsZXMvc3RvcmFnZWZpbGUvc3RvcmFnZWZpbGUudXBsb2FkLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsZ0NBQWdDLEVBQUUsZUFBZSxFQUFFLCtCQUErQixFQUFFLHNCQUFzQixFQUFFLGdDQUFnQyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDck0sT0FBTyxFQUFFLGtEQUFrRCxFQUFFLDBDQUEwQyxFQUFFLHlDQUF5QyxFQUFFLHVEQUF1RCxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQ2pPLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLDRDQUE0QyxFQUFFLE1BQU0sOENBQThDLENBQUM7QUFDNUcsT0FBTyxFQUFFLDhDQUE4QyxFQUFFLE1BQU0sU0FBUyxDQUFDOztBQUV6RSxNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRztJQUMvQixzQ0FBc0M7SUFDdEMsZUFBZTtJQUNmLG1CQUFtQjtJQUNuQixnQ0FBZ0M7SUFDaEMsK0JBQStCO0lBQy9CLHNCQUFzQjtJQUN0QixnQ0FBZ0M7SUFDaEMsYUFBYTtJQUNiLGtEQUFrRDtJQUNsRCwwQ0FBMEM7SUFDMUMseUNBQXlDO0lBQ3pDLHVEQUF1RDtJQUN2RCxTQUFTO0lBQ1QsOENBQThDO0lBQzlDLDRDQUE0QztDQUM3QyxDQUFDO0FBRUY7Ozs7Ozs7Ozs7R0FVRztBQUtILE1BQU0sT0FBTyxrQ0FBa0M7d0dBQWxDLGtDQUFrQzt5R0FBbEMsa0NBQWtDO1lBaEM3QyxzQ0FBc0M7WUFDdEMsZUFBZTtZQUNmLG1CQUFtQjtZQUNuQixnQ0FBZ0M7WUFDaEMsK0JBQStCO1lBQy9CLHNCQUFzQjtZQUN0QixnQ0FBZ0M7WUFDaEMsYUFBYTtZQUNiLGtEQUFrRDtZQUNsRCwwQ0FBMEM7WUFDMUMseUNBQXlDO1lBQ3pDLHVEQUF1RDtZQUN2RCxTQUFTO1lBQ1QsOENBQThDO1lBQzlDLDRDQUE0QztZQWQ1QyxzQ0FBc0M7WUFDdEMsZUFBZTtZQUNmLG1CQUFtQjtZQUNuQixnQ0FBZ0M7WUFDaEMsK0JBQStCO1lBQy9CLHNCQUFzQjtZQUN0QixnQ0FBZ0M7WUFDaEMsYUFBYTtZQUNiLGtEQUFrRDtZQUNsRCwwQ0FBMEM7WUFDMUMseUNBQXlDO1lBQ3pDLHVEQUF1RDtZQUN2RCxTQUFTO1lBQ1QsOENBQThDO1lBQzlDLDRDQUE0Qzt5R0FrQmpDLGtDQUFrQztZQWhDN0Msc0NBQXNDO1lBQ3RDLGVBQWU7WUFDZixtQkFBbUI7WUFHbkIsc0JBQXNCO1lBTHRCLHNDQUFzQztZQUN0QyxlQUFlOzs0RkErQkosa0NBQWtDO2tCQUo5QyxRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxpQkFBaUI7b0JBQzFCLE9BQU8sRUFBRSxpQkFBaUI7aUJBQzNCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGJ4QWN0aW9uTG9hZGluZ0NvbnRleHREaXJlY3RpdmUsIERieEFjdGlvbk1vZHVsZSwgRGJ4QWN0aW9uU25hY2tiYXJFcnJvckRpcmVjdGl2ZSwgRGJ4RmlsZVVwbG9hZENvbXBvbmVudCwgRGJ4RmlsZVVwbG9hZEFjdGlvblN5bmNEaXJlY3RpdmUsIERieExvYWRpbmdDb21wb25lbnQgfSBmcm9tICdAZGVyZWVrYi9kYngtd2ViJztcbmltcG9ydCB7IERieEZpcmViYXNlU3RvcmFnZUZpbGVVcGxvYWRBY3Rpb25IYW5kbGVyRGlyZWN0aXZlLCBEYnhGaXJlYmFzZVN0b3JhZ2VGaWxlVXBsb2FkU3RvcmVEaXJlY3RpdmUsIERieEZpcmViYXNlU3RvcmFnZUZpbGVVcGxvYWRTeW5jRGlyZWN0aXZlLCBEYnhGaXJlYmFzZVN0b3JhZ2VGaWxlVXBsb2FkSW5pdGlhbGl6ZURvY3VtZW50RGlyZWN0aXZlIH0gZnJvbSAnLi9jb250YWluZXInO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IERieEZpcmViYXNlU3RvcmFnZUZpbGVEb2N1bWVudFN0b3JlRGlyZWN0aXZlIH0gZnJvbSAnLi9zdG9yZS9zdG9yYWdlZmlsZS5kb2N1bWVudC5zdG9yZS5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgRGJ4RmlyZWJhc2VTdG9yYWdlRmlsZUNvbGxlY3Rpb25TdG9yZURpcmVjdGl2ZSB9IGZyb20gJy4vc3RvcmUnO1xuXG5leHBvcnQgY29uc3QgaW1wb3J0c0FuZEV4cG9ydHMgPSBbXG4gIC8vIGRieC1jb3JlL2RieC13ZWIgbW9kdWxlcy9jb21wb25lbnRzXG4gIERieEFjdGlvbk1vZHVsZSxcbiAgRGJ4TG9hZGluZ0NvbXBvbmVudCxcbiAgRGJ4QWN0aW9uTG9hZGluZ0NvbnRleHREaXJlY3RpdmUsXG4gIERieEFjdGlvblNuYWNrYmFyRXJyb3JEaXJlY3RpdmUsXG4gIERieEZpbGVVcGxvYWRDb21wb25lbnQsXG4gIERieEZpbGVVcGxvYWRBY3Rpb25TeW5jRGlyZWN0aXZlLFxuICAvLyBjb250YWluZXJzXG4gIERieEZpcmViYXNlU3RvcmFnZUZpbGVVcGxvYWRBY3Rpb25IYW5kbGVyRGlyZWN0aXZlLFxuICBEYnhGaXJlYmFzZVN0b3JhZ2VGaWxlVXBsb2FkU3RvcmVEaXJlY3RpdmUsXG4gIERieEZpcmViYXNlU3RvcmFnZUZpbGVVcGxvYWRTeW5jRGlyZWN0aXZlLFxuICBEYnhGaXJlYmFzZVN0b3JhZ2VGaWxlVXBsb2FkSW5pdGlhbGl6ZURvY3VtZW50RGlyZWN0aXZlLFxuICAvLyBzdG9yZXNcbiAgRGJ4RmlyZWJhc2VTdG9yYWdlRmlsZUNvbGxlY3Rpb25TdG9yZURpcmVjdGl2ZSxcbiAgRGJ4RmlyZWJhc2VTdG9yYWdlRmlsZURvY3VtZW50U3RvcmVEaXJlY3RpdmVcbl07XG5cbi8qKlxuICogQ29udmVuaWVuY2UgbW9kdWxlIGZvciBpbXBvcnRpbmcgdmFyaW91cyBtb2R1bGVzL2NvbXBvbmVudHMgdGhhdCBhcmUgcmVsZXZhbnQgdG8gdGhlIHN0b3JhZ2UgZmlsZSB1cGxvYWQgZmVhdHVyZS5cbiAqXG4gKiAtIERieEFjdGlvbk1vZHVsZVxuICogLSBEYnhGaWxlVXBsb2FkQ29tcG9uZW50XG4gKiAtIERieEZpcmViYXNlU3RvcmFnZUZpbGVVcGxvYWRBY3Rpb25IYW5kbGVyRGlyZWN0aXZlXG4gKiAtIERieEZpcmViYXNlU3RvcmFnZUZpbGVVcGxvYWRTdG9yZURpcmVjdGl2ZVxuICogLSBEYnhGaXJlYmFzZVN0b3JhZ2VGaWxlVXBsb2FkU3luY0RpcmVjdGl2ZVxuICogLSBEYnhGaXJlYmFzZVN0b3JhZ2VGaWxlVXBsb2FkSW5pdGlhbGl6ZURvY3VtZW50RGlyZWN0aXZlXG4gKiAtIERieEZpcmViYXNlU3RvcmFnZUZpbGVVcGxvYWRTdG9yZVxuICovXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBpbXBvcnRzQW5kRXhwb3J0cyxcbiAgZXhwb3J0czogaW1wb3J0c0FuZEV4cG9ydHNcbn0pXG5leHBvcnQgY2xhc3MgRGJ4RmlyZWJhc2VTdG9yYWdlRmlsZVVwbG9hZE1vZHVsZSB7fVxuIl19

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

@@ -0,0 +1,6 @@
+export * from './storagefile.collection.store';
+export * from './storagefile.collection.store.directive';
+export * from './storagefile.document.store';
+export * from './storagefile.document.store.directive';
+export * from './storagefile.upload.store';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZmlyZWJhc2Uvc3JjL2xpYi9tb2R1bGVzL3N0b3JhZ2VmaWxlL3N0b3JlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYywwQ0FBMEMsQ0FBQztBQUN6RCxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsd0NBQXdDLENBQUM7QUFDdkQsY0FBYyw0QkFBNEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc3RvcmFnZWZpbGUuY29sbGVjdGlvbi5zdG9yZSc7XG5leHBvcnQgKiBmcm9tICcuL3N0b3JhZ2VmaWxlLmNvbGxlY3Rpb24uc3RvcmUuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vc3RvcmFnZWZpbGUuZG9jdW1lbnQuc3RvcmUnO1xuZXhwb3J0ICogZnJvbSAnLi9zdG9yYWdlZmlsZS5kb2N1bWVudC5zdG9yZS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9zdG9yYWdlZmlsZS51cGxvYWQuc3RvcmUnO1xuIl19

package/esm2022/lib/modules/storagefile/store/storagefile.collection.store.directive.mjs

@@ -0,0 +1,22 @@
+import { Directive } from '@angular/core';
+import { DbxFirebaseCollectionStoreDirective, provideDbxFirebaseCollectionStoreDirective } from '../../../model/modules/store';
+import { StorageFileCollectionStore } from './storagefile.collection.store';
+import * as i0 from "@angular/core";
+import * as i1 from "./storagefile.collection.store";
+export class DbxFirebaseStorageFileCollectionStoreDirective extends DbxFirebaseCollectionStoreDirective {
+    constructor(store) {
+        super(store);
+        this.setConstraints([]);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileCollectionStoreDirective, deps: [{ token: i1.StorageFileCollectionStore }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: DbxFirebaseStorageFileCollectionStoreDirective, isStandalone: true, selector: "[dbxFirebaseStorageFileCollection]", providers: provideDbxFirebaseCollectionStoreDirective(DbxFirebaseStorageFileCollectionStoreDirective, StorageFileCollectionStore), usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseStorageFileCollectionStoreDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxFirebaseStorageFileCollection]',
+                    providers: provideDbxFirebaseCollectionStoreDirective(DbxFirebaseStorageFileCollectionStoreDirective, StorageFileCollectionStore),
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.StorageFileCollectionStore }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,18 @@
+import { Injectable, inject } from '@angular/core';
+import { AbstractDbxFirebaseCollectionStore, firebaseCollectionStoreCreateFunction } from '../../../model/modules/store';
+import { StorageFileFirestoreCollections, StorageFileFunctions } from '@dereekb/firebase';
+import * as i0 from "@angular/core";
+import * as i1 from "@dereekb/firebase";
+export class StorageFileCollectionStore extends AbstractDbxFirebaseCollectionStore {
+    storageFileFunctions = inject(StorageFileFunctions);
+    constructor(collections) {
+        super({ firestoreCollection: collections.storageFileCollection });
+    }
+    initializeAllStorageFilesFromUpload = firebaseCollectionStoreCreateFunction(this, this.storageFileFunctions.storageFile.createStorageFile.allFromUpload);
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StorageFileCollectionStore, deps: [{ token: i1.StorageFileFirestoreCollections }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StorageFileCollectionStore });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StorageFileCollectionStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.StorageFileFirestoreCollections }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZWZpbGUuY29sbGVjdGlvbi5zdG9yZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2RieC1maXJlYmFzZS9zcmMvbGliL21vZHVsZXMvc3RvcmFnZWZpbGUvc3RvcmUvc3RvcmFnZWZpbGUuY29sbGVjdGlvbi5zdG9yZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNuRCxPQUFPLEVBQUUsa0NBQWtDLEVBQUUscUNBQXFDLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUN6SCxPQUFPLEVBQUUsK0JBQStCLEVBQW9DLG9CQUFvQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7OztBQUc1SCxNQUFNLE9BQU8sMEJBQTJCLFNBQVEsa0NBQW9FO0lBQ3pHLG9CQUFvQixHQUFHLE1BQU0sQ0FBQyxvQkFBb0IsQ0FBQyxDQUFDO0lBRTdELFlBQVksV0FBNEM7UUFDdEQsS0FBSyxDQUFDLEVBQUUsbUJBQW1CLEVBQUUsV0FBVyxDQUFDLHFCQUFxQixFQUFFLENBQUMsQ0FBQztJQUNwRSxDQUFDO0lBRVEsbUNBQW1DLEdBQUcscUNBQXFDLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxvQkFBb0IsQ0FBQyxXQUFXLENBQUMsaUJBQWlCLENBQUMsYUFBYSxDQUFDLENBQUM7d0dBUHZKLDBCQUEwQjs0R0FBMUIsMEJBQTBCOzs0RkFBMUIsMEJBQTBCO2tCQUR0QyxVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSwgaW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBBYnN0cmFjdERieEZpcmViYXNlQ29sbGVjdGlvblN0b3JlLCBmaXJlYmFzZUNvbGxlY3Rpb25TdG9yZUNyZWF0ZUZ1bmN0aW9uIH0gZnJvbSAnLi4vLi4vLi4vbW9kZWwvbW9kdWxlcy9zdG9yZSc7XG5pbXBvcnQgeyBTdG9yYWdlRmlsZUZpcmVzdG9yZUNvbGxlY3Rpb25zLCBTdG9yYWdlRmlsZSwgU3RvcmFnZUZpbGVEb2N1bWVudCwgU3RvcmFnZUZpbGVGdW5jdGlvbnMgfSBmcm9tICdAZGVyZWVrYi9maXJlYmFzZSc7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBTdG9yYWdlRmlsZUNvbGxlY3Rpb25TdG9yZSBleHRlbmRzIEFic3RyYWN0RGJ4RmlyZWJhc2VDb2xsZWN0aW9uU3RvcmU8U3RvcmFnZUZpbGUsIFN0b3JhZ2VGaWxlRG9jdW1lbnQ+IHtcbiAgcmVhZG9ubHkgc3RvcmFnZUZpbGVGdW5jdGlvbnMgPSBpbmplY3QoU3RvcmFnZUZpbGVGdW5jdGlvbnMpO1xuXG4gIGNvbnN0cnVjdG9yKGNvbGxlY3Rpb25zOiBTdG9yYWdlRmlsZUZpcmVzdG9yZUNvbGxlY3Rpb25zKSB7XG4gICAgc3VwZXIoeyBmaXJlc3RvcmVDb2xsZWN0aW9uOiBjb2xsZWN0aW9ucy5zdG9yYWdlRmlsZUNvbGxlY3Rpb24gfSk7XG4gIH1cblxuICByZWFkb25seSBpbml0aWFsaXplQWxsU3RvcmFnZUZpbGVzRnJvbVVwbG9hZCA9IGZpcmViYXNlQ29sbGVjdGlvblN0b3JlQ3JlYXRlRnVuY3Rpb24odGhpcywgdGhpcy5zdG9yYWdlRmlsZUZ1bmN0aW9ucy5zdG9yYWdlRmlsZS5jcmVhdGVTdG9yYWdlRmlsZS5hbGxGcm9tVXBsb2FkKTtcbn1cbiJdfQ==