@indietabletop/appkit 6.1.5 → 7.0.0-0

package/dist/ModalDialog/style.css.d.ts

@@ -0,0 +1,58 @@
+export declare const dialog: import('@vanilla-extract/recipes').RuntimeFn<{
+    size: {
+        large: {
+            inlineSize: "100%";
+            blockSize: "100%";
+            "@media": {
+                "(min-width: 50em)": {
+                    blockSize: "fit-content";
+                    maxInlineSize: "40rem";
+                    maxBlockSize: "90%";
+                    borderRadius: "1rem";
+                    transition: string;
+                    transform: string;
+                    selectors: {
+                        "&[data-enter]": {
+                            opacity: number;
+                            transform: string;
+                        };
+                        "&[data-leave]": {
+                            opacity: number;
+                            transform: string;
+                        };
+                    };
+                };
+            };
+            transition: string;
+            transform: string;
+            selectors: {
+                "&[data-enter]": {
+                    opacity: number;
+                    transform: string;
+                };
+                "&[data-leave]": {
+                    opacity: number;
+                    transform: string;
+                };
+            };
+        };
+        small: {
+            inlineSize: "min(24rem, 90svw)";
+            blockSize: "fit-content";
+            borderRadius: "1rem";
+            transition: string;
+            transform: string;
+            selectors: {
+                "&[data-enter]": {
+                    opacity: number;
+                    transform: string;
+                };
+                "&[data-leave]": {
+                    opacity: number;
+                    transform: string;
+                };
+            };
+        };
+    };
+}>;
+export declare const backdrop: string;

package/dist/ModernIDB/Cursor.d.ts

@@ -0,0 +1,56 @@
+export declare class Cursor<C extends IDBCursor = IDBCursor> {
+    idbCursor: C;
+    constructor(idbCursor: C);
+    get key(): IDBValidKey;
+    get primaryKey(): IDBValidKey;
+    get direction(): IDBCursorDirection;
+    /**
+     * Advances the cursor through the next count records in range.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursor/advance
+     */
+    advance(count: number): void;
+    /**
+     * Advances the cursor to the next record in range.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursor/continue)
+     */
+    continue(key?: IDBValidKey): void;
+}
+export declare class CursorWithValue<Item> extends Cursor<IDBCursorWithValue> {
+    get value(): Item;
+    /**
+     * Delete the record pointed at by the cursor.
+     *
+     * If successful, request's result will be undefined.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursor/delete)
+     */
+    delete(): Promise<undefined>;
+    /**
+     * Updated the record pointed at by the cursor with a new value.
+     *
+     * Throws a "DataError" DOMException if the effective object store uses in-line keys and the key would have changed.
+     *
+     * If successful, request's result will be the record's key.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursor/update)
+     */
+    update(value: Item): Promise<IDBValidKey>;
+}
+export declare class IndexCursor extends Cursor {
+    /**
+     * Advances the cursor to the next record in range matching or after key and primaryKey. Throws an "InvalidAccessError" DOMException if the source is not an index.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursor/continuePrimaryKey)
+     */
+    continuePrimaryKey(key: IDBValidKey, primaryKey: IDBValidKey): void;
+}
+export declare class IndexCursorWithValue<Item> extends CursorWithValue<Item> {
+    /**
+     * Advances the cursor to the next record in range matching or after key and primaryKey. Throws an "InvalidAccessError" DOMException if the source is not an index.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBCursor/continuePrimaryKey)
+     */
+    continuePrimaryKey(key: IDBValidKey, primaryKey: IDBValidKey): void;
+}

package/dist/ModernIDB/ModernIDB.d.ts

