@lapis-notes/api 0.1.0

package/dist/storage/keyval.d.ts

@@ -0,0 +1,94 @@
+export declare function promisifyRequest<T = undefined>(request: IDBRequest<T> | IDBTransaction): Promise<T>;
+export declare function createStore(dbName: string, storeName: string): UseStore;
+export type UseStore = <T>(txMode: IDBTransactionMode, callback: (store: IDBObjectStore, db: IDBDatabase) => T | PromiseLike<T>) => Promise<T>;
+export declare function close(customStore?: UseStore): Promise<void>;
+/**
+ * Get a value by its key.
+ *
+ * @param key
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export declare function get<T = any>(key: IDBValidKey, customStore?: UseStore): Promise<T | undefined>;
+/**
+ * Set a value with a key.
+ *
+ * @param key
+ * @param value
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export declare function set(key: IDBValidKey, value: any, customStore?: UseStore): Promise<void>;
+/**
+ * Set multiple values at once. This is faster than calling set() multiple
+ * times. It's also atomic – if one of the pairs can't be added, none will be
+ * added.
+ *
+ * @param entries Array of entries, where each entry is an array of `[key,
+ *   value]`.
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export declare function setMany(entries: [IDBValidKey, any][], customStore?: UseStore): Promise<void>;
+/**
+ * Get multiple values by their keys
+ *
+ * @param keys
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export declare function getMany<T = any>(keys: IDBValidKey[], customStore?: UseStore): Promise<T[]>;
+/**
+ * Update a value. This lets you see the old value and update it as an atomic
+ * operation.
+ *
+ * @param key
+ * @param updater A callback that takes the old value and returns a new value.
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export declare function update<T = any>(key: IDBValidKey, updater: (oldValue: T | undefined) => T, customStore?: UseStore): Promise<void>;
+/**
+ * Delete a particular key from the store.
+ *
+ * @param key
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export declare function del(key: IDBValidKey, customStore?: UseStore): Promise<void>;
+/**
+ * Delete multiple keys at once.
+ *
+ * @param keys List of keys to delete.
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export declare function delMany(keys: IDBValidKey[], customStore?: UseStore): Promise<void>;
+/**
+ * Clear all values in the store.
+ *
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export declare function clear(customStore?: UseStore): Promise<void>;
+/**
+ * Get all keys in the store.
+ *
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export declare function keys<KeyType extends IDBValidKey>(customStore?: UseStore): Promise<KeyType[]>;
+/**
+ * Get all values in the store.
+ *
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export declare function values<T = any>(customStore?: UseStore): Promise<T[]>;
+/**
+ * Get all entries in the store. Each entry is an array of `[key, value]`.
+ *
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export declare function entries<KeyType extends IDBValidKey, ValueType = any>(customStore?: UseStore): Promise<[KeyType, ValueType][]>;

package/dist/storage/keyval.js

@@ -0,0 +1,199 @@
+export function promisifyRequest(request) {
+    return new Promise((resolve, reject) => {
+        // @ts-ignore - file size hacks
+        request.oncomplete = request.onsuccess = () => resolve(request.result);
+        // @ts-ignore - file size hacks
+        request.onabort = request.onerror = () => reject(request.error);
+    });
+}
+export function createStore(dbName, storeName) {
+    const request = indexedDB.open(dbName);
+    request.onupgradeneeded = () => request.result.createObjectStore(storeName);
+    const dbp = promisifyRequest(request);
+    return (txMode, callback) => dbp.then((db) => callback(db.transaction(storeName, txMode).objectStore(storeName), db));
+}
+let defaultGetStoreFunc;
+function defaultGetStore() {
+    if (!defaultGetStoreFunc) {
+        defaultGetStoreFunc = createStore("keyval-store", "keyval");
+    }
+    return defaultGetStoreFunc;
+}
+export function close(customStore = defaultGetStore()) {
+    return customStore("readonly", (_, db) => Promise.resolve(db.close()));
+}
+/**
+ * Get a value by its key.
+ *
+ * @param key
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export function get(key, customStore = defaultGetStore()) {
+    return customStore("readonly", (store) => promisifyRequest(store.get(key)));
+}
+/**
+ * Set a value with a key.
+ *
+ * @param key
+ * @param value
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export function set(key, value, customStore = defaultGetStore()) {
+    return customStore("readwrite", (store) => {
+        store.put(value, key);
+        return promisifyRequest(store.transaction);
+    });
+}
+/**
+ * Set multiple values at once. This is faster than calling set() multiple
+ * times. It's also atomic – if one of the pairs can't be added, none will be
+ * added.
+ *
+ * @param entries Array of entries, where each entry is an array of `[key,
+ *   value]`.
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export function setMany(entries, customStore = defaultGetStore()) {
+    return customStore("readwrite", (store) => {
+        entries.forEach((entry) => store.put(entry[1], entry[0]));
+        return promisifyRequest(store.transaction);
+    });
+}
+/**
+ * Get multiple values by their keys
+ *
+ * @param keys
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export function getMany(keys, customStore = defaultGetStore()) {
+    return customStore("readonly", (store) => Promise.all(keys.map((key) => promisifyRequest(store.get(key)))));
+}
+/**
+ * Update a value. This lets you see the old value and update it as an atomic
+ * operation.
+ *
+ * @param key
+ * @param updater A callback that takes the old value and returns a new value.
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export function update(key, updater, customStore = defaultGetStore()) {
+    return customStore("readwrite", (store) => 
+    // Need to create the promise manually.
+    // If I try to chain promises, the transaction closes in browsers
+    // that use a promise polyfill (IE10/11).
+    new Promise((resolve, reject) => {
+        store.get(key).onsuccess = function () {
+            try {
+                store.put(updater(this.result), key);
+                resolve(promisifyRequest(store.transaction));
+            }
+            catch (err) {
+                reject(err);
+            }
+        };
+    }));
+}
+/**
+ * Delete a particular key from the store.
+ *
+ * @param key
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export function del(key, customStore = defaultGetStore()) {
+    return customStore("readwrite", (store) => {
+        store.delete(key);
+        return promisifyRequest(store.transaction);
+    });
+}
+/**
+ * Delete multiple keys at once.
+ *
+ * @param keys List of keys to delete.
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export function delMany(keys, customStore = defaultGetStore()) {
+    return customStore("readwrite", (store) => {
+        keys.forEach((key) => store.delete(key));
+        return promisifyRequest(store.transaction);
+    });
+}
+/**
+ * Clear all values in the store.
+ *
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export function clear(customStore = defaultGetStore()) {
+    return customStore("readwrite", (store) => {
+        store.clear();
+        return promisifyRequest(store.transaction);
+    });
+}
+function eachCursor(store, callback) {
+    store.openCursor().onsuccess = function () {
+        if (!this.result)
+            return;
+        callback(this.result);
+        this.result.continue();
+    };
+    return promisifyRequest(store.transaction);
+}
+/**
+ * Get all keys in the store.
+ *
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export function keys(customStore = defaultGetStore()) {
+    return customStore("readonly", (store) => {
+        // Fast path for modern browsers
+        if (store.getAllKeys) {
+            return promisifyRequest(store.getAllKeys());
+        }
+        const items = [];
+        return eachCursor(store, (cursor) => items.push(cursor.key)).then(() => items);
+    });
+}
+/**
+ * Get all values in the store.
+ *
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export function values(customStore = defaultGetStore()) {
+    return customStore("readonly", (store) => {
+        // Fast path for modern browsers
+        if (store.getAll) {
+            return promisifyRequest(store.getAll());
+        }
+        const items = [];
+        return eachCursor(store, (cursor) => items.push(cursor.value)).then(() => items);
+    });
+}
+/**
+ * Get all entries in the store. Each entry is an array of `[key, value]`.
+ *
+ * @param customStore Method to get a custom store. Use with caution (see the
+ *   docs).
+ */
+export function entries(customStore = defaultGetStore()) {
+    return customStore("readonly", (store) => {
+        // Fast path for modern browsers
+        // (although, hopefully we'll get a simpler path some day)
+        if (store.getAll && store.getAllKeys) {
+            return Promise.all([
+                promisifyRequest(store.getAllKeys()),
+                promisifyRequest(store.getAll()),
+            ]).then(([keys, values]) => keys.map((key, i) => [key, values[i]]));
+        }
+        const items = [];
+        return customStore("readonly", (store) => eachCursor(store, (cursor) => items.push([cursor.key, cursor.value])).then(() => items));
+    });
+}

