@verdant-web/store 2.7.5 → 2.7.7-next.0

package/dist/esm/files/EntityFile.d.ts

@@ -1,31 +1,31 @@
-import { EventSubscriber, FileData } from '@verdant-web/common';
-export type EntityFileEvents = {
-    change: () => void;
-};
-export declare const UPDATE: unique symbol;
-export declare const MARK_FAILED: unique symbol;
-/**
- * Provides a consistent interface for files used in an app via
- * Entity access.
- */
-export declare class EntityFile extends EventSubscriber<EntityFileEvents> {
-    readonly id: string;
-    private _objectUrl;
-    private _fileData;
-    private _loading;
-    private _failed;
-    private _disposed;
-    private _downloadRemote;
-    constructor(id: string, { downloadRemote, }?: {
-        downloadRemote?: boolean;
-    });
-    get downloadRemote(): boolean;
-    [UPDATE]: (fileData: FileData) => void;
-    [MARK_FAILED]: () => void;
-    get url(): string | null;
-    get name(): string | null;
-    get type(): string | null;
-    get loading(): boolean;
-    get failed(): boolean;
-    dispose: () => void;
-}
+import { EventSubscriber, FileData } from '@verdant-web/common';
+export type EntityFileEvents = {
+    change: () => void;
+};
+export declare const UPDATE: unique symbol;
+export declare const MARK_FAILED: unique symbol;
+/**
+ * Provides a consistent interface for files used in an app via
+ * Entity access.
+ */
+export declare class EntityFile extends EventSubscriber<EntityFileEvents> {
+    readonly id: string;
+    private _objectUrl;
+    private _fileData;
+    private _loading;
+    private _failed;
+    private _disposed;
+    private _downloadRemote;
+    constructor(id: string, { downloadRemote, }?: {
+        downloadRemote?: boolean;
+    });
+    get downloadRemote(): boolean;
+    [UPDATE]: (fileData: FileData) => void;
+    [MARK_FAILED]: () => void;
+    get url(): string | null;
+    get name(): string | null;
+    get type(): string | null;
+    get loading(): boolean;
+    get failed(): boolean;
+    dispose: () => void;
+}

package/dist/esm/files/EntityFile.js

