@verdant-web/store 2.0.1 → 2.0.2

package/dist/esm/files/FileManager.js

@@ -1,142 +1,142 @@
-import { EntityFile, MARK_FAILED, UPDATE } from './EntityFile.js';
-import { FileStorage } from './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);
-}
-export 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(file.id);
-                entityFile[UPDATE](file);
-                this.files.set(file.id, entityFile);
-            }
-            else {
-                this.files.get(file.id)[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(id);
-            this.files.set(id, file);
-            this.load(file);
-            return file;
-        };
-        this.load = async (file, retries = 0) => {
-            if (retries > 5) {
-                file[MARK_FAILED]();
-                return;
-            }
-            const fileData = await this.storage.getFile(file.id);
-            if (fileData) {
-                file[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[UPDATE](result.data);
-                        await this.storage.addFile(result.data);
-                    }
-                    else {
-                        file[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[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(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();
-    }
-}
+import { EntityFile, MARK_FAILED, UPDATE } from './EntityFile.js';
+import { FileStorage } from './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);
+}
+export 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(file.id);
+                entityFile[UPDATE](file);
+                this.files.set(file.id, entityFile);
+            }
+            else {
+                this.files.get(file.id)[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(id);
+            this.files.set(id, file);
+            this.load(file);
+            return file;
+        };
+        this.load = async (file, retries = 0) => {
+            if (retries > 5) {
+                file[MARK_FAILED]();
+                return;
+            }
+            const fileData = await this.storage.getFile(file.id);
+            if (fileData) {
+                file[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[UPDATE](result.data);
+                        await this.storage.addFile(result.data);
+                    }
+                    else {
+                        file[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[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(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();
+    }
+}
 //# sourceMappingURL=FileManager.js.map

package/dist/esm/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/esm/files/FileStorage.js

@@ -1,89 +1,89 @@
-import { IDBService } from '../IDBService.js';
-import { fileToArrayBuffer } from './utils.js';
-export class FileStorage extends IDBService {
-    constructor() {
-        super(...arguments);
-        this.addFile = async (file, { transaction } = {}) => {
-            const buffer = file.file ? await 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);
-    }
-}
-export function arrayBufferToBlob(buffer, type) {
-    return new Blob([buffer], { type });
-}
+import { IDBService } from '../IDBService.js';
+import { fileToArrayBuffer } from './utils.js';
+export class FileStorage extends IDBService {
+    constructor() {
+        super(...arguments);
+        this.addFile = async (file, { transaction } = {}) => {
+            const buffer = file.file ? await 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);
+    }
+}
+export function arrayBufferToBlob(buffer, type) {
+    return new Blob([buffer], { type });
+}
 //# sourceMappingURL=FileStorage.js.map

package/dist/esm/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>;

package/dist/esm/files/utils.js

@@ -1,47 +1,47 @@
-import { createFileRef } from '@verdant-web/common';
-import cuid from 'cuid';
-export function createFileData(file) {
-    return {
-        id: cuid(),
-        file: file,
-        url: undefined,
-        remote: false,
-        name: file.name,
-        type: file.type,
-    };
-}
-/**
- * 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 function processValueFiles(value, onFileIdentified) {
-    if (value instanceof File) {
-        const data = createFileData(value);
-        onFileIdentified(data);
-        return createFileRef(data.id);
-    }
-    if (Array.isArray(value)) {
-        for (let i = 0; i < value.length; i++) {
-            value[i] = processValueFiles(value[i], onFileIdentified);
-        }
-        return value;
-    }
-    if (typeof value === 'object') {
-        for (const key in value) {
-            value[key] = processValueFiles(value[key], onFileIdentified);
-        }
-        return value;
-    }
-    return value;
-}
-export function fileToArrayBuffer(file) {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onload = () => {
-            resolve(reader.result);
-        };
-        reader.onerror = reject;
-        reader.readAsArrayBuffer(file);
-    });
-}
+import { createFileRef } from '@verdant-web/common';
+import cuid from 'cuid';
+export function createFileData(file) {
+    return {
+        id: cuid(),
+        file: file,
+        url: undefined,
+        remote: false,
+        name: file.name,
+        type: file.type,
+    };
+}
+/**
+ * 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 function processValueFiles(value, onFileIdentified) {
+    if (value instanceof File) {
+        const data = createFileData(value);
+        onFileIdentified(data);
+        return createFileRef(data.id);
+    }
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            value[i] = processValueFiles(value[i], onFileIdentified);
+        }
+        return value;
+    }
+    if (typeof value === 'object') {
+        for (const key in value) {
+            value[key] = processValueFiles(value[key], onFileIdentified);
+        }
+        return value;
+    }
+    return value;
+}
+export function fileToArrayBuffer(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            resolve(reader.result);
+        };
+        reader.onerror = reject;
+        reader.readAsArrayBuffer(file);
+    });
+}
 //# sourceMappingURL=utils.js.map

package/dist/esm/files/utils.test.d.ts

@@ -1 +1 @@
-export {};
+export {};