package/dist/storage/memory-vault-adapter.d.ts

@@ -0,0 +1,44 @@
+import type { DataWriteOptions, ListedFiles, Stat, VaultAdapter, VaultAdapterCapabilities, VaultIdentityAdapter } from "./fs";
+export type MemoryVaultClock = number | (() => number);
+export interface MemoryVaultAdapterOptions {
+    name?: string;
+    vaultId?: string;
+    clock?: MemoryVaultClock;
+}
+/**
+ * Deterministic, non-persistent vault adapter for demos, tests, and embedded
+ * hosts that need the real vault contract without browser or native storage.
+ *
+ * @public
+ */
+export declare class MemoryVaultAdapter implements VaultAdapter, VaultIdentityAdapter {
+    #private;
+    /** Optional diagnostic hook used by demos and tests. */
+    onWrite?: (path: string, data: string, writeCount: number) => void;
+    constructor(seed?: Record<string, string | ArrayBuffer>, options?: MemoryVaultAdapterOptions);
+    get writeCount(): number;
+    getName(): string;
+    getVaultId(): string;
+    getCapabilities(): VaultAdapterCapabilities;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<Stat | null>;
+    read(path: string): Promise<string>;
+    readBinary(path: string): Promise<ArrayBuffer>;
+    write(path: string, data: string, options?: DataWriteOptions): Promise<void>;
+    writeBinary(path: string, data: ArrayBuffer, options?: DataWriteOptions): Promise<void>;
+    append(path: string, data: string, options?: DataWriteOptions): Promise<void>;
+    appendBinary(path: string, data: ArrayBuffer, options?: DataWriteOptions): Promise<void>;
+    process(path: string, fn: (data: string) => string, options?: DataWriteOptions): Promise<string>;
+    list(path: string): Promise<ListedFiles>;
+    mkdir(path: string, options?: Partial<{
+        recursive: boolean;
+        mode: string;
+    }>): Promise<void>;
+    rmdir(path: string, recursive: boolean): Promise<void>;
+    remove(path: string): Promise<void>;
+    rename(path: string, newPath: string): Promise<void>;
+    copy(path: string, newPath: string): Promise<void>;
+    getResourcePath(path: string): string;
+    trashSystem(): Promise<boolean>;
+    trashLocal(path: string): Promise<void>;
+}

