sliftutils 0.10.0 → 0.12.0

package/storage/dist/FileFolderAPI.tsx.cache

@@ -0,0 +1,345 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.resetStorageLocation = exports.getFileStorage = exports.getFileStorageNested = exports.getDirectoryHandle = void 0;
+const preact_1 = __importDefault(require("preact"));
+const fileSystemPointer_1 = require("./fileSystemPointer");
+const mobxTyped_1 = require("../misc/mobxTyped");
+const observer_1 = require("../misc/observer");
+const caching_1 = require("socket-function/src/caching");
+const typesafecss_1 = require("typesafecss");
+const batching_1 = require("socket-function/src/batching");
+const IndexedDBFileFolderAPI_1 = require("./IndexedDBFileFolderAPI");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// NOTE: IndexedDB is required for iOS, at least. We MIGHT want to make
+//  this a user supported toggle too, so they can choose during runtime if they want it.
+// DO NOT enable this is isNode
+const USE_INDEXED_DB = false;
+let displayData = (0, mobxTyped_1.observable)({
+    ui: undefined,
+}, undefined, { deep: false });
+const storageKey = "syncFileSystemCamera3";
+let DirectoryPrompter = class DirectoryPrompter extends preact_1.default.Component {
+    render() {
+        if (!displayData.ui)
+            return undefined;
+        return (preact_1.default.createElement("div", { className: typesafecss_1.css.position("fixed").pos(0, 0).size("100vw", "100vh")
+                .zIndex(1)
+                .background("white")
+                .center
+                .fontSize(40) }, displayData.ui));
+    }
+};
+DirectoryPrompter = __decorate([
+    observer_1.observer
+], DirectoryPrompter);
+class NodeJSFileHandleWrapper {
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    async getFile() {
+        const stats = await fs_1.default.promises.stat(this.filePath);
+        return {
+            size: stats.size,
+            lastModified: stats.mtimeMs,
+            arrayBuffer: async () => {
+                const buffer = await fs_1.default.promises.readFile(this.filePath);
+                return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+            }
+        };
+    }
+    async createWritable(config) {
+        let fileHandle;
+        const flags = (config === null || config === void 0 ? void 0 : config.keepExistingData) ? "r+" : "w";
+        // Ensure the directory exists
+        await fs_1.default.promises.mkdir(path_1.default.dirname(this.filePath), { recursive: true });
+        // Open or create the file
+        if ((config === null || config === void 0 ? void 0 : config.keepExistingData) && await fs_1.default.promises.access(this.filePath).then(() => true).catch(() => false)) {
+            fileHandle = await fs_1.default.promises.open(this.filePath, flags);
+        }
+        else {
+            fileHandle = await fs_1.default.promises.open(this.filePath, "w");
+        }
+        let position = 0;
+        return {
+            seek: async (offset) => {
+                position = offset;
+            },
+            write: async (value) => {
+                await fileHandle.write(value, 0, value.length, position);
+                position += value.length;
+            },
+            close: async () => {
+                await fileHandle.close();
+            }
+        };
+    }
+}
+class NodeJSDirectoryHandleWrapper {
+    constructor(rootPath) {
+        this.rootPath = rootPath;
+    }
+    async removeEntry(key, options) {
+        const entryPath = path_1.default.join(this.rootPath, key);
+        if (options === null || options === void 0 ? void 0 : options.recursive) {
+            await fs_1.default.promises.rm(entryPath, { recursive: true, force: true });
+        }
+        else {
+            await fs_1.default.promises.unlink(entryPath);
+        }
+    }
+    async getFileHandle(key, options) {
+        const filePath = path_1.default.join(this.rootPath, key);
+        const exists = await fs_1.default.promises.access(filePath).then(() => true).catch(() => false);
+        if (!exists && (options === null || options === void 0 ? void 0 : options.create)) {
+            // Ensure the directory exists
+            await fs_1.default.promises.mkdir(path_1.default.dirname(filePath), { recursive: true });
+            // Create the file
+            await fs_1.default.promises.writeFile(filePath, Buffer.alloc(0));
+        }
+        else if (!exists) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        return new NodeJSFileHandleWrapper(filePath);
+    }
+    async getDirectoryHandle(key, options) {
+        const dirPath = path_1.default.join(this.rootPath, key);
+        if (options === null || options === void 0 ? void 0 : options.create) {
+            await fs_1.default.promises.mkdir(dirPath, { recursive: true });
+        }
+        else {
+            const exists = await fs_1.default.promises.access(dirPath).then(() => true).catch(() => false);
+            if (!exists) {
+                throw new Error(`Directory not found: ${dirPath}`);
+            }
+        }
+        return new NodeJSDirectoryHandleWrapper(dirPath);
+    }
+    async *[Symbol.asyncIterator]() {
+        // Ensure directory exists
+        await fs_1.default.promises.mkdir(this.rootPath, { recursive: true });
+        const entries = await fs_1.default.promises.readdir(this.rootPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile()) {
+                yield [entry.name, {
+                        kind: "file",
+                        name: entry.name,
+                        getFile: async () => new NodeJSFileHandleWrapper(path_1.default.join(this.rootPath, entry.name))
+                    }];
+            }
+            else if (entry.isDirectory()) {
+                const dirPath = path_1.default.join(this.rootPath, entry.name);
+                yield [entry.name, {
+                        kind: "directory",
+                        name: entry.name,
+                        getDirectoryHandle: async (key, options) => {
+                            return new NodeJSDirectoryHandleWrapper(dirPath).getDirectoryHandle(key, options);
+                        }
+                    }];
+            }
+        }
+    }
+}
+// NOTE: Blocks until the user provides a directory
+exports.getDirectoryHandle = (0, caching_1.lazy)(async function getDirectoryHandle() {
+    if ((0, typesafecss_1.isNode)()) {
+        return new NodeJSDirectoryHandleWrapper(path_1.default.resolve("./data/"));
+    }
+    let root = document.createElement("div");
+    document.body.appendChild(root);
+    preact_1.default.render(preact_1.default.createElement(DirectoryPrompter, null), root);
+    try {
+        let handle;
+        let storedId = localStorage.getItem(storageKey);
+        if (storedId) {
+            let doneLoad = false;
+            setTimeout(() => {
+                if (doneLoad)
+                    return;
+                console.log("Waiting for user to click");
+                displayData.ui = "Click anywhere to allow file system access";
+            }, 500);
+            try {
+                handle = await tryToLoadPointer(storedId);
+            }
+            catch (_a) { }
+            doneLoad = true;
+            if (handle) {
+                return handle;
+            }
+        }
+        let fileCallback;
+        let promise = new Promise(resolve => {
+            fileCallback = resolve;
+        });
+        displayData.ui = (preact_1.default.createElement("button", { className: typesafecss_1.css.fontSize(40).pad2(80, 40), onClick: async () => {
+                console.log("Waiting for user to give permission");
+                const handle = await window.showDirectoryPicker();
+                await handle.requestPermission({ mode: "readwrite" });
+                let storedId = await (0, fileSystemPointer_1.storeFileSystemPointer)({ mode: "readwrite", handle });
+                localStorage.setItem(storageKey, storedId);
+                fileCallback(handle);
+            } }, "Pick Media Directory"));
+        return await promise;
+    }
+    finally {
+        preact_1.default.render(null, root);
+        root.remove();
+    }
+});
+exports.getFileStorageNested = (0, caching_1.cache)(async function getFileStorage(path) {
+    let base = await (0, exports.getDirectoryHandle)();
+    for (let part of path.split("/")) {
+        if (!part)
+            continue;
+        base = await base.getDirectoryHandle(part, { create: true });
+    }
+    return wrapHandle(base);
+});
+exports.getFileStorage = (0, caching_1.lazy)(async function getFileStorage() {
+    if (USE_INDEXED_DB) {
+        return await (0, IndexedDBFileFolderAPI_1.getFileStorageIndexDB)();
+    }
+    let handle = await (0, exports.getDirectoryHandle)();
+    return wrapHandle(handle);
+});
+function resetStorageLocation() {
+    localStorage.removeItem(storageKey);
+    window.location.reload();
+}
+exports.resetStorageLocation = resetStorageLocation;
+let appendQueue = (0, caching_1.cache)((key) => {
+    return (0, batching_1.runInSerial)((fnc) => fnc());
+});
+async function fixedGetFileHandle(config) {
+    if (config.key.includes("/")) {
+        throw new Error(`Cannot use folders directly in file system read / writes. Use a wrapper which handles the folder navigation. Path was ${JSON.stringify(config.key)}`);
+    }
+    // ALWAYS try without create, because the sshfs-win sucks and doesn't support `create: true`? Wtf...
+    try {
+        return await config.handle.getFileHandle(config.key);
+    }
+    catch (_a) {
+        if (!config.create)
+            return undefined;
+    }
+    return await config.handle.getFileHandle(config.key, { create: true });
+}
+function wrapHandleFiles(handle) {
+    return {
+        async getInfo(key) {
+            try {
+                const file = await handle.getFileHandle(key);
+                const fileContent = await file.getFile();
+                return {
+                    size: fileContent.size,
+                    lastModified: fileContent.lastModified,
+                };
+            }
+            catch (error) {
+                return undefined;
+            }
+        },
+        async get(key) {
+            try {
+                const file = await handle.getFileHandle(key);
+                const fileContent = await file.getFile();
+                const arrayBuffer = await fileContent.arrayBuffer();
+                return Buffer.from(arrayBuffer);
+            }
+            catch (error) {
+                return undefined;
+            }
+        },
+        async append(key, value) {
+            await appendQueue(key)(async () => {
+                // NOTE: Interesting point. Chrome doesn't optimize this to be an append, and instead
+                //  rewrites the entire file.
+                const file = await fixedGetFileHandle({ handle, key, create: true });
+                const writable = await file.createWritable({ keepExistingData: true });
+                let offset = (await file.getFile()).size;
+                await writable.seek(offset);
+                await writable.write(value);
+                await writable.close();
+            });
+        },
+        async set(key, value) {
+            const file = await fixedGetFileHandle({ handle, key, create: true });
+            const writable = await file.createWritable();
+            await writable.write(value);
+            await writable.close();
+        },
+        async remove(key) {
+            await handle.removeEntry(key);
+        },
+        async getKeys() {
+            const keys = [];
+            for await (const [name, entry] of handle) {
+                if (entry.kind === "file") {
+                    keys.push(entry.name);
+                }
+            }
+            return keys;
+        },
+        async reset() {
+            for await (const [name, entry] of handle) {
+                await handle.removeEntry(entry.name, { recursive: true });
+            }
+        },
+    };
+}
+function wrapHandleNested(handle) {
+    return {
+        async hasKey(key) {
+            try {
+                await handle.getDirectoryHandle(key);
+                return true;
+            }
+            catch (error) {
+                return false;
+            }
+        },
+        async getStorage(key) {
+            const subDirectory = await handle.getDirectoryHandle(key, { create: true });
+            return wrapHandle(subDirectory);
+        },
+        async removeStorage(key) {
+            await handle.removeEntry(key, { recursive: true });
+        },
+        async getKeys() {
+            const keys = [];
+            for await (const [name, entry] of handle) {
+                if (entry.kind === "directory") {
+                    keys.push(entry.name);
+                }
+            }
+            return keys;
+        },
+    };
+}
+function wrapHandle(handle) {
+    return {
+        ...wrapHandleFiles(handle),
+        folder: wrapHandleNested(handle),
+    };
+}
+async function tryToLoadPointer(pointer) {
+    let result = await (0, fileSystemPointer_1.getFileSystemPointer)({ pointer });
+    if (!result)
+        return;
+    let handle = await (result === null || result === void 0 ? void 0 : result.onUserActivation());
+    if (!handle)
+        return;
+    return handle;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FileFolderAPI.js","sourceRoot":"","sources":["FileFolderAPI.tsx"],"names":[],"mappings":"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","sourcesContent":["import preact from \"preact\";\nimport { getFileSystemPointer, storeFileSystemPointer } from \"./fileSystemPointer\";\nimport { observable } from \"../misc/mobxTyped\";\nimport { observer } from \"../misc/observer\";\nimport { cache, lazy } from \"socket-function/src/caching\";\nimport { css, isNode } from \"typesafecss\";\nimport { IStorageRaw } from \"./IStorage\";\nimport { runInSerial } from \"socket-function/src/batching\";\nimport { getFileStorageIndexDB } from \"./IndexedDBFileFolderAPI\";\nimport fs from \"fs\";\nimport path from \"path\";\n\n// NOTE: IndexedDB is required for iOS, at least. We MIGHT want to make\n//  this a user supported toggle too, so they can choose during runtime if they want it.\n// DO NOT enable this is isNode\nconst USE_INDEXED_DB = false;\n\ntype FileWrapper = {\n    getFile(): Promise<{\n        size: number;\n        lastModified: number;\n        arrayBuffer(): Promise<ArrayBuffer>;\n    }>;\n    createWritable(config?: { keepExistingData?: boolean }): Promise<{\n        seek(offset: number): Promise<void>;\n        write(value: Buffer): Promise<void>;\n        close(): Promise<void>;\n    }>;\n};\ntype DirectoryWrapper = {\n    removeEntry(key: string, options?: { recursive?: boolean }): Promise<void>;\n    getFileHandle(key: string, options?: { create?: boolean }): Promise<FileWrapper>;\n    getDirectoryHandle(key: string, options?: { create?: boolean }): Promise<DirectoryWrapper>;\n    [Symbol.asyncIterator](): AsyncIterableIterator<[string, {\n        kind: \"file\";\n        name: string;\n        getFile(): Promise<FileWrapper>;\n    } | {\n        kind: \"directory\";\n        name: string;\n        getDirectoryHandle(key: string, options?: { create?: boolean }): Promise<DirectoryWrapper>;\n    }]>;\n};\n\nlet displayData = observable({\n    ui: undefined as undefined | preact.ComponentChildren,\n}, undefined, { deep: false });\n\nconst storageKey = \"syncFileSystemCamera3\";\n\n@observer\nclass DirectoryPrompter extends preact.Component {\n    render() {\n        if (!displayData.ui) return undefined;\n        return (\n            <div className={\n                css.position(\"fixed\").pos(0, 0).size(\"100vw\", \"100vh\")\n                    .zIndex(1)\n                    .background(\"white\")\n                    .center\n                    .fontSize(40)\n            }>\n                {displayData.ui}\n            </div>\n        );\n    }\n}\n\nclass NodeJSFileHandleWrapper implements FileWrapper {\n    constructor(private filePath: string) {\n    }\n\n    async getFile() {\n        const stats = await fs.promises.stat(this.filePath);\n        return {\n            size: stats.size,\n            lastModified: stats.mtimeMs,\n            arrayBuffer: async () => {\n                const buffer = await fs.promises.readFile(this.filePath);\n                return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);\n            }\n        };\n    }\n\n    async createWritable(config?: { keepExistingData?: boolean }) {\n        let fileHandle: fs.promises.FileHandle;\n        const flags = config?.keepExistingData ? \"r+\" : \"w\";\n\n        // Ensure the directory exists\n        await fs.promises.mkdir(path.dirname(this.filePath), { recursive: true });\n\n        // Open or create the file\n        if (config?.keepExistingData && await fs.promises.access(this.filePath).then(() => true).catch(() => false)) {\n            fileHandle = await fs.promises.open(this.filePath, flags);\n        } else {\n            fileHandle = await fs.promises.open(this.filePath, \"w\");\n        }\n\n        let position = 0;\n\n        return {\n            seek: async (offset: number) => {\n                position = offset;\n            },\n            write: async (value: Buffer) => {\n                await fileHandle.write(value, 0, value.length, position);\n                position += value.length;\n            },\n            close: async () => {\n                await fileHandle.close();\n            }\n        };\n    }\n}\n\nclass NodeJSDirectoryHandleWrapper implements DirectoryWrapper {\n    constructor(private rootPath: string) {\n    }\n\n    async removeEntry(key: string, options?: { recursive?: boolean }) {\n        const entryPath = path.join(this.rootPath, key);\n        if (options?.recursive) {\n            await fs.promises.rm(entryPath, { recursive: true, force: true });\n        } else {\n            await fs.promises.unlink(entryPath);\n        }\n    }\n\n    async getFileHandle(key: string, options?: { create?: boolean }): Promise<FileWrapper> {\n        const filePath = path.join(this.rootPath, key);\n\n        const exists = await fs.promises.access(filePath).then(() => true).catch(() => false);\n\n        if (!exists && options?.create) {\n            // Ensure the directory exists\n            await fs.promises.mkdir(path.dirname(filePath), { recursive: true });\n            // Create the file\n            await fs.promises.writeFile(filePath, Buffer.alloc(0));\n        } else if (!exists) {\n            throw new Error(`File not found: ${filePath}`);\n        }\n\n        return new NodeJSFileHandleWrapper(filePath);\n    }\n\n    async getDirectoryHandle(key: string, options?: { create?: boolean }): Promise<DirectoryWrapper> {\n        const dirPath = path.join(this.rootPath, key);\n\n        if (options?.create) {\n            await fs.promises.mkdir(dirPath, { recursive: true });\n        } else {\n            const exists = await fs.promises.access(dirPath).then(() => true).catch(() => false);\n            if (!exists) {\n                throw new Error(`Directory not found: ${dirPath}`);\n            }\n        }\n\n        return new NodeJSDirectoryHandleWrapper(dirPath);\n    }\n\n    async *[Symbol.asyncIterator](): AsyncIterableIterator<[string, {\n        kind: \"file\";\n        name: string;\n        getFile(): Promise<FileWrapper>;\n    } | {\n        kind: \"directory\";\n        name: string;\n        getDirectoryHandle(key: string, options?: { create?: boolean }): Promise<DirectoryWrapper>;\n    }]> {\n        // Ensure directory exists\n        await fs.promises.mkdir(this.rootPath, { recursive: true });\n\n        const entries = await fs.promises.readdir(this.rootPath, { withFileTypes: true });\n\n        for (const entry of entries) {\n            if (entry.isFile()) {\n                yield [entry.name, {\n                    kind: \"file\",\n                    name: entry.name,\n                    getFile: async () => new NodeJSFileHandleWrapper(path.join(this.rootPath, entry.name))\n                }];\n            } else if (entry.isDirectory()) {\n                const dirPath = path.join(this.rootPath, entry.name);\n                yield [entry.name, {\n                    kind: \"directory\",\n                    name: entry.name,\n                    getDirectoryHandle: async (key: string, options?: { create?: boolean }) => {\n                        return new NodeJSDirectoryHandleWrapper(dirPath).getDirectoryHandle(key, options);\n                    }\n                }];\n            }\n        }\n    }\n}\n\n\n// NOTE: Blocks until the user provides a directory\nexport const getDirectoryHandle = lazy(async function getDirectoryHandle(): Promise<DirectoryWrapper> {\n    if (isNode()) {\n        return new NodeJSDirectoryHandleWrapper(path.resolve(\"./data/\"));\n    }\n    let root = document.createElement(\"div\");\n    document.body.appendChild(root);\n    preact.render(<DirectoryPrompter />, root);\n    try {\n\n        let handle: DirectoryWrapper | undefined;\n\n        let storedId = localStorage.getItem(storageKey);\n        if (storedId) {\n            let doneLoad = false;\n            setTimeout(() => {\n                if (doneLoad) return;\n                console.log(\"Waiting for user to click\");\n                displayData.ui = \"Click anywhere to allow file system access\";\n            }, 500);\n            try {\n                handle = await tryToLoadPointer(storedId);\n            } catch { }\n            doneLoad = true;\n            if (handle) {\n                return handle;\n            }\n        }\n        let fileCallback: (handle: DirectoryWrapper) => void;\n        let promise = new Promise<DirectoryWrapper>(resolve => {\n            fileCallback = resolve;\n        });\n        displayData.ui = (\n            <button\n                className={css.fontSize(40).pad2(80, 40)}\n                onClick={async () => {\n                    console.log(\"Waiting for user to give permission\");\n                    const handle = await window.showDirectoryPicker();\n                    await handle.requestPermission({ mode: \"readwrite\" });\n                    let storedId = await storeFileSystemPointer({ mode: \"readwrite\", handle });\n                    localStorage.setItem(storageKey, storedId);\n                    fileCallback(handle as any);\n                }}\n            >\n                Pick Media Directory\n            </button>\n        );\n        return await promise;\n    } finally {\n        preact.render(null, root);\n        root.remove();\n    }\n});\n\nexport const getFileStorageNested = cache(async function getFileStorage(path: string): Promise<FileStorage> {\n    let base = await getDirectoryHandle();\n    for (let part of path.split(\"/\")) {\n        if (!part) continue;\n        base = await base.getDirectoryHandle(part, { create: true });\n    }\n    return wrapHandle(base);\n});\nexport const getFileStorage = lazy(async function getFileStorage(): Promise<FileStorage> {\n    if (USE_INDEXED_DB) {\n        return await getFileStorageIndexDB();\n    }\n\n    let handle = await getDirectoryHandle();\n    return wrapHandle(handle);\n});\nexport function resetStorageLocation() {\n    localStorage.removeItem(storageKey);\n    window.location.reload();\n}\n\nexport type NestedFileStorage = {\n    hasKey(key: string): Promise<boolean>;\n    getStorage(key: string): Promise<FileStorage>;\n    removeStorage(key: string): Promise<void>;\n    getKeys(): Promise<string[]>;\n};\n\nexport type FileStorage = IStorageRaw & {\n    folder: NestedFileStorage;\n};\n\nlet appendQueue = cache((key: string) => {\n    return runInSerial((fnc: () => Promise<void>) => fnc());\n});\n\n\nasync function fixedGetFileHandle(config: {\n    handle: DirectoryWrapper;\n    key: string;\n    create: true;\n}): Promise<FileWrapper>;\nasync function fixedGetFileHandle(config: {\n    handle: DirectoryWrapper;\n    key: string;\n    create?: boolean;\n}): Promise<FileWrapper | undefined>;\nasync function fixedGetFileHandle(config: {\n    handle: DirectoryWrapper;\n    key: string;\n    create?: boolean;\n}): Promise<FileWrapper | undefined> {\n    if (config.key.includes(\"/\")) {\n        throw new Error(`Cannot use folders directly in file system read / writes. Use a wrapper which handles the folder navigation. Path was ${JSON.stringify(config.key)}`);\n    }\n    // ALWAYS try without create, because the sshfs-win sucks and doesn't support `create: true`? Wtf...\n    try {\n        return await config.handle.getFileHandle(config.key);\n    } catch {\n        if (!config.create) return undefined;\n    }\n    return await config.handle.getFileHandle(config.key, { create: true });\n}\n\nfunction wrapHandleFiles(handle: DirectoryWrapper): IStorageRaw {\n    return {\n        async getInfo(key: string) {\n            try {\n                const file = await handle.getFileHandle(key);\n                const fileContent = await file.getFile();\n                return {\n                    size: fileContent.size,\n                    lastModified: fileContent.lastModified,\n                };\n            } catch (error) {\n                return undefined;\n            }\n        },\n        async get(key: string): Promise<Buffer | undefined> {\n            try {\n                const file = await handle.getFileHandle(key);\n                const fileContent = await file.getFile();\n                const arrayBuffer = await fileContent.arrayBuffer();\n                return Buffer.from(arrayBuffer);\n            } catch (error) {\n                return undefined;\n            }\n        },\n\n        async append(key: string, value: Buffer): Promise<void> {\n            await appendQueue(key)(async () => {\n                // NOTE: Interesting point. Chrome doesn't optimize this to be an append, and instead\n                //  rewrites the entire file.\n                const file = await fixedGetFileHandle({ handle, key, create: true });\n                const writable = await file.createWritable({ keepExistingData: true });\n                let offset = (await file.getFile()).size;\n                await writable.seek(offset);\n                await writable.write(value);\n                await writable.close();\n            });\n        },\n\n        async set(key: string, value: Buffer): Promise<void> {\n            const file = await fixedGetFileHandle({ handle, key, create: true });\n            const writable = await file.createWritable();\n            await writable.write(value);\n            await writable.close();\n        },\n\n        async remove(key: string): Promise<void> {\n            await handle.removeEntry(key);\n        },\n\n        async getKeys(): Promise<string[]> {\n            const keys: string[] = [];\n            for await (const [name, entry] of handle) {\n                if (entry.kind === \"file\") {\n                    keys.push(entry.name);\n                }\n            }\n            return keys;\n        },\n\n        async reset() {\n            for await (const [name, entry] of handle) {\n                await handle.removeEntry(entry.name, { recursive: true });\n            }\n        },\n    };\n}\n\nfunction wrapHandleNested(handle: DirectoryWrapper): NestedFileStorage {\n    return {\n        async hasKey(key: string): Promise<boolean> {\n            try {\n                await handle.getDirectoryHandle(key);\n                return true;\n            } catch (error) {\n                return false;\n            }\n        },\n\n        async getStorage(key: string): Promise<FileStorage> {\n            const subDirectory = await handle.getDirectoryHandle(key, { create: true });\n            return wrapHandle(subDirectory);\n        },\n\n        async removeStorage(key: string): Promise<void> {\n            await handle.removeEntry(key, { recursive: true });\n        },\n\n        async getKeys(): Promise<string[]> {\n            const keys: string[] = [];\n            for await (const [name, entry] of handle) {\n                if (entry.kind === \"directory\") {\n                    keys.push(entry.name);\n                }\n            }\n            return keys;\n        },\n    };\n}\n\nfunction wrapHandle(handle: DirectoryWrapper): FileStorage {\n    return {\n        ...wrapHandleFiles(handle),\n        folder: wrapHandleNested(handle),\n    };\n}\n\nasync function tryToLoadPointer(pointer: string) {\n    let result = await getFileSystemPointer({ pointer });\n    if (!result) return;\n    let handle = await result?.onUserActivation();\n    if (!handle) return;\n    return handle as any as DirectoryWrapper;\n}"]}
+ /* _JS_SOURCE_HASH = "2c171fd06df7fe1cfb75e04ee9f78c65385c23788b53f9fe0775b27670622e69"; */