@@ -0,0 +1,66 @@
+import { ObjectStore } from './ObjectStore.ts';
+import { ModernIDBIndexes, ModernIDBSchema, ModernIDBState, OpenRequestHandlers, TransactionMode } from './types.ts';
+export declare class TransactionEvent<StoreName extends string> extends CustomEvent<{
+    storeNames: StoreName[];
+}> {
+    constructor(type: TransactionMode, storeNames: StoreName[]);
+}
+type TransactionOptions = IDBTransactionOptions & {
+    /**
+     * Do not emit events when this transaction completes.
+     */
+    noEmit?: boolean;
+};
+type DatabaseProps = {
+    name: string;
+    version: number;
+};
+export declare class ModernIDB<Schema extends ModernIDBSchema, IndexNames extends ModernIDBIndexes<Schema>> {
+    readonly name: string;
+    readonly version: number;
+    protected state: ModernIDBState;
+    protected idbDatabase: IDBDatabase | null;
+    private eventTarget;
+    private onBlocking?;
+    private onUpgrade?;
+    private onInit?;
+    constructor(props: DatabaseProps & OpenRequestHandlers<Schema, IndexNames>);
+    addEventListener(type: TransactionMode, callback: (event: TransactionEvent<string & keyof Schema>) => void, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener(type: TransactionMode, callback: (event: TransactionEvent<string & keyof Schema>) => void, options?: boolean | EventListenerOptions): void;
+    /**
+     * Opens a connection to IndexedDB.
+     *
+     * ModernIDB instance must be in a `closed` state, otherwise an
+     * `InvalidConnectionStateError` will be thrown.
+     *
+     * If the database needs to upgrade (i.e. supplied version is higher than
+     * the current version), but there are existing connections that don't
+     * close on `versionchange` event (the onBlocking handler), an
+     * `OpenRequestBlockedError` will be thrown.
+     *
+     * Additional browser-specific exceptions can also be thrown. Make
+     * sure to inspect any error's `name` property to differentiate
+     * between the various types of errors that could occur.
+     */
+    open(handlers?: OpenRequestHandlers<Schema, IndexNames>): Promise<Event>;
+    close(): void;
+    isOpen(): this is this & {
+        idbDatabase: IDBDatabase;
+    };
+    private assertOpen;
+    transaction<StoreName extends string & keyof Schema>(name: StoreName, mode?: TransactionMode, options?: TransactionOptions): [
+        ObjectStore<Schema[StoreName], IndexNames[StoreName] extends string ? IndexNames[StoreName] : never>,
+        Promise<Event>
+    ];
+    transaction<StoreNamesArray extends readonly (string & keyof Schema)[] | []>(names: StoreNamesArray, mode?: TransactionMode, options?: TransactionOptions): [
+        {
+            -readonly [Index in keyof StoreNamesArray]: ObjectStore<Schema[StoreNamesArray[Index]], IndexNames[StoreNamesArray[Index]] extends string ? IndexNames[StoreNamesArray[Index]] : never>;
+        },
+        Promise<Event>
+    ];
+    deleteFromStore(storeName: string & keyof Schema, query: IDBValidKey | IDBKeyRange, options?: IDBTransactionOptions): Promise<void>;
+    getFromStore<StoreName extends string & keyof Schema>(storeName: StoreName, query: IDBValidKey | IDBKeyRange, options?: IDBTransactionOptions): Promise<Schema[StoreName] | undefined>;
+    putToStore<StoreName extends string & keyof Schema>(storeName: StoreName, value: Schema[StoreName], key?: IDBValidKey): Promise<IDBValidKey>;
+}
+export declare function deleteDatabase(name: string): Promise<IDBDatabase>;
+export {};

package/dist/ModernIDB/ModernIDBError.d.ts

@@ -0,0 +1,3 @@
+export declare class ModernIDBError extends Error {
+    constructor(name: "OpenRequestBlockedError" | "InvalidConnectionStateError", message: string);
+}

package/dist/ModernIDB/ObjectStore.d.ts

@@ -0,0 +1,112 @@
+import { Cursor, CursorWithValue } from './Cursor.ts';
+import { ObjectStoreIndex } from './ObjectStoreIndex.ts';
+import { KeyPath } from './types.ts';
+export declare class ObjectStore<Item, IndexName extends string> {
+    readonly idbObjectStore: IDBObjectStore;
+    constructor(objectStore: IDBObjectStore);
+    /**
+     * Adds or updates a record in store with the given value and key.
+     *
+     * If the store uses in-line keys and key is specified a "DataError" DOMException will be thrown.
+     *
+     * If put() is used, any existing record with the key will be replaced. If add() is used, and if a record with the key already exists the request will fail, with request's error set to a "ConstraintError" DOMException.
+     *
+     * If successful, request's result will be the record's key.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/add)
+     */
+    add(value: Item, key?: IDBValidKey): Promise<IDBValidKey>;
+    /**
+     * Deletes all records in store.
+     *
+     * If successful, request's result will be undefined.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/clear)
+     */
+    clear(): Promise<undefined>;
+    /**
+     * Retrieves the number of records matching the given key or key range in query.
+     *
+     * If successful, request's result will be the count.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/count)
+     */
+    count(query?: IDBValidKey | IDBKeyRange): Promise<number>;
+    /**
+     * Deletes records in store with the given key or in the given key range in query.
+     *
+     * If successful, request's result will be undefined.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/delete)
+     */
+    delete(query: IDBValidKey | IDBKeyRange): Promise<undefined>;
+    /**
+     * Retrieves the value of the first record matching the given key or key range in query.
+     *
+     * If successful, request's result will be the value, or undefined if there was no matching record.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/get)
+     */
+    get(query: IDBValidKey | IDBKeyRange): Promise<Item | undefined>;
+    /**
+     * Retrieves the values of the records matching the given key or key range in query (up to count if given).
+     *
+     * If successful, request's result will be an Array of the values.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/getAll)
+     */
+    getAll(query?: IDBValidKey | IDBKeyRange | null, count?: number): Promise<Item[]>;
+    /**
+     * Retrieves the keys of records matching the given key or key range in query (up to count if given).
+     *
+     * If successful, request's result will be an Array of the keys.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/getAllKeys)
+     */
+    getAllKeys(query?: IDBValidKey | IDBKeyRange | null, count?: number): Promise<IDBValidKey[]>;
+    /**
+     * Retrieves the key of the first record matching the given key or key range in query.
+     *
+     * If successful, request's result will be the key, or undefined if there was no matching record.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/getKey)
+     */
+    getKey(query: IDBValidKey | IDBKeyRange): Promise<IDBValidKey | undefined>;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/index) */
+    index(name: IndexName): ObjectStoreIndex<Item>;
+    /**
+     * Opens a cursor over the records matching query, ordered by direction. If query is null, all records in store are matched.
+     */
+    openCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): AsyncGenerator<CursorWithValue<Item>, void, undefined>;
+    /**
+     * Opens a cursor with key only flag set over the records matching query, ordered by direction. If query is null, all records in store are matched.
+     */
+    openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): AsyncGenerator<Cursor, void, undefined>;
+    /**
+     * Adds or updates a record in store with the given value and key.
+     *
+     * If the store uses in-line keys and key is specified a "DataError" DOMException will be thrown.
+     *
+     * If put() is used, any existing record with the key will be replaced. If add() is used, and if a record with the key already exists the request will fail, with request's error set to a "ConstraintError" DOMException.
+     *
+     * If successful, request's result will be the record's key.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/put)
+     */
+    put(value: Item, key?: IDBValidKey): Promise<IDBValidKey>;
+}
+export declare class VersionChangeObjectStore<Item, IndexName extends string> extends ObjectStore<Item, IndexName> {
+    /**
+     * Creates a new index in store with the given name, keyPath and options and returns a new IDBIndex. If the keyPath and options define constraints that cannot be satisfied with the data already in store the upgrade transaction will abort with a "ConstraintError" DOMException.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/createIndex)
+     */
+    createIndex(name: IndexName, keyPath: KeyPath<Item> | KeyPath<Item>[], options?: IDBIndexParameters): ObjectStoreIndex<Item>;
+    /**
+     * Deletes the index in store with the given name.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/deleteIndex)
+     */
+    deleteIndex(name: IndexName): void;
+    renameIndex(currentName: string, newName: IndexName): void;
+}

