@verdant-web/store 2.0.1 → 2.0.2

package/dist/cjs/files/FileManager.js

@@ -1,146 +1,146 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileManager = void 0;
-const EntityFile_js_1 = require("./EntityFile.js");
-const FileStorage_js_1 = require("./FileStorage.js");
-/**
- * Default: if file was deleted > 3 days ago
- */
-function defaultCanCleanup(fileData) {
-    return (fileData.deletedAt !== null &&
-        fileData.deletedAt < Date.now() - 1000 * 60 * 24 * 3);
-}
-class FileManager {
-    constructor({ db, sync, context, meta, config = {}, }) {
-        this.files = new Map();
-        this.add = async (fileInput) => {
-            const file = fileInput;
-            file.remote = false;
-            // immediately cache the file
-            if (!this.files.has(file.id)) {
-                const entityFile = new EntityFile_js_1.EntityFile(file.id);
-                entityFile[EntityFile_js_1.UPDATE](file);
-                this.files.set(file.id, entityFile);
-            }
-            else {
-                this.files.get(file.id)[EntityFile_js_1.UPDATE](file);
-            }
-            // write to local storage and send to sync immediately
-            await this.storage.addFile(file);
-            // send to sync
-            if (file.file) {
-                const result = await this.sync.uploadFile(file);
-                if (result.success) {
-                    await this.storage.markUploaded(file.id);
-                }
-                else {
-                    this.context.log('error', 'Failed to upload file');
-                }
-            }
-        };
-        this.uploadFile = async (file, retries = 0) => {
-            const result = await this.sync.uploadFile(file);
-            if (result.success) {
-                await this.storage.markUploaded(file.id);
-            }
-            else {
-                if (result.retry && retries < 5) {
-                    this.context.log('error', 'Error uploading file, retrying...');
-                    // schedule a retry
-                    setTimeout(this.uploadFile, 1000, file, retries + 1);
-                }
-                else {
-                    this.context.log('error', 'Failed to upload file. Not retrying until next sync.');
-                }
-            }
-        };
-        /**
-         * Immediately returns an EntityFile to use, then either loads
-         * the file from cache, local database, or the server.
-         */
-        this.get = (id) => {
-            if (this.files.has(id)) {
-                return this.files.get(id);
-            }
-            const file = new EntityFile_js_1.EntityFile(id);
-            this.files.set(id, file);
-            this.load(file);
-            return file;
-        };
-        this.load = async (file, retries = 0) => {
-            if (retries > 5) {
-                file[EntityFile_js_1.MARK_FAILED]();
-                return;
-            }
-            const fileData = await this.storage.getFile(file.id);
-            if (fileData) {
-                file[EntityFile_js_1.UPDATE](fileData);
-            }
-            else {
-                // maybe we don't have it yet, it might be on the server still.
-                try {
-                    const result = await this.sync.getFile(file.id);
-                    if (result.success) {
-                        file[EntityFile_js_1.UPDATE](result.data);
-                        await this.storage.addFile(result.data);
-                    }
-                    else {
-                        file[EntityFile_js_1.MARK_FAILED]();
-                        if (result.retry) {
-                            // schedule a retry
-                            setTimeout(this.load, 1000, file, retries + 1);
-                        }
-                    }
-                }
-                catch (err) {
-                    this.context.log('error', 'Failed to load file', err);
-                    file[EntityFile_js_1.MARK_FAILED]();
-                    // schedule a retry
-                    setTimeout(this.load, 1000, file, retries + 1);
-                }
-            }
-        };
-        this.listUnsynced = async () => {
-            return this.storage.listUnsynced();
-        };
-        this.onOnlineChange = async (online) => {
-            // if online, try to upload any unsynced files
-            if (online) {
-                const unsynced = await this.listUnsynced();
-                await Promise.all(unsynced.map(this.uploadFile));
-            }
-        };
-        this.tryCleanupDeletedFiles = async () => {
-            let count = 0;
-            let skipCount = 0;
-            await this.storage.iterateOverPendingDelete((fileData, store) => {
-                if (this.config.canCleanupDeletedFile(fileData)) {
-                    count++;
-                    store.delete(fileData.id);
-                }
-                else {
-                    skipCount++;
-                }
-            });
-            this.context.log('info', `Cleaned up ${count} files, skipped ${skipCount} files`);
-        };
-        this.handleFileRefsDeleted = async (fileRefs) => {
-            const tx = this.storage.createTransaction(['files'], 'readwrite');
-            await Promise.all(fileRefs.map(async (fileRef) => {
-                await this.storage.markPendingDelete(fileRef.id, { transaction: tx });
-            }));
-            this.context.log('info', `Marked ${fileRefs.length} files as pending delete`);
-        };
-        this.storage = new FileStorage_js_1.FileStorage(db);
-        this.sync = sync;
-        this.context = context;
-        this.meta = meta;
-        this.config = Object.assign({ canCleanupDeletedFile: defaultCanCleanup }, config);
-        this.sync.subscribe('onlineChange', this.onOnlineChange);
-        this.meta.subscribe('filesDeleted', this.handleFileRefsDeleted);
-        // check on startup to see if files can be cleaned up
-        this.tryCleanupDeletedFiles();
-    }
-}
-exports.FileManager = FileManager;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileManager = void 0;
+const EntityFile_js_1 = require("./EntityFile.js");
+const FileStorage_js_1 = require("./FileStorage.js");
+/**
+ * Default: if file was deleted > 3 days ago
+ */
+function defaultCanCleanup(fileData) {
+    return (fileData.deletedAt !== null &&
+        fileData.deletedAt < Date.now() - 1000 * 60 * 24 * 3);
+}
+class FileManager {
+    constructor({ db, sync, context, meta, config = {}, }) {
+        this.files = new Map();
+        this.add = async (fileInput) => {
+            const file = fileInput;
+            file.remote = false;
+            // immediately cache the file
+            if (!this.files.has(file.id)) {
+                const entityFile = new EntityFile_js_1.EntityFile(file.id);
+                entityFile[EntityFile_js_1.UPDATE](file);
+                this.files.set(file.id, entityFile);
+            }
+            else {
+                this.files.get(file.id)[EntityFile_js_1.UPDATE](file);
+            }
+            // write to local storage and send to sync immediately
+            await this.storage.addFile(file);
+            // send to sync
+            if (file.file) {
+                const result = await this.sync.uploadFile(file);
+                if (result.success) {
+                    await this.storage.markUploaded(file.id);
+                }
+                else {
+                    this.context.log('error', 'Failed to upload file');
+                }
+            }
+        };
+        this.uploadFile = async (file, retries = 0) => {
+            const result = await this.sync.uploadFile(file);
+            if (result.success) {
+                await this.storage.markUploaded(file.id);
+            }
+            else {
+                if (result.retry && retries < 5) {
+                    this.context.log('error', 'Error uploading file, retrying...');
+                    // schedule a retry
+                    setTimeout(this.uploadFile, 1000, file, retries + 1);
+                }
+                else {
+                    this.context.log('error', 'Failed to upload file. Not retrying until next sync.');
+                }
+            }
+        };
+        /**
+         * Immediately returns an EntityFile to use, then either loads
+         * the file from cache, local database, or the server.
+         */
+        this.get = (id) => {
+            if (this.files.has(id)) {
+                return this.files.get(id);
+            }
+            const file = new EntityFile_js_1.EntityFile(id);
+            this.files.set(id, file);
+            this.load(file);
+            return file;
+        };
+        this.load = async (file, retries = 0) => {
+            if (retries > 5) {
+                file[EntityFile_js_1.MARK_FAILED]();
+                return;
+            }
+            const fileData = await this.storage.getFile(file.id);
+            if (fileData) {
+                file[EntityFile_js_1.UPDATE](fileData);
+            }
+            else {
+                // maybe we don't have it yet, it might be on the server still.
+                try {
+                    const result = await this.sync.getFile(file.id);
+                    if (result.success) {
+                        file[EntityFile_js_1.UPDATE](result.data);
+                        await this.storage.addFile(result.data);
+                    }
+                    else {
+                        file[EntityFile_js_1.MARK_FAILED]();
+                        if (result.retry) {
+                            // schedule a retry
+                            setTimeout(this.load, 1000, file, retries + 1);
+                        }
+                    }
+                }
+                catch (err) {
+                    this.context.log('error', 'Failed to load file', err);
+                    file[EntityFile_js_1.MARK_FAILED]();
+                    // schedule a retry
+                    setTimeout(this.load, 1000, file, retries + 1);
+                }
+            }
+        };
+        this.listUnsynced = async () => {
+            return this.storage.listUnsynced();
+        };
+        this.onOnlineChange = async (online) => {
+            // if online, try to upload any unsynced files
+            if (online) {
+                const unsynced = await this.listUnsynced();
+                await Promise.all(unsynced.map(this.uploadFile));
+            }
+        };
+        this.tryCleanupDeletedFiles = async () => {
+            let count = 0;
+            let skipCount = 0;
+            await this.storage.iterateOverPendingDelete((fileData, store) => {
+                if (this.config.canCleanupDeletedFile(fileData)) {
+                    count++;
+                    store.delete(fileData.id);
+                }
+                else {
+                    skipCount++;
+                }
+            });
+            this.context.log('info', `Cleaned up ${count} files, skipped ${skipCount} files`);
+        };
+        this.handleFileRefsDeleted = async (fileRefs) => {
+            const tx = this.storage.createTransaction(['files'], 'readwrite');
+            await Promise.all(fileRefs.map(async (fileRef) => {
+                await this.storage.markPendingDelete(fileRef.id, { transaction: tx });
+            }));
+            this.context.log('info', `Marked ${fileRefs.length} files as pending delete`);
+        };
+        this.storage = new FileStorage_js_1.FileStorage(db);
+        this.sync = sync;
+        this.context = context;
+        this.meta = meta;
+        this.config = Object.assign({ canCleanupDeletedFile: defaultCanCleanup }, config);
+        this.sync.subscribe('onlineChange', this.onOnlineChange);
+        this.meta.subscribe('filesDeleted', this.handleFileRefsDeleted);
+        // check on startup to see if files can be cleaned up
+        this.tryCleanupDeletedFiles();
+    }
+}
+exports.FileManager = FileManager;
 //# sourceMappingURL=FileManager.js.map