package/storage/dist/IndexedDBFileFolderAPI.ts.cache

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.getFileStorageIndexDB = void 0;
+const caching_1 = require("socket-function/src/caching");
+const DB_NAME = "FileStorage";
+const STORE_NAME = "files";
+const DB_VERSION = 1;
+class VirtualFileStorage {
+    constructor(db, id) {
+        this.id = id;
+        // NestedFileStorage implementation
+        this.folder = {
+            hasKey: async (key) => {
+                const folderPath = this.id + key + "/";
+                const keys = await this.getKeysWithPrefix(folderPath);
+                return keys.length > 0;
+            },
+            getStorage: async (key) => {
+                const newPath = this.id + key + "/";
+                return new VirtualFileStorage(this.db, newPath);
+            },
+            removeStorage: async (key) => {
+                let nested = new VirtualFileStorage(this.db, this.id + key + "/");
+                await nested.reset();
+            },
+            getKeys: async () => {
+                let keys = await this.getKeysWithPrefix(this.id);
+                let folderKeys = new Set();
+                for (let key of keys) {
+                    if (!key.includes("/"))
+                        continue;
+                    let parts = key.split("/");
+                    folderKeys.add(parts[0]);
+                }
+                return Array.from(folderKeys);
+            }
+        };
+        if (!db)
+            debugger;
+        this.db = db;
+    }
+    getStore(mode = "readonly") {
+        const transaction = this.db.transaction(STORE_NAME, mode);
+        return transaction.objectStore(STORE_NAME);
+    }
+    request(request) {
+        return new Promise((resolve, reject) => {
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = () => reject(request.error);
+        });
+    }
+    // IStorageRaw implementation
+    async get(key) {
+        const store = this.getStore();
+        const result = await this.request(store.get(this.id + key));
+        let badBuffer = result === null || result === void 0 ? void 0 : result.data;
+        if (badBuffer)
+            badBuffer = Buffer.from(badBuffer);
+        return badBuffer;
+    }
+    async append(key, value) {
+        const store = this.getStore("readwrite");
+        const fullPath = this.id + key;
+        const existing = await this.request(store.get(fullPath));
+        const newRecord = {
+            data: existing
+                ? Buffer.concat([existing.data, value])
+                : value,
+            lastModified: Date.now()
+        };
+        await this.request(store.put(newRecord, fullPath));
+    }
+    async set(key, value) {
+        const store = this.getStore("readwrite");
+        const record = {
+            data: value,
+            lastModified: Date.now()
+        };
+        await this.request(store.put(record, this.id + key));
+    }
+    async remove(key) {
+        const store = this.getStore("readwrite");
+        await this.request(store.delete(this.id + key));
+    }
+    async getKeysWithPrefix(prefix) {
+        const store = this.getStore();
+        const range = IDBKeyRange.bound(prefix, prefix + "\uffff", false, true);
+        return new Promise((resolve, reject) => {
+            const keys = [];
+            const request = store.openCursor(range);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => {
+                const cursor = request.result;
+                if (cursor) {
+                    let newKey = cursor.key;
+                    newKey = newKey.slice(this.id.length);
+                    keys.push(newKey);
+                    cursor.continue();
+                }
+                else {
+                    resolve(keys);
+                }
+            };
+        });
+    }
+    async getKeys() {
+        let keys = await this.getKeysWithPrefix(this.id);
+        return keys.filter(x => !x.includes("/"));
+    }
+    async getInfo(key) {
+        const store = this.getStore();
+        const result = await this.request(store.get(this.id + key));
+        if (!result)
+            return undefined;
+        return {
+            size: result.data.length,
+            lastModified: result.lastModified
+        };
+    }
+    async reset() {
+        let keys = await this.getKeysWithPrefix(this.id);
+        for (let key of keys) {
+            await this.remove(key);
+        }
+    }
+}
+exports.getFileStorageIndexDB = (0, caching_1.lazy)(async () => {
+    const db = await new Promise((resolve, reject) => {
+        const request = indexedDB.open(DB_NAME, DB_VERSION);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve(request.result);
+        request.onupgradeneeded = (event) => {
+            const db = event.target.result;
+            if (!db.objectStoreNames.contains(STORE_NAME)) {
+                db.createObjectStore(STORE_NAME);
+            }
+        };
+    });
+    return new VirtualFileStorage(db, "/");
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"IndexedDBFileFolderAPI.js","sourceRoot":"","sources":["IndexedDBFileFolderAPI.ts"],"names":[],"mappings":"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","sourcesContent":["import { lazy } from \"socket-function/src/caching\";\nimport { IStorageRaw } from \"./IStorage\";\nimport { FileStorage } from \"./FileFolderAPI\";\n\nconst DB_NAME = \"FileStorage\";\nconst STORE_NAME = \"files\";\nconst DB_VERSION = 1;\n\ninterface FileRecord {\n    data: Buffer;\n    lastModified: number;\n}\n\nclass VirtualFileStorage implements FileStorage {\n    private db: IDBDatabase;\n\n    constructor(\n        db: IDBDatabase,\n        public readonly id: string\n    ) {\n        if (!db) debugger;\n        this.db = db;\n    }\n\n    private getStore(mode: IDBTransactionMode = \"readonly\") {\n        const transaction = this.db.transaction(STORE_NAME, mode);\n        return transaction.objectStore(STORE_NAME);\n    }\n\n    private request<T>(request: IDBRequest<T>): Promise<T> {\n        return new Promise((resolve, reject) => {\n            request.onsuccess = () => resolve(request.result);\n            request.onerror = () => reject(request.error);\n        });\n    }\n\n\n    // IStorageRaw implementation\n    async get(key: string): Promise<Buffer | undefined> {\n        const store = this.getStore();\n        const result = await this.request<FileRecord | undefined>(store.get(this.id + key));\n        let badBuffer = result?.data;\n        if (badBuffer) badBuffer = Buffer.from(badBuffer);\n        return badBuffer;\n    }\n\n    async append(key: string, value: Buffer): Promise<void> {\n        const store = this.getStore(\"readwrite\");\n        const fullPath = this.id + key;\n        const existing = await this.request<FileRecord | undefined>(store.get(fullPath));\n\n        const newRecord: FileRecord = {\n            data: existing\n                ? Buffer.concat([existing.data, value])\n                : value,\n            lastModified: Date.now()\n        };\n\n        await this.request(store.put(newRecord, fullPath));\n    }\n\n    async set(key: string, value: Buffer): Promise<void> {\n        const store = this.getStore(\"readwrite\");\n        const record: FileRecord = {\n            data: value,\n            lastModified: Date.now()\n        };\n        await this.request(store.put(record, this.id + key));\n    }\n\n    async remove(key: string): Promise<void> {\n        const store = this.getStore(\"readwrite\");\n        await this.request(store.delete(this.id + key));\n    }\n\n    private async getKeysWithPrefix(prefix: string): Promise<string[]> {\n        const store = this.getStore();\n        const range = IDBKeyRange.bound(prefix, prefix + \"\\uffff\", false, true);\n\n        return new Promise((resolve, reject) => {\n            const keys: string[] = [];\n            const request = store.openCursor(range);\n\n            request.onerror = () => reject(request.error);\n            request.onsuccess = () => {\n                const cursor = request.result;\n                if (cursor) {\n                    let newKey = cursor.key as string;\n                    newKey = newKey.slice(this.id.length);\n                    keys.push(newKey);\n                    cursor.continue();\n                } else {\n                    resolve(keys);\n                }\n            };\n        });\n    }\n\n    async getKeys(): Promise<string[]> {\n        let keys = await this.getKeysWithPrefix(this.id);\n        return keys.filter(x => !x.includes(\"/\"));\n    }\n\n    async getInfo(key: string): Promise<{ size: number; lastModified: number; } | undefined> {\n        const store = this.getStore();\n        const result = await this.request<FileRecord | undefined>(store.get(this.id + key));\n\n        if (!result) return undefined;\n\n        return {\n            size: result.data.length,\n            lastModified: result.lastModified\n        };\n    }\n\n    async reset(): Promise<void> {\n        let keys = await this.getKeysWithPrefix(this.id);\n        for (let key of keys) {\n            await this.remove(key);\n        }\n    }\n\n    // NestedFileStorage implementation\n    folder = {\n        hasKey: async (key: string): Promise<boolean> => {\n            const folderPath = this.id + key + \"/\";\n            const keys = await this.getKeysWithPrefix(folderPath);\n            return keys.length > 0;\n        },\n\n        getStorage: async (key: string): Promise<FileStorage> => {\n            const newPath = this.id + key + \"/\";\n            return new VirtualFileStorage(this.db, newPath);\n        },\n\n        removeStorage: async (key: string): Promise<void> => {\n            let nested = new VirtualFileStorage(this.db, this.id + key + \"/\");\n            await nested.reset();\n        },\n\n        getKeys: async (): Promise<string[]> => {\n            let keys = await this.getKeysWithPrefix(this.id);\n            let folderKeys = new Set<string>();\n            for (let key of keys) {\n                if (!key.includes(\"/\")) continue;\n                let parts = key.split(\"/\");\n                folderKeys.add(parts[0]);\n            }\n            return Array.from(folderKeys);\n        }\n    };\n}\n\nexport const getFileStorageIndexDB = lazy(async (): Promise<FileStorage> => {\n    const db = await new Promise<IDBDatabase>((resolve, reject) => {\n        const request = indexedDB.open(DB_NAME, DB_VERSION);\n\n        request.onerror = () => reject(request.error);\n        request.onsuccess = () => resolve(request.result);\n\n        request.onupgradeneeded = (event) => {\n            const db = (event.target as IDBOpenDBRequest).result;\n            if (!db.objectStoreNames.contains(STORE_NAME)) {\n                db.createObjectStore(STORE_NAME);\n            }\n        };\n    });\n\n    return new VirtualFileStorage(db, \"/\");\n});"]}
+ /* _JS_SOURCE_HASH = "fcaf403302186bb428bbd7c05d2bb7882b4e5b2efc380c304cecc1090621cb0e"; */

package/storage/dist/JSONStorage.ts.cache

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.JSONStorage = void 0;
+class JSONStorage {
+    constructor(storage) {
+        this.storage = storage;
+    }
+    async get(key) {
+        let buffer = await this.storage.get(key);
+        if (buffer === undefined) {
+            return undefined;
+        }
+        try {
+            return JSON.parse(buffer.toString());
+        }
+        catch (e) {
+            console.warn(`Failed to parse JSON for key: ${key}`, buffer.toString(), e);
+        }
+    }
+    async set(key, value) {
+        await this.storage.set(key, Buffer.from(JSON.stringify(value)));
+    }
+    async remove(key) {
+        await this.storage.remove(key);
+    }
+    async getKeys() {
+        return await this.storage.getKeys();
+    }
+    async getInfo(key) {
+        return await this.storage.getInfo(key);
+    }
+    async reset() {
+        await this.storage.reset();
+    }
+}
+exports.JSONStorage = JSONStorage;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "6e2e6e8b1179c3970ad66f8dee16186e8445262a0ae235abc02a62a332d0db8c"; */