package/dist/ModernIDB/ObjectStoreIndex.d.ts

@@ -0,0 +1,53 @@
+import { IndexCursor, IndexCursorWithValue } from './Cursor.ts';
+export declare class ObjectStoreIndex<Item> {
+    readonly idbIndex: IDBIndex;
+    constructor(idbIndex: IDBIndex);
+    /**
+     * Retrieves the number of records matching the given key or key range in query.
+     *
+     * If successful, request's result will be the count.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/count)
+     */
+    count(query?: IDBValidKey | IDBKeyRange): Promise<number>;
+    /**
+     * Retrieves the value of the first record matching the given key or key range in query.
+     *
+     * If successful, request's result will be the value, or undefined if there was no matching record.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/get)
+     */
+    get(query: IDBValidKey | IDBKeyRange): Promise<Item | undefined>;
+    /**
+     * Retrieves the values of the records matching the given key or key range in query (up to count if given).
+     *
+     * If successful, request's result will be an Array of the values.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/getAll)
+     */
+    getAll(query?: IDBValidKey | IDBKeyRange | null, count?: number): Promise<Item[]>;
+    /**
+     * Retrieves the keys of records matching the given key or key range in query (up to count if given).
+     *
+     * If successful, request's result will be an Array of the keys.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/getAllKeys)
+     */
+    getAllKeys(query?: IDBValidKey | IDBKeyRange | null, count?: number): Promise<IDBValidKey[]>;
+    /**
+     * Retrieves the key of the first record matching the given key or key range in query.
+     *
+     * If successful, request's result will be the key, or undefined if there was no matching record.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBObjectStore/getKey)
+     */
+    getKey(query: IDBValidKey | IDBKeyRange): Promise<IDBValidKey | undefined>;
+    /**
+     * Opens a cursor over the records matching query, ordered by direction. If query is null, all records in store are matched.
+     */
+    openCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): AsyncGenerator<IndexCursorWithValue<Item>, void, undefined>;
+    /**
+     * Opens a cursor with key only flag set over the records matching query, ordered by direction. If query is null, all records in store are matched.
+     */
+    openKeyCursor(query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): AsyncGenerator<IndexCursor, void, undefined>;
+}