package/dist/storage/memory-vault-adapter.js

@@ -0,0 +1,351 @@
+import { dirname, joinPath, normalizePath } from "./path";
+/**
+ * Deterministic, non-persistent vault adapter for demos, tests, and embedded
+ * hosts that need the real vault contract without browser or native storage.
+ *
+ * @public
+ */
+export class MemoryVaultAdapter {
+    #files = new Map();
+    #folders = new Map();
+    #name;
+    #vaultId;
+    #clock;
+    #writeCount = 0;
+    /** Optional diagnostic hook used by demos and tests. */
+    onWrite;
+    constructor(seed = {}, options = {}) {
+        this.#name = options.name ?? "memory-vault";
+        this.#vaultId = options.vaultId ?? "memory-vault";
+        if (typeof options.clock === "function") {
+            this.#clock = options.clock;
+        }
+        else {
+            let time = options.clock ?? 0;
+            this.#clock = () => {
+                time += 1;
+                return time;
+            };
+        }
+        const rootTime = this.#now();
+        this.#folders.set("/", {
+            type: "folder",
+            ctime: rootTime,
+            mtime: rootTime,
+            size: 0,
+        });
+        for (const [path, value] of Object.entries(seed)) {
+            const normalized = this.#path(path);
+            this.#assertFilePath(normalized);
+            this.#ensureParentFolders(normalized);
+            const createdAt = this.#now();
+            this.#files.set(normalized, {
+                data: cloneValue(value),
+                stat: {
+                    type: "file",
+                    ctime: createdAt,
+                    mtime: createdAt,
+                    size: byteLength(value),
+                },
+            });
+        }
+    }
+    get writeCount() {
+        return this.#writeCount;
+    }
+    getName() {
+        return this.#name;
+    }
+    getVaultId() {
+        return this.#vaultId;
+    }
+    getCapabilities() {
+        return {
+            persistent: false,
+            userVisibleFiles: false,
+            requiresPermission: false,
+            nativeWatch: false,
+            resourceUrls: false,
+            systemTrash: false,
+        };
+    }
+    async exists(path) {
+        const normalized = this.#path(path);
+        return this.#files.has(normalized) || this.#folders.has(normalized);
+    }
+    async stat(path) {
+        const normalized = this.#path(path);
+        const stat = this.#files.get(normalized)?.stat ?? this.#folders.get(normalized);
+        return stat ? { ...stat } : null;
+    }
+    async read(path) {
+        const normalized = this.#path(path);
+        const value = this.#files.get(normalized)?.data;
+        if (value === undefined)
+            throw fsError("ENOENT", normalized);
+        return typeof value === "string" ? value : new TextDecoder().decode(value);
+    }
+    async readBinary(path) {
+        const normalized = this.#path(path);
+        const value = this.#files.get(normalized)?.data;
+        if (value === undefined)
+            throw fsError("ENOENT", normalized);
+        return typeof value === "string"
+            ? toArrayBuffer(new TextEncoder().encode(value))
+            : value.slice(0);
+    }
+    async write(path, data, options) {
+        await this.#writeValue(path, data, options);
+    }
+    async writeBinary(path, data, options) {
+        await this.#writeValue(path, data, options);
+    }
+    async append(path, data, options) {
+        const current = await this.read(path).catch((error) => {
+            if (hasCode(error, "ENOENT"))
+                return "";
+            throw error;
+        });
+        await this.write(path, current + data, options);
+    }
+    async appendBinary(path, data, options) {
+        const current = new Uint8Array(await this.readBinary(path).catch((error) => {
+            if (hasCode(error, "ENOENT"))
+                return new ArrayBuffer(0);
+            throw error;
+        }));
+        const next = new Uint8Array(current.byteLength + data.byteLength);
+        next.set(current);
+        next.set(new Uint8Array(data), current.byteLength);
+        await this.writeBinary(path, toArrayBuffer(next), options);
+    }
+    async process(path, fn, options) {
+        const next = fn(await this.read(path));
+        await this.write(path, next, options);
+        return next;
+    }
+    async list(path) {
+        const normalized = this.#path(path);
+        if (!this.#folders.has(normalized))
+            throw fsError("ENOENT", normalized);
+        const prefix = normalized === "/" ? "" : `${normalized}/`;
+        const listed = { files: [], folders: [] };
+        for (const file of this.#files.keys()) {
+            if (!file.startsWith(prefix))
+                continue;
+            const child = file.slice(prefix.length);
+            if (child && !child.includes("/"))
+                listed.files.push(child);
+        }
+        for (const folder of this.#folders.keys()) {
+            if (folder === normalized || !folder.startsWith(prefix))
+                continue;
+            const child = folder.slice(prefix.length);
+            if (child && !child.includes("/"))
+                listed.folders.push(child);
+        }
+        listed.files.sort();
+        listed.folders.sort();
+        return listed;
+    }
+    async mkdir(path, options) {
+        const normalized = this.#path(path);
+        if (normalized === "/")
+            return;
+        if (this.#files.has(normalized))
+            throw fsError("EEXIST", normalized);
+        const parent = this.#parent(normalized);
+        if (!this.#folders.has(parent)) {
+            if (!options?.recursive)
+                throw fsError("ENOENT", parent);
+            this.#ensureParentFolders(`${normalized}/child`);
+        }
+        const existing = this.#folders.get(normalized);
+        const now = this.#now();
+        this.#folders.set(normalized, {
+            type: "folder",
+            ctime: existing?.ctime ?? now,
+            mtime: now,
+            size: 0,
+        });
+    }
+    async rmdir(path, recursive) {
+        const normalized = this.#path(path);
+        if (normalized === "/")
+            throw fsError("EPERM", normalized);
+        if (!this.#folders.has(normalized))
+            throw fsError("ENOENT", normalized);
+        const prefix = `${normalized}/`;
+        const files = [...this.#files.keys()].filter((key) => key.startsWith(prefix));
+        const folders = [...this.#folders.keys()].filter((key) => key.startsWith(prefix));
+        if (!recursive && (files.length > 0 || folders.length > 0)) {
+            throw fsError("ENOTEMPTY", normalized);
+        }
+        for (const file of files)
+            this.#files.delete(file);
+        for (const folder of folders)
+            this.#folders.delete(folder);
+        this.#folders.delete(normalized);
+    }
+    async remove(path) {
+        const normalized = this.#path(path);
+        if (this.#files.delete(normalized))
+            return;
+        if (this.#folders.has(normalized))
+            throw fsError("EISDIR", normalized);
+        throw fsError("ENOENT", normalized);
+    }
+    async rename(path, newPath) {
+        const source = this.#path(path);
+        const target = this.#path(newPath);
+        if (source === target)
+            return;
+        await this.copy(source, target);
+        if (this.#folders.has(source))
+            await this.rmdir(source, true);
+        else
+            await this.remove(source);
+    }
+    async copy(path, newPath) {
+        const source = this.#path(path);
+        const target = this.#path(newPath);
+        if (source === target)
+            return;
+        this.#assertFilePath(target);
+        const file = this.#files.get(source);
+        const isFolder = this.#folders.has(source);
+        if (!file && !isFolder)
+            throw fsError("ENOENT", source);
+        if ((isFolder && target.startsWith(`${source}/`)) ||
+            source.startsWith(`${target}/`)) {
+            throw fsError("EINVAL", target);
+        }
+        await this.#removeTarget(target);
+        if (file) {
+            await this.#writeValue(target, file.data, {
+                ctime: file.stat.ctime,
+                mtime: file.stat.mtime,
+            });
+            return;
+        }
+        await this.mkdir(target, { recursive: true });
+        const prefix = `${source}/`;
+        const folders = [...this.#folders.keys()]
+            .filter((key) => key.startsWith(prefix))
+            .sort((a, b) => a.length - b.length);
+        for (const folder of folders) {
+            const suffix = folder.slice(prefix.length);
+            await this.mkdir(joinPath(target, suffix), { recursive: true });
+        }
+        for (const [filePath, stored] of this.#files.entries()) {
+            if (!filePath.startsWith(prefix))
+                continue;
+            const suffix = filePath.slice(prefix.length);
+            await this.#writeValue(joinPath(target, suffix), stored.data, {
+                ctime: stored.stat.ctime,
+                mtime: stored.stat.mtime,
+            });
+        }
+    }
+    getResourcePath(path) {
+        return `memory-vault://${encodeURIComponent(this.#vaultId)}/${this.#path(path)}`;
+    }
+    async trashSystem() {
+        return false;
+    }
+    async trashLocal(path) {
+        const normalized = this.#path(path);
+        const trashPath = this.#path(joinPath(".trash", normalized));
+        await this.mkdir(dirname(trashPath), { recursive: true });
+        await this.rename(normalized, trashPath);
+    }
+    async #writeValue(path, value, options) {
+        const normalized = this.#path(path);
+        this.#assertFilePath(normalized);
+        if (this.#folders.has(normalized))
+            throw fsError("EISDIR", normalized);
+        this.#ensureParentFolders(normalized);
+        const existing = this.#files.get(normalized)?.stat;
+        const now = this.#now();
+        this.#files.set(normalized, {
+            data: cloneValue(value),
+            stat: {
+                type: "file",
+                ctime: options?.ctime ?? existing?.ctime ?? now,
+                mtime: options?.mtime ?? now,
+                size: byteLength(value),
+            },
+        });
+        this.#writeCount += 1;
+        if (typeof value === "string") {
+            this.onWrite?.(normalized, value, this.#writeCount);
+        }
+    }
+    async #removeTarget(path) {
+        if (this.#files.has(path)) {
+            this.#files.delete(path);
+            return;
+        }
+        if (this.#folders.has(path))
+            await this.rmdir(path, true);
+    }
+    #ensureParentFolders(path) {
+        let parent = this.#parent(path);
+        const missing = [];
+        while (parent !== "/" && !this.#folders.has(parent)) {
+            if (this.#files.has(parent))
+                throw fsError("ENOTDIR", parent);
+            missing.unshift(parent);
+            parent = this.#parent(parent);
+        }
+        for (const folder of missing) {
+            const now = this.#now();
+            this.#folders.set(folder, {
+                type: "folder",
+                ctime: now,
+                mtime: now,
+                size: 0,
+            });
+        }
+    }
+    #path(value) {
+        const slashes = value.replace(/\\/g, "/").replace(/\/+$/, "");
+        if (!slashes || slashes === "/")
+            return "/";
+        const normalized = normalizePath(slashes);
+        if (!normalized || normalized === "/")
+            return "/";
+        if (normalized === ".." || normalized.startsWith("../")) {
+            throw fsError("EPERM", value);
+        }
+        return normalized.replace(/^\/+/, "");
+    }
+    #parent(path) {
+        const parent = dirname(path);
+        return parent === "." || parent === "" ? "/" : this.#path(parent);
+    }
+    #assertFilePath(path) {
+        if (path === "/")
+            throw fsError("EISDIR", path);
+    }
+    #now() {
+        return this.#clock();
+    }
+}
+function byteLength(value) {
+    return typeof value === "string"
+        ? new TextEncoder().encode(value).byteLength
+        : value.byteLength;
+}
+function cloneValue(value) {
+    return typeof value === "string" ? value : value.slice(0);
+}
+function toArrayBuffer(value) {
+    return value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+}
+function fsError(code, path) {
+    return Object.assign(new Error(`${code}: ${path}`), { code });
+}
+function hasCode(error, code) {
+    return error?.code === code;
+}