@scalar/workspace-store 0.40.2 → 0.40.4

package/dist/persistence/indexdb.js

@@ -1,133 +1,270 @@
-const createIndexDbConnection = async ({
-  name = "scalar-workspace-store",
-  tables,
-  version = 1,
-  migrations = []
-}) => {
-  const db = indexedDB.open(name, version);
-  db.onupgradeneeded = (e) => {
-    if (e.oldVersion < 1) {
-      const database = db.result;
-      Object.entries(tables).forEach(([name2, options]) => {
-        if (!database.objectStoreNames.contains(name2)) {
-          const objectStore = database.createObjectStore(name2, {
-            keyPath: options.keyPath.length === 1 ? options.keyPath[0] : options.keyPath
-          });
-          Object.entries(options.indexes ?? {}).forEach(([indexName, indexPath]) => {
-            objectStore.createIndex(indexName, indexPath);
-          });
+/**
+ * Initializes and manages an IndexedDB database connection for table-based persistence.
+ *
+ * @param name - The database name. Defaults to 'scalar-workspace-store'.
+ * @param tables - Table definitions: the tables to create and their key schemas.
+ * @param version - The database version. Bump this to trigger upgrades (default: 1).
+ * @param migrations - Optional migration steps to run for version upgrades.
+ * @returns An object with the following methods:
+ *   - `get(tableName)` — Get a wrapper to interact with the object store for the given table name.
+ *   - `closeDatabase()` — Closes the database connection.
+ *
+ * Example usage:
+ * ```ts
+ * import { Type } from '@scalar/typebox'
+ * import { createIndexDbConnection } from './indexdb.js'
+ *
+ * // Define a schema for a user
+ * const UserSchema = Type.Object({
+ *   id: Type.String(),
+ *   name: Type.String(),
+ *   age: Type.Number(),
+ * })
+ *
+ * // Define tables in the database
+ * const dbConfig = {
+ *   users: {
+ *     schema: UserSchema,
+ *     index: ['id'] as const,
+ *   },
+ * }
+ *
+ * // Open the database connection and get table API
+ * const { get, closeDatabase } = await createIndexDbConnection({
+ *   name: 'my-app-db',
+ *   tables: dbConfig,
+ *   version: 1,
+ * })
+ *
+ * // Get a strongly-typed users table API
+ * const usersTable = get('users')
+ *
+ * // Add a user
+ * await usersTable.addItem({ id: 'user-1' }, { name: 'Alice', age: 25 })
+ *
+ * // Retrieve a user by id
+ * const user = await usersTable.getItem({ id: 'user-1' })
+ *
+ * // Don't forget to close the database when done!
+ * closeDatabase()
+ * ```
+ */
+export const createIndexDbConnection = async ({ name = 'scalar-workspace-store', tables, version = 1, migrations = [], }) => {
+    const db = indexedDB.open(name, version);
+    db.onupgradeneeded = (e) => {
+        // Initial setup of object stores
+        if (e.oldVersion < 1) {
+            const database = db.result;
+            // Initialize all the tables
+            Object.entries(tables).forEach(([name, options]) => {
+                if (!database.objectStoreNames.contains(name)) {
+                    const objectStore = database.createObjectStore(name, {
+                        keyPath: options.keyPath.length === 1 ? options.keyPath[0] : options.keyPath,
+                    });
+                    // Create any indexes for the object store
+                    Object.entries(options.indexes ?? {}).forEach(([indexName, indexPath]) => {
+                        objectStore.createIndex(indexName, indexPath);
+                    });
+                }
+            });
         }
-      });
-    }
-    migrations.forEach((migration) => {
-      if (e.oldVersion < migration.version) {
-        migration.exec(db.result, e);
-      }
+        // Run any future migrations here
+        migrations.forEach((migration) => {
+            if (e.oldVersion < migration.version) {
+                migration.exec(db.result, e);
+            }
+        });
+    };
+    await new Promise((resolve, reject) => {
+        db.onsuccess = () => resolve(true);
+        db.onerror = () => reject(db.error);
     });
-  };
-  await new Promise((resolve, reject) => {
-    db.onsuccess = () => resolve(true);
-    db.onerror = () => reject(db.error);
-  });
-  return {
-    get: (name2) => {
-      return createTableWrapper(name2, db.result);
-    },
-    closeDatabase: () => {
-      db.result.close();
-    }
-  };
+    return {
+        get: (name) => {
+            return createTableWrapper(name, db.result);
+        },
+        closeDatabase: () => {
+            db.result.close();
+        },
+    };
 };
+/**
+ * Utility wrapper for interacting with an IndexedDB object store, typed by the schema.
+ *
+ * Usage example:
+ * ```
+ * // Define a TypeBox schema for users
+ * const UserSchema = Type.Object({
+ *   id: Type.String(),
+ *   name: Type.String(),
+ *   age: Type.Number(),
+ * })
+ *
+ * // Open or create the users table
+ * const usersTable = createTableWrapper<typeof UserSchema, 'id'>('users', openDatabase)
+ *
+ * // Add a user
+  await usersTable.addItem({ id: 'user-1' }, { name: 'Alice', age: 24 })
+ *
+ * // Get a user by id
+ * const alic = await usersTable.getItem({ id: 'user-1' })
+ *
+ * // Get users with a partial key (use [] if no composite key)
+ * const users = await usersTable.getRange(['user-1'])
+ *
+ * // Get all users
+ * const allUsers = await usersTable.getAll()
+ * ```
+ *
+ * @template T TypeBox schema type for objects in the store
+ * @template K Key property names that compose the primary key
+ *
+ * @param name - Object store name
+ * @param getDb - Function returning a Promise for the IDBDatabase
+ * @returns Methods to interact with the object store
+ */
 function createTableWrapper(name, db) {
-  const getStore = (mode) => {
-    const tx = db.transaction(name, mode);
-    return tx.objectStore(name);
-  };
-  async function addItem(key, value) {
-    const store = getStore("readwrite");
-    const finalValue = { ...value, ...key };
-    await requestAsPromise(store.put(finalValue));
-    return finalValue;
-  }
-  function getItem(key) {
-    const store = getStore("readonly");
-    const keyValues = Object.values(key);
-    const keyToUse = keyValues.length === 1 ? keyValues[0] : keyValues;
-    return requestAsPromise(store.get(keyToUse));
-  }
-  function getRange(partialKey, indexName) {
-    const store = getStore("readonly");
-    const objectStoreOrIndex = indexName ? store.index(indexName) : store;
-    const results = [];
-    const upperBound = [...partialKey];
-    upperBound.push([]);
-    const range = IDBKeyRange.bound(partialKey, upperBound, false, true);
-    return new Promise((resolve, reject) => {
-      const request = objectStoreOrIndex.openCursor(range);
-      request.onerror = () => reject(request.error);
-      request.onsuccess = (event) => {
-        const cursor = event.target.result;
-        if (cursor) {
-          results.push(cursor.value);
-          cursor.continue();
-        } else {
-          resolve(results);
-        }
-      };
-    });
-  }
-  async function deleteItem(key) {
-    const store = getStore("readwrite");
-    const keyValues = Object.values(key);
-    const keyToUse = keyValues.length === 1 ? keyValues[0] : keyValues;
-    await requestAsPromise(store.delete(keyToUse));
-  }
-  function deleteRange(partialKey) {
-    const store = getStore("readwrite");
-    let deletedCount = 0;
-    const upperBound = [...partialKey];
-    upperBound.push([]);
-    const range = IDBKeyRange.bound(partialKey, upperBound, false, true);
-    return new Promise((resolve, reject) => {
-      const request = store.openCursor(range);
-      request.onerror = () => reject(request.error);
-      request.onsuccess = (event) => {
-        const cursor = event.target.result;
-        if (cursor) {
-          cursor.delete();
-          deletedCount++;
-          cursor.continue();
-        } else {
-          resolve(deletedCount);
-        }
-      };
-    });
-  }
-  async function deleteAll() {
-    const store = getStore("readwrite");
-    await requestAsPromise(store.clear());
-  }
-  function getAll() {
-    const store = getStore("readonly");
-    return requestAsPromise(store.getAll());
-  }
-  return {
-    addItem,
-    getItem,
-    getRange,
-    deleteItem,
-    deleteRange,
-    getAll,
-    deleteAll
-  };
+    /**
+     * Gets the object store from the latest DB connection, for the given transaction mode.
+     */
+    const getStore = (mode) => {
+        const tx = db.transaction(name, mode);
+        return tx.objectStore(name);
+    };
+    /**
+     * Adds or updates an item in the store.
+     * @param key - The primary key values, as { key1, key2 }
+     * @param value - The value for the other properties, omitting keys
+     * @returns The full inserted/updated object
+     */
+    async function addItem(key, value) {
+        const store = getStore('readwrite');
+        const finalValue = { ...value, ...key };
+        await requestAsPromise(store.put(finalValue));
+        return finalValue;
+    }
+    /**
+     * Retrieves a single item by composite key.
+     * @param key - Key values. For a single key: { id: '...' }
+     * @returns The found object or undefined
+     */
+    function getItem(key) {
+        const store = getStore('readonly');
+        const keyValues = Object.values(key);
+        // For single keys, pass value directly; for compound keys, pass array
+        const keyToUse = keyValues.length === 1 ? keyValues[0] : keyValues;
+        return requestAsPromise(store.get(keyToUse));
+    }
+    /**
+     * Returns all records matching a partial (prefix) key. Use for composite keys.
+     * For non-compound keys, pass single-element array: getRange(['some-id'])
+     * For prefix search, pass subset of key parts.
+     * @param partialKey - Array of partial key values
+     * @returns Matching objects
+     *
+     * Example (composite [a,b]):
+     *   getRange(['foo']) // All with a === 'foo'
+     *   getRange(['foo', 'bar']) // All with a === 'foo' and b === 'bar'
+     */
+    function getRange(partialKey, indexName) {
+        const store = getStore('readonly');
+        const objectStoreOrIndex = indexName ? store.index(indexName) : store;
+        const results = [];
+        // Construct upper bound to match all keys starting with partialKey
+        const upperBound = [...partialKey];
+        upperBound.push([]); // ensures upper bound includes all keys with this prefix
+        const range = IDBKeyRange.bound(partialKey, upperBound, false, true);
+        return new Promise((resolve, reject) => {
+            const request = objectStoreOrIndex.openCursor(range);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = (event) => {
+                const cursor = event.target.result;
+                if (cursor) {
+                    results.push(cursor.value);
+                    cursor.continue();
+                }
+                else {
+                    resolve(results);
+                }
+            };
+        });
+    }
+    /**
+     * Deletes an item from the store by its composite key.
+     * @param key - Key values. For a single key: { id: '...' }
+     * @returns void
+     */
+    async function deleteItem(key) {
+        const store = getStore('readwrite');
+        const keyValues = Object.values(key);
+        // For single keys, pass value directly; for compound keys, pass array
+        const keyToUse = keyValues.length === 1 ? keyValues[0] : keyValues;
+        await requestAsPromise(store.delete(keyToUse));
+    }
+    /**
+     * Deletes all records matching a partial (prefix) key. Use for composite keys.
+     * For non-compound keys, pass single-element array: deleteRange(['some-id'])
+     * For prefix deletion, pass subset of key parts.
+     * @param partialKey - Array of partial key values
+     * @returns Number of deleted items
+     *
+     * Example (composite [a,b]):
+     *   deleteRange(['foo']) // Delete all with a === 'foo'
+     *   deleteRange(['foo', 'bar']) // Delete all with a === 'foo' and b === 'bar'
+     */
+    function deleteRange(partialKey) {
+        const store = getStore('readwrite');
+        let deletedCount = 0;
+        // Construct upper bound to match all keys starting with partialKey
+        const upperBound = [...partialKey];
+        upperBound.push([]); // ensures upper bound includes all keys with this prefix
+        const range = IDBKeyRange.bound(partialKey, upperBound, false, true);
+        return new Promise((resolve, reject) => {
+            const request = store.openCursor(range);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = (event) => {
+                const cursor = event.target.result;
+                if (cursor) {
+                    cursor.delete();
+                    deletedCount++;
+                    cursor.continue();
+                }
+                else {
+                    resolve(deletedCount);
+                }
+            };
+        });
+    }
+    /**
+     * Deletes all items from the table.
+     * @returns void
+     */
+    async function deleteAll() {
+        const store = getStore('readwrite');
+        await requestAsPromise(store.clear());
+    }
+    /**
+     * Retrieves all items from the table.
+     * @returns Array of all objects in the store
+     */
+    function getAll() {
+        const store = getStore('readonly');
+        return requestAsPromise(store.getAll());
+    }
+    return {
+        addItem,
+        getItem,
+        getRange,
+        deleteItem,
+        deleteRange,
+        getAll,
+        deleteAll,
+    };
 }
+// ---- Utility ----
 function requestAsPromise(req) {
-  return new Promise((resolve, reject) => {
-    req.onsuccess = () => resolve(req.result);
-    req.onerror = () => reject(req.error);
-  });
+    return new Promise((resolve, reject) => {
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error);
+    });
 }
-export {
-  createIndexDbConnection
-};
-//# sourceMappingURL=indexdb.js.map

package/dist/plugins/bundler/helpers.js

@@ -1,13 +1,22 @@
-import { getValueAtPath } from "@scalar/helpers/object/get-value-at-path";
-import { getSegmentsFromPath } from "@scalar/json-magic/helpers/get-segments-from-path";
-const getResolvedRef = (node, context) => {
-  if (node && typeof node === "object" && "$ref" in node && typeof node["$ref"] === "string" && node["$ref"].startsWith("#")) {
-    const segments = getSegmentsFromPath(node["$ref"].slice(1));
-    return getResolvedRef(getValueAtPath(context.rootNode, segments), context);
-  }
-  return node;
+import { getValueAtPath } from '@scalar/helpers/object/get-value-at-path';
+import { getSegmentsFromPath } from '@scalar/json-magic/helpers/get-segments-from-path';
+/**
+ * Recursively resolves the value behind a $ref pointer within the current document tree.
+ * For example, given a node with { $ref: '#/some/path' }, this will locate and return
+ * the referenced node, following the $ref chain if necessary.
+ *
+ * @param node - The node that may be a $ref object. If not, returns the node as is.
+ * @returns The resolved node if a $ref chain exists, otherwise the original node.
+ */
+export const getResolvedRef = (node, context) => {
+    if (node &&
+        typeof node === 'object' &&
+        '$ref' in node &&
+        typeof node['$ref'] === 'string' &&
+        node['$ref'].startsWith('#')) {
+        const segments = getSegmentsFromPath(node['$ref'].slice(1));
+        return getResolvedRef(getValueAtPath(context.rootNode, segments), context);
+    }
+    // If this node isn't a $ref, return it as the resolved value
+    return node;
 };
-export {
-  getResolvedRef
-};
-//# sourceMappingURL=helpers.js.map

package/dist/plugins/bundler/index.d.ts

@@ -104,4 +104,11 @@ export declare const normalizeRefs: () => LifecyclePlugin;
  * even after bundling or other transformations.
  */
 export declare const syncPathParameters: () => LifecyclePlugin;
+/**
+ * Lifecycle plugin to remove extra Scalar internal keys from nodes.
+ *
+ * This plugin is used to remove extra Scalar internal keys from nodes during the bundling process.
+ * These keys are used for internal purposes and are not needed in the final bundled document.
+ */
+export declare const removeExtraScalarKeys: () => LifecyclePlugin;
 //# sourceMappingURL=index.d.ts.map

package/dist/plugins/bundler/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/bundler/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAShE;;;;;GAKG;AACH,eAAO,MAAM,aAAa,QAAO,eAahC,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,QAAO,eA+BxC,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,QAAO,eAwCjC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,mBAAmB,QAAO,eAuBtC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,oBAAoB,QAAO,eAuBvC,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,aAAa,QAAO,eAmBhC,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,QAAO,eAkFrC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/bundler/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAShE;;;;;GAKG;AACH,eAAO,MAAM,aAAa,QAAO,eAahC,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,QAAO,eA+BxC,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,QAAO,eAwCjC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,mBAAmB,QAAO,eAuBtC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,oBAAoB,QAAO,eAuBvC,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,aAAa,QAAO,eAmBhC,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,QAAO,eAkFrC,CAAA;AAKD;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,QAAO,eAaxC,CAAA"}