package/dist/ModernIDB/Transaction.d.ts

@@ -0,0 +1,16 @@
+import { ObjectStore, VersionChangeObjectStore } from './ObjectStore.ts';
+import { ModernIDBSchema } from './types.ts';
+export declare class Transaction<Schema extends ModernIDBSchema, IndexNames extends {
+    [K in keyof Schema]?: string;
+}> {
+    idbTransaction: IDBTransaction;
+    constructor(props: {
+        transaction: IDBTransaction;
+    });
+    objectStore<StoreName extends string & keyof Schema>(name: StoreName): ObjectStore<Schema[StoreName], IndexNames[StoreName] extends string ? IndexNames[StoreName] : never>;
+}
+export declare class VersionChangeTransaction<Schema extends ModernIDBSchema, IndexNames extends {
+    [K in keyof Schema]?: string;
+}> extends Transaction<Schema, IndexNames> {
+    objectStore<StoreName extends string & keyof Schema>(name: StoreName): VersionChangeObjectStore<Schema[StoreName], IndexNames[StoreName] extends string ? IndexNames[StoreName] : never>;
+}

package/dist/ModernIDB/VersionChangeManager.d.ts

@@ -0,0 +1,30 @@
+import { VersionChangeObjectStore } from './ObjectStore.ts';
+import { VersionChangeTransaction } from './Transaction.ts';
+import { KeyPath, ModernIDBSchema } from './types.ts';
+export declare class VersionChangeManager<Schema extends ModernIDBSchema, IndexNames extends {
+    [K in keyof Schema]?: string;
+} = never> {
+    readonly idbDatabase: IDBDatabase;
+    readonly event: IDBVersionChangeEvent;
+    readonly transaction: VersionChangeTransaction<Schema, IndexNames>;
+    constructor(props: {
+        idbDatabase: IDBDatabase;
+        event: IDBVersionChangeEvent;
+        idbTransaction: IDBTransaction;
+    });
+    /**
+     * Creates a new object store with the given name and options and returns a new IDBObjectStore.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBDatabase/createObjectStore)
+     */
+    createObjectStore<StoreName extends string & keyof Schema>(name: StoreName, options?: {
+        autoIncrement?: boolean;
+        keyPath?: KeyPath<Schema[StoreName]> | KeyPath<Schema[StoreName]>[] | null;
+    }): VersionChangeObjectStore<Schema[StoreName], IndexNames[StoreName] extends string ? IndexNames[StoreName] : never>;
+    /**
+     * Deletes the object store with the given name.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBDatabase/deleteObjectStore)
+     */
+    deleteObjectStore(name: string): void;
+}