@@ -1,73 +1,73 @@
-var _a, _b;
-import { EventSubscriber } from '@verdant-web/common';
-export const UPDATE = Symbol('entity-file-update');
-export const MARK_FAILED = Symbol('entity-file-mark-failed');
-/**
- * Provides a consistent interface for files used in an app via
- * Entity access.
- */
-export class EntityFile extends EventSubscriber {
-    constructor(id, { downloadRemote = false, } = {}) {
-        super();
-        this.id = id;
-        // cached object URL for a local blob file, if applicable
-        this._objectUrl = null;
-        this._fileData = null;
-        this._loading = true;
-        this._failed = false;
-        this._disposed = false;
-        this._downloadRemote = false;
-        this[_a] = (fileData) => {
-            this._loading = false;
-            this._failed = false;
-            this._disposed = false;
-            this._fileData = fileData;
-            if (fileData.file) {
-                if (this._objectUrl) {
-                    URL.revokeObjectURL(this._objectUrl);
-                }
-                this._objectUrl = URL.createObjectURL(fileData.file);
-            }
-            this.emit('change');
-        };
-        this[_b] = () => {
-            this._failed = true;
-            this._loading = false;
-            this.emit('change');
-        };
-        this.dispose = () => {
-            if (this._objectUrl) {
-                URL.revokeObjectURL(this._objectUrl);
-            }
-            this._disposed = true;
-        };
-        this._downloadRemote = downloadRemote;
-    }
-    get downloadRemote() {
-        return this._downloadRemote;
-    }
-    get url() {
-        var _c, _d;
-        if (this.loading)
-            return null;
-        if (this._objectUrl)
-            return this._objectUrl;
-        return (_d = (_c = this._fileData) === null || _c === void 0 ? void 0 : _c.url) !== null && _d !== void 0 ? _d : null;
-    }
-    get name() {
-        var _c, _d;
-        return (_d = (_c = this._fileData) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : null;
-    }
-    get type() {
-        var _c, _d;
-        return (_d = (_c = this._fileData) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : null;
-    }
-    get loading() {
-        return this._loading;
-    }
-    get failed() {
-        return this._failed;
-    }
-}
-_a = UPDATE, _b = MARK_FAILED;
+var _a, _b;
+import { EventSubscriber } from '@verdant-web/common';
+export const UPDATE = Symbol('entity-file-update');
+export const MARK_FAILED = Symbol('entity-file-mark-failed');
+/**
+ * Provides a consistent interface for files used in an app via
+ * Entity access.
+ */
+export class EntityFile extends EventSubscriber {
+    constructor(id, { downloadRemote = false, } = {}) {
+        super();
+        this.id = id;
+        // cached object URL for a local blob file, if applicable
+        this._objectUrl = null;
+        this._fileData = null;
+        this._loading = true;
+        this._failed = false;
+        this._disposed = false;
+        this._downloadRemote = false;
+        this[_a] = (fileData) => {
+            this._loading = false;
+            this._failed = false;
+            this._disposed = false;
+            this._fileData = fileData;
+            if (fileData.file) {
+                if (this._objectUrl) {
+                    URL.revokeObjectURL(this._objectUrl);
+                }
+                this._objectUrl = URL.createObjectURL(fileData.file);
+            }
+            this.emit('change');
+        };
+        this[_b] = () => {
+            this._failed = true;
+            this._loading = false;
+            this.emit('change');
+        };
+        this.dispose = () => {
+            if (this._objectUrl) {
+                URL.revokeObjectURL(this._objectUrl);
+            }
+            this._disposed = true;
+        };
+        this._downloadRemote = downloadRemote;
+    }
+    get downloadRemote() {
+        return this._downloadRemote;
+    }
+    get url() {
+        var _c, _d;
+        if (this.loading)
+            return null;
+        if (this._objectUrl)
+            return this._objectUrl;
+        return (_d = (_c = this._fileData) === null || _c === void 0 ? void 0 : _c.url) !== null && _d !== void 0 ? _d : null;
+    }
+    get name() {
+        var _c, _d;
+        return (_d = (_c = this._fileData) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : null;
+    }
+    get type() {
+        var _c, _d;
+        return (_d = (_c = this._fileData) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : null;
+    }
+    get loading() {
+        return this._loading;
+    }
+    get failed() {
+        return this._failed;
+    }
+}
+_a = UPDATE, _b = MARK_FAILED;
 //# sourceMappingURL=EntityFile.js.map

package/dist/esm/files/FileManager.d.ts

@@ -1,42 +1,42 @@
-import { FileData } from '@verdant-web/common';
-import { Context } from '../context.js';
-import { Metadata } from '../metadata/Metadata.js';
-import { Sync } from '../sync/Sync.js';
-import { EntityFile } from './EntityFile.js';
-import { ReturnedFileData } from './FileStorage.js';
-export interface FileManagerConfig {
-    /**
-     * Override the heuristic for deciding when a deleted file can be cleaned up.
-     * By default this waits 3 days since deletion, then deletes the file data.
-     * If the file has been synchronized to a server, it could still be restored
-     * if the server has not yet deleted it.
-     */
-    canCleanupDeletedFile?: (file: ReturnedFileData) => boolean;
-}
-export declare class FileManager {
-    private storage;
-    private sync;
-    private context;
-    private files;
-    private config;
-    private meta;
-    constructor({ db, sync, context, meta, config, }: {
-        db: IDBDatabase;
-        sync: Sync;
-        context: Context;
-        config?: FileManagerConfig;
-        meta: Metadata;
-    });
-    add: (fileInput: Omit<FileData, 'remote'>) => Promise<void>;
-    private uploadFile;
-    /**
-     * Immediately returns an EntityFile to use, then either loads
-     * the file from cache, local database, or the server.
-     */
-    get: (id: string) => EntityFile;
-    private load;
-    listUnsynced: () => Promise<ReturnedFileData[]>;
-    private onOnlineChange;
-    private tryCleanupDeletedFiles;
-    private handleFileRefsDeleted;
-}
+import { FileData } from '@verdant-web/common';
+import { Context } from '../context.js';
+import { Metadata } from '../metadata/Metadata.js';
+import { Sync } from '../sync/Sync.js';
+import { EntityFile } from './EntityFile.js';
+import { ReturnedFileData } from './FileStorage.js';
+export interface FileManagerConfig {
+    /**
+     * Override the heuristic for deciding when a deleted file can be cleaned up.
+     * By default this waits 3 days since deletion, then deletes the file data.
+     * If the file has been synchronized to a server, it could still be restored
+     * if the server has not yet deleted it.
+     */
+    canCleanupDeletedFile?: (file: ReturnedFileData) => boolean;
+}
+export declare class FileManager {
+    private storage;
+    private sync;
+    private context;
+    private files;
+    private config;
+    private meta;
+    constructor({ db, sync, context, meta, config, }: {
+        db: IDBDatabase;
+        sync: Sync;
+        context: Context;
+        config?: FileManagerConfig;
+        meta: Metadata;
+    });
+    add: (fileInput: Omit<FileData, 'remote'>) => Promise<void>;
+    private uploadFile;
+    /**
+     * Immediately returns an EntityFile to use, then either loads
+     * the file from cache, local database, or the server.
+     */
+    get: (id: string) => EntityFile;
+    private load;
+    listUnsynced: () => Promise<ReturnedFileData[]>;
+    private onOnlineChange;
+    private tryCleanupDeletedFiles;
+    private handleFileRefsDeleted;
+}

package/dist/esm/files/FileManager.js

@@ -1,149 +1,149 @@
-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, {
-                            downloadRemote: file.downloadRemote,
-                        });
-                    }
-                    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) => {
-                try {
-                    await this.storage.markPendingDelete(fileRef.id, { transaction: tx });
-                }
-                catch (err) {
-                    this.context.log('error', 'Failed to mark file for deletion', err);
-                }
-            }));
-            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, {
+                            downloadRemote: file.downloadRemote,
+                        });
+                    }
+                    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) => {
+                try {
+                    await this.storage.markPendingDelete(fileRef.id, { transaction: tx });
+                }
+                catch (err) {
+                    this.context.log('error', 'Failed to mark file for deletion', err);
+                }
+            }));
+            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,28 +1,28 @@
-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, downloadRemote, }?: {
-        transaction?: IDBTransaction | undefined;
-        downloadRemote?: boolean | 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, downloadRemote, }?: {
+        transaction?: IDBTransaction | undefined;
+        downloadRemote?: boolean | 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;