package/dist/cjs/files/FileStorage.d.ts

@@ -1,27 +1,27 @@
-import { FileData } from '@verdant-web/common';
-import { IDBService } from '../IDBService.js';
-export interface ReturnedFileData extends FileData {
-    deletedAt: number | null;
-}
-export declare class FileStorage extends IDBService {
-    addFile: (file: FileData, { transaction }?: {
-        transaction?: IDBTransaction | undefined;
-    }) => Promise<IDBValidKey>;
-    private hydrateFileData;
-    markUploaded: (id: string, { transaction }?: {
-        transaction?: IDBTransaction | undefined;
-    }) => Promise<IDBValidKey>;
-    private getFileRaw;
-    getFile: (id: string, { transaction }?: {
-        transaction?: IDBTransaction | undefined;
-    }) => Promise<ReturnedFileData | undefined>;
-    deleteFile(id: string, { transaction }?: {
-        transaction?: IDBTransaction;
-    }): Promise<undefined>;
-    markPendingDelete: (id: string, { transaction }?: {
-        transaction?: IDBTransaction | undefined;
-    }) => Promise<IDBValidKey>;
-    listUnsynced: () => Promise<ReturnedFileData[]>;
-    iterateOverPendingDelete: (iterator: (file: ReturnedFileData, store: IDBObjectStore) => void, transaction?: IDBTransaction) => Promise<void>;
-}
-export declare function arrayBufferToBlob(buffer: ArrayBuffer, type: string): Blob;
+import { FileData } from '@verdant-web/common';
+import { IDBService } from '../IDBService.js';
+export interface ReturnedFileData extends FileData {
+    deletedAt: number | null;
+}
+export declare class FileStorage extends IDBService {
+    addFile: (file: FileData, { transaction }?: {
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<IDBValidKey>;
+    private hydrateFileData;
+    markUploaded: (id: string, { transaction }?: {
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<IDBValidKey>;
+    private getFileRaw;
+    getFile: (id: string, { transaction }?: {
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<ReturnedFileData | undefined>;
+    deleteFile(id: string, { transaction }?: {
+        transaction?: IDBTransaction;
+    }): Promise<undefined>;
+    markPendingDelete: (id: string, { transaction }?: {
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<IDBValidKey>;
+    listUnsynced: () => Promise<ReturnedFileData[]>;
+    iterateOverPendingDelete: (iterator: (file: ReturnedFileData, store: IDBObjectStore) => void, transaction?: IDBTransaction) => Promise<void>;
+}
+export declare function arrayBufferToBlob(buffer: ArrayBuffer, type: string): Blob;

package/dist/cjs/files/FileStorage.js

@@ -1,94 +1,94 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrayBufferToBlob = exports.FileStorage = void 0;
-const IDBService_js_1 = require("../IDBService.js");
-const utils_js_1 = require("./utils.js");
-class FileStorage extends IDBService_js_1.IDBService {
-    constructor() {
-        super(...arguments);
-        this.addFile = async (file, { transaction } = {}) => {
-            const buffer = file.file ? await (0, utils_js_1.fileToArrayBuffer)(file.file) : undefined;
-            return this.run('files', (store) => {
-                return store.put({
-                    id: file.id,
-                    // IDB doesn't support boolean indexes
-                    remote: file.remote ? 'true' : 'false',
-                    deletedAt: null,
-                    name: file.name,
-                    type: file.type,
-                    url: file.url,
-                    buffer,
-                });
-            }, 'readwrite', transaction);
-        };
-        this.hydrateFileData = (raw) => {
-            raw.remote = raw.remote === 'true';
-            const buffer = raw.buffer;
-            delete raw.buffer;
-            raw.file = buffer
-                ? arrayBufferToBlob(buffer, raw.type)
-                : undefined;
-            return raw;
-        };
-        this.markUploaded = async (id, { transaction } = {}) => {
-            const current = await this.getFileRaw(id, { transaction });
-            if (!current) {
-                throw new Error('File is not in local database');
-            }
-            return this.run('files', (store) => {
-                return store.put(Object.assign(Object.assign({}, current), { remote: 'true' }));
-            }, 'readwrite', transaction);
-        };
-        this.getFileRaw = async (id, { transaction } = {}) => {
-            const raw = await this.run('files', (store) => {
-                return store.get(id);
-            }, 'readonly', transaction);
-            if (!raw) {
-                return undefined;
-            }
-            return raw;
-        };
-        this.getFile = async (id, { transaction } = {}) => {
-            const raw = await this.getFileRaw(id, { transaction });
-            if (!raw) {
-                return undefined;
-            }
-            return this.hydrateFileData(raw);
-        };
-        this.markPendingDelete = async (id, { transaction } = {}) => {
-            const current = await this.getFileRaw(id, { transaction });
-            if (!current) {
-                throw new Error('File is not in local database');
-            }
-            return this.run('files', (store) => {
-                return store.put(Object.assign(Object.assign({}, current), { deletedAt: Date.now() }));
-            }, 'readwrite', transaction);
-        };
-        this.listUnsynced = async () => {
-            const raw = await this.run('files', (store) => {
-                return store.index('remote').getAll('false');
-            }, 'readonly');
-            return raw.map(this.hydrateFileData);
-        };
-        this.iterateOverPendingDelete = (iterator, transaction) => {
-            return this.iterate('files', (store) => {
-                return store
-                    .index('deletedAt')
-                    .openCursor(IDBKeyRange.lowerBound(0, true));
-            }, (value, store) => {
-                iterator(this.hydrateFileData(value), store);
-            }, 'readwrite', transaction);
-        };
-    }
-    deleteFile(id, { transaction } = {}) {
-        return this.run('files', (store) => {
-            return store.delete(id);
-        }, 'readwrite', transaction);
-    }
-}
-exports.FileStorage = FileStorage;
-function arrayBufferToBlob(buffer, type) {
-    return new Blob([buffer], { type });
-}
-exports.arrayBufferToBlob = arrayBufferToBlob;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayBufferToBlob = exports.FileStorage = void 0;
+const IDBService_js_1 = require("../IDBService.js");
+const utils_js_1 = require("./utils.js");
+class FileStorage extends IDBService_js_1.IDBService {
+    constructor() {
+        super(...arguments);
+        this.addFile = async (file, { transaction } = {}) => {
+            const buffer = file.file ? await (0, utils_js_1.fileToArrayBuffer)(file.file) : undefined;
+            return this.run('files', (store) => {
+                return store.put({
+                    id: file.id,
+                    // IDB doesn't support boolean indexes
+                    remote: file.remote ? 'true' : 'false',
+                    deletedAt: null,
+                    name: file.name,
+                    type: file.type,
+                    url: file.url,
+                    buffer,
+                });
+            }, 'readwrite', transaction);
+        };
+        this.hydrateFileData = (raw) => {
+            raw.remote = raw.remote === 'true';
+            const buffer = raw.buffer;
+            delete raw.buffer;
+            raw.file = buffer
+                ? arrayBufferToBlob(buffer, raw.type)
+                : undefined;
+            return raw;
+        };
+        this.markUploaded = async (id, { transaction } = {}) => {
+            const current = await this.getFileRaw(id, { transaction });
+            if (!current) {
+                throw new Error('File is not in local database');
+            }
+            return this.run('files', (store) => {
+                return store.put(Object.assign(Object.assign({}, current), { remote: 'true' }));
+            }, 'readwrite', transaction);
+        };
+        this.getFileRaw = async (id, { transaction } = {}) => {
+            const raw = await this.run('files', (store) => {
+                return store.get(id);
+            }, 'readonly', transaction);
+            if (!raw) {
+                return undefined;
+            }
+            return raw;
+        };
+        this.getFile = async (id, { transaction } = {}) => {
+            const raw = await this.getFileRaw(id, { transaction });
+            if (!raw) {
+                return undefined;
+            }
+            return this.hydrateFileData(raw);
+        };
+        this.markPendingDelete = async (id, { transaction } = {}) => {
+            const current = await this.getFileRaw(id, { transaction });
+            if (!current) {
+                throw new Error('File is not in local database');
+            }
+            return this.run('files', (store) => {
+                return store.put(Object.assign(Object.assign({}, current), { deletedAt: Date.now() }));
+            }, 'readwrite', transaction);
+        };
+        this.listUnsynced = async () => {
+            const raw = await this.run('files', (store) => {
+                return store.index('remote').getAll('false');
+            }, 'readonly');
+            return raw.map(this.hydrateFileData);
+        };
+        this.iterateOverPendingDelete = (iterator, transaction) => {
+            return this.iterate('files', (store) => {
+                return store
+                    .index('deletedAt')
+                    .openCursor(IDBKeyRange.lowerBound(0, true));
+            }, (value, store) => {
+                iterator(this.hydrateFileData(value), store);
+            }, 'readwrite', transaction);
+        };
+    }
+    deleteFile(id, { transaction } = {}) {
+        return this.run('files', (store) => {
+            return store.delete(id);
+        }, 'readwrite', transaction);
+    }
+}
+exports.FileStorage = FileStorage;
+function arrayBufferToBlob(buffer, type) {
+    return new Blob([buffer], { type });
+}
+exports.arrayBufferToBlob = arrayBufferToBlob;
 //# sourceMappingURL=FileStorage.js.map

package/dist/cjs/files/utils.d.ts

@@ -1,8 +1,8 @@
-import { FileData } from '@verdant-web/common';
-export declare function createFileData(file: File): FileData;
-/**
- * Replaces File values with refs and returns the normalized value.
- * The list of files passed to the second argument will be populated with the files found in the value.
- */
-export declare function processValueFiles(value: any, onFileIdentified: (fileData: FileData) => void): any;
-export declare function fileToArrayBuffer(file: File | Blob): Promise<ArrayBuffer>;
+import { FileData } from '@verdant-web/common';
+export declare function createFileData(file: File): FileData;
+/**
+ * Replaces File values with refs and returns the normalized value.
+ * The list of files passed to the second argument will be populated with the files found in the value.
+ */
+export declare function processValueFiles(value: any, onFileIdentified: (fileData: FileData) => void): any;
+export declare function fileToArrayBuffer(file: File | Blob): Promise<ArrayBuffer>;