package/dist/ModernIDB/bindings/factory.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import { AnyModernIDB } from '../types.ts';
+import { DatabaseOpenRequestOp, FlattenSuccessOps, QueryOp } from './types.ts';
+export declare function createDatabaseBindings<T extends AnyModernIDB>(db: T): {
+    useQuery: <Output>(query: (db: T) => Promise<Output>, cacheKey?: string) => FlattenSuccessOps<QueryOp<Output>>;
+    useDatabase: () => T;
+    useDatabaseOpenRequest: () => DatabaseOpenRequestOp<T>;
+    DatabaseProvider: (props: {
+        children: ReactNode;
+        open?: boolean;
+    }) => import("react/jsx-runtime").JSX.Element;
+};

package/dist/ModernIDB/bindings/index.d.ts

@@ -0,0 +1,2 @@
+export * from './factory.tsx';
+export * from './types.ts';

package/{lib/ModernIDB/bindings/types.ts → dist/ModernIDB/bindings/types.d.ts}

@@ -1,56 +1,37 @@
-import type { AsyncOp, Success } from "../../async-op.ts";
-import type { AnyModernIDB } from "../types.ts";
-
+import { AsyncOp, Success } from '../../async-op.ts';
+import { AnyModernIDB } from '../types.ts';
 export type DatabaseQueryOpFailure = QueryError | InaccessibleDatabaseError;
-
 export type QueryOp<Output> = AsyncOp<Output, DatabaseQueryOpFailure>;
-
-export type FlattenSuccessOps<T> = T extends Success<
-  infer S extends AsyncOp<unknown, unknown>
->
-  ? S
-  : T;
-
+export type FlattenSuccessOps<T> = T extends Success<infer S extends AsyncOp<unknown, unknown>> ? S : T;
 export type QueryError = {
-  type: "QUERY_ERROR";
-  error: string;
+    type: "QUERY_ERROR";
+    error: string;
 };
-
 /**
  * The stored database version is higher than the version requested.
  */
 export type VersionHigherState = {
-  type: "DB_VERSION_HIGHER_THAN_REQUESTED";
-  message: string;
+    type: "DB_VERSION_HIGHER_THAN_REQUESTED";
+    message: string;
 };
-
 /**
  * Database could not be opened for an unrecognized reason.
  */
 export type UnexpectedErrorState = {
-  type: "UNKNOWN_ERROR";
-  message: string;
+    type: "UNKNOWN_ERROR";
+    message: string;
 };
-
 /**
  * This happens if the database needs an upgrade due to version change, but there are connections open to it from other tabs.
  */
 export type UpgradeBlockedState = {
-  type: "UPGRADE_BLOCKED";
+    type: "UPGRADE_BLOCKED";
 };
-
 /**
  * The DB has been closed to allow for version change.
  */
 export type ClosedForUpgradeState = {
-  type: "CLOSED_FOR_UPGRADE";
+    type: "CLOSED_FOR_UPGRADE";
 };
-
-export type InaccessibleDatabaseError =
-  | UpgradeBlockedState
-  | ClosedForUpgradeState
-  | VersionHigherState
-  | UnexpectedErrorState;
-
-export type DatabaseOpenRequestOp<T extends AnyModernIDB = AnyModernIDB> =
-  AsyncOp<T, InaccessibleDatabaseError>;
+export type InaccessibleDatabaseError = UpgradeBlockedState | ClosedForUpgradeState | VersionHigherState | UnexpectedErrorState;
+export type DatabaseOpenRequestOp<T extends AnyModernIDB = AnyModernIDB> = AsyncOp<T, InaccessibleDatabaseError>;

package/dist/ModernIDB/bindings/utils.d.ts

@@ -0,0 +1,2 @@
+import { InaccessibleDatabaseError } from './types.ts';
+export declare function toKnownError(error: unknown): InaccessibleDatabaseError;

package/dist/ModernIDB/index.d.ts

@@ -0,0 +1,10 @@
+export * from './bindings/index.ts';
+export * from './Cursor.ts';
+export * from './ModernIDB.ts';
+export * from './ModernIDBError.ts';
+export * from './ObjectStore.ts';
+export * from './ObjectStoreIndex.ts';
+export * from './Transaction.ts';
+export * from './types.ts';
+export * from './utils.ts';
+export * from './VersionChangeManager.ts';

package/dist/ModernIDB/types.d.ts

@@ -0,0 +1,88 @@
+import { ModernIDB } from './ModernIDB.ts';
+import { VersionChangeManager } from './VersionChangeManager.ts';
+/**
+ * IDB supports "readonly", "readwrite", and "versionchange" transaction modes,
+ * but "versionchange" can only be initiated automatically during DB upgrade.
+ */
+export type TransactionMode = "readonly" | "readwrite";
+export type ModernIDBState = "open" | "opening" | "closed";
+export type ModernIDBSchema = {
+    [key: string]: unknown;
+};
+export type ModernIDBIndexes<Schema extends ModernIDBSchema> = {
+    [K in keyof Schema]?: string;
+};
+export type VersionChangeHandlerProps<Schema extends ModernIDBSchema, IndexNames extends ModernIDBIndexes<Schema>> = {
+    event: IDBVersionChangeEvent;
+    manager: VersionChangeManager<Schema, IndexNames>;
+    db: ModernIDB<Schema, IndexNames>;
+};
+export type VersionChangeHandler<Schema extends ModernIDBSchema, IndexNames extends ModernIDBIndexes<Schema>> = (props: VersionChangeHandlerProps<Schema, IndexNames>) => void;
+export type BlockingHandlerProps<Schema extends ModernIDBSchema, IndexNames extends ModernIDBIndexes<Schema>> = {
+    event: IDBVersionChangeEvent;
+    db: ModernIDB<Schema, IndexNames>;
+};
+export type BlockingHandler<Schema extends ModernIDBSchema, IndexNames extends ModernIDBIndexes<Schema>> = (props: BlockingHandlerProps<Schema, IndexNames>) => void;
+export type OpenRequestHandlers<Schema extends ModernIDBSchema, IndexNames extends ModernIDBIndexes<Schema>> = {
+    /**
+     * Called when the database is initialized from scratch.
+     *
+     * Should be used to set up all required stores and indexes.
+     *
+     * If error is thrown in this handler, the version change transaction will
+     * be aborted.
+     *
+     * @example
+     *
+     * ```ts
+     * onInit({ manager }) {
+     *   const store = manager.createObjectStore("items", { keyPath: "id" });
+     *   store.createIndex("createdTs", "createdTs");
+     *
+     *   console.info("DB initialized.");
+     * },
+     * ```
+     */
+    onInit?: VersionChangeHandler<Schema, IndexNames>;
+    /**
+     * Called when there is an existing IDB database present, but is is of a lower
+     * version than the latest.
+     *
+     * If error is thrown inside this handler, the version change transaction
+     * will be aborted.
+     *
+     * @example
+     * ```ts
+     * onUpgrade({ manager, event }) {
+     *  switch (event.oldVersion) {
+     *    case 1: {
+     *      // We need a `settings` store in v2, but it did't exist in v1
+     *      const store = manager.createObjectStore("settings", { keyPath: "id" });
+     *      store.createIndex("createdTs", "createdTs");
+     *    }
+     *
+     *    default: {
+     *      console.info(`Migration from DB v${event.oldVersion} complete.`);
+     *    }
+     *   }
+     * }
+     * ```
+     */
+    onUpgrade?: VersionChangeHandler<Schema, IndexNames>;
+    /**
+     * If a new connection opens which requests a higher version number than
+     * is the current version number, a `versionchange` event will be dispatched
+     * on the IDBDatabase instance. This handler can specify desired behaviour.
+     * For example, you might want to close currently connected connections
+     * to allow the version change to proceed.
+     */
+    onBlocking?: BlockingHandler<Schema, IndexNames>;
+};
+type ValidKeyValue = string | number | Date;
+export type KeyPath<T> = T extends {
+    [key: string]: unknown;
+} ? {
+    [K in keyof T]: K extends string ? T[K] extends ValidKeyValue ? `${K}` : `${K}.${KeyPath<T[K]>}` : never;
+}[keyof T] : never;
+export type AnyModernIDB = ModernIDB<any, any>;
+export {};

package/dist/ModernIDB/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function transactionToPromise(transaction: IDBTransaction): Promise<Event>;
+export declare function requestToPromise<T>(request: IDBRequest<T>): Promise<T>;
+export declare function openRequestToPromise(request: IDBOpenDBRequest): Promise<IDBDatabase>;
+export declare function requestToAsyncGenerator(request: IDBRequest<IDBCursorWithValue | null>): AsyncGenerator<IDBCursorWithValue, void, unknown>;

package/dist/QRCode/QRCode.d.ts

@@ -0,0 +1,7 @@
+import { AsyncOp } from '../async-op.ts';
+type QRCodeProps = {
+    url: AsyncOp<string, unknown>;
+    className?: string;
+};
+export declare function QRCode(props: QRCodeProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/QRCode/QRCode.stories.d.ts

@@ -0,0 +1,33 @@
+import { Failure, Pending } from '../async-op.ts';
+export declare const SuccessCase: import('@storybook/react').ReactStory<import('@storybook/react').ReactTypes & import('@storybook/addon-docs').DocsTypes & {
+    csf4: true;
+} & {
+    args: {
+        url: import('../async-op.ts').AsyncOp<string, unknown>;
+        className?: string | undefined;
+    };
+}, {}>;
+export declare const PendingCase: import('@storybook/react').ReactStory<import('@storybook/react').ReactTypes & import('@storybook/addon-docs').DocsTypes & {
+    csf4: true;
+} & {
+    args: {
+        url: import('../async-op.ts').AsyncOp<string, unknown>;
+        className?: string | undefined;
+    };
+}, {
+    args: {
+        url: Pending;
+    };
+}>;
+export declare const FailureCase: import('@storybook/react').ReactStory<import('@storybook/react').ReactTypes & import('@storybook/addon-docs').DocsTypes & {
+    csf4: true;
+} & {
+    args: {
+        url: import('../async-op.ts').AsyncOp<string, unknown>;
+        className?: string | undefined;
+    };
+}, {
+    args: {
+        url: Failure<string>;
+    };
+}>;

package/dist/QRCode/style.css.d.ts

@@ -0,0 +1,4 @@
+export declare const code: {
+    container: string;
+    image: string;
+};

package/dist/ReleaseInfo/index.d.ts

@@ -0,0 +1,5 @@
+export declare function ReleaseInfo(props: {
+    branch?: string;
+    shortcode?: string;
+    backgroundColor?: string;
+}): import("react/jsx-runtime").JSX.Element;