amateras 0.4.1 → 0.5.0

package/README.md

@@ -99,11 +99,13 @@ $(document.body).content([
 ```
 
 ## Packages
-The packages size result using Vite 7.0 with default bundle settings, polyfills code size included.
+The packages size result using Vite 7.0 with default bundle settings, polyfills code included.
 | Package name | Size | Size(gzip) | Description |
 | --- | --- | --- | --- |
-| amateras | 5.64 kB | 2.48 kB | Core |
-| amateras/html | 0.97 kB | 0.25 kB | Import HTMLElement types and methods |
+| amateras | 5.67 kB | 2.52 kB | Core |
+| amateras/html | 0.99 kB | 0.26 kB | Import HTMLElement types and methods |
 | [amateras/css](./ext/css/README.md) | 3.65 kB | 1.41 kB | Style in JS |
-| [amateras/router](./ext/router/README.md) | 3.74 kB | 1.69 kB | Amateras Router |
-| [amateras/i18n](./ext/i18n/README.md) | 1.49 kB | 0.57 kB | I18n translations |
+| [amateras/router](./ext/router/README.md) | 3.79 kB | 1.71 kB | Amateras Router |
+| [amateras/i18n](./ext/i18n/README.md) | 1.48 kB | 0.58 kB | I18n translations |
+| [amateras/idb](./ext/idb/README.md) | 5.35 kB | 2.03 kB | IndexedDB Builder and API Wrapper |
+| amateras/markdown | 1.89 kB | 0.67 kB | Markdown Converter |

package/ext/html/node/$Anchor.ts

@@ -40,7 +40,7 @@ export interface $Anchor extends $HTMLElement<HTMLAnchorElement> {
     type(): string;
 }
 
-export type AnchorTarget = '_self' | '_blank' | '_parent' | '_top' | '_unfenced_top' | '';
+export type AnchorTarget = '_self' | '_blank' | '_parent' | '_top' | '_unfenced_top' | '' | '_replace';
 
 declare module '#core' {
     export function $(nodeName: 'a'): $Anchor

package/ext/html/node/$Input.ts

@@ -143,8 +143,8 @@ export interface $Input extends $HTMLElement<HTMLInputElement> {
     step(step: $Parameter<string>): this;
     step(): string;
     /** {@link HTMLInputElement.type} */
-    type(type: $Parameter<string>): this;
-    type(): string;
+    type(type: $Parameter<InputType>): this;
+    type(): InputType;
     /** {@link HTMLInputElement.value} */
     value(value: $Parameter<string>): this;
     value(): string;
@@ -162,6 +162,30 @@ export interface $Input extends $HTMLElement<HTMLInputElement> {
     width(): number;
 }
 
+export type InputType =
+  | 'button'
+  | 'checkbox'
+  | 'color'
+  | 'date'
+  | 'datetime-local'
+  | 'email'
+  | 'file'
+  | 'hidden'
+  | 'image'
+  | 'month'
+  | 'number'
+  | 'password'
+  | 'radio'
+  | 'range'
+  | 'reset'
+  | 'search'
+  | 'submit'
+  | 'tel'
+  | 'text'
+  | 'time'
+  | 'url'
+  | 'week';
+
 assignHelper(HTMLInputElement, $Input, 'input');
 
 declare module '#core' {

package/ext/html/node/$Label.ts

@@ -7,7 +7,16 @@ export class $Label extends $HTMLElement<HTMLLabelElement> {
     }
 }
 
-export interface $Label extends $HTMLElement<HTMLLabelElement> {}
+export interface $Label extends $HTMLElement<HTMLLabelElement> {
+    /** {@link HTMLLabelElement.control} */
+    readonly control: HTMLElement | null;
+    /** {@link HTMLLabelElement.form} */
+    readonly form: HTMLFormElement | null;
+    
+    /** {@link HTMLLabelElement.htmlFor} */
+    htmlFor(htmlFor: $Parameter<string>): this;
+    htmlFor(): string;
+}
 
 assignHelper(HTMLLabelElement, $Label, 'label');
 

package/ext/i18n/src/structure/I18nDictionary.ts

@@ -1,10 +1,10 @@
-import { _instanceof, isObject } from "amateras/lib/native";
+import { _instanceof, isFunction, isObject } from "amateras/lib/native";
 
 export class I18nDictionary {
     #context: I18nDictionaryContext | Promise<I18nDictionaryContext> | null = null;
     #fetch: I18nDictionaryContextImporter | null = null;
     constructor(resolver: I18nDictionaryContext | I18nDictionaryContextImporter) {
-        if (_instanceof(resolver, Function)) this.#fetch = resolver;
+        if (isFunction(resolver)) this.#fetch = resolver;
         else this.#context = resolver;
     }
 

package/ext/idb/README.md

@@ -0,0 +1,127 @@
+# amateras/idb
+
+## Usage
+```ts
+import 'amateras';
+import 'amateras/idb';
+
+// configure indexedDB
+const idb = await $.idb('MyDB', 1)
+// add store
+.store('userStore', store => store
+    .keyPath('id')
+    .autoIncrement(true)
+    // define store object type
+    .schema<{
+        id: number,
+        name: string,
+        age: number
+    }>()
+    .index('by_age', { keyPath: 'age' })
+)
+// open idb
+.open();
+
+// open `readwrite` transaction with `userStore`
+const result = await idb.store('userStore', true, async store => {
+    store.put({name: 'Amateras', age: 16});
+    return store.getAll();
+})
+
+console.log(result); // [ { name: 'Amateras', age: 16, id: 1 } ]
+```
+
+## Quick Examples
+
+### Get object from store
+```ts
+await idb.store('userStore', store => store.get(1))
+```
+
+### Get all object from store
+```ts
+await idb.store('userStore', store => store.getAll())
+```
+
+### Add object to store
+Any changes to database without `readwrite` mode is resisted, pass `true` value to `writable` argument to enable `readwrite` mode.
+``` ts
+await idb.store('userStore', true, store => store.add({name: 'Tsukimi', age: 16}))
+```
+
+### Put object to store
+The `.put()` method is different with `.add()` method, put object will replace the object of existed key.
+``` ts
+await idb.store('userStore', true, store => store.put({name: 'Amateras', age: 17}))
+```
+
+### Use index
+```ts
+await idb.store('userStore', true, store => store.index('by_age').getAll(16))
+```
+
+### Operating multiple stores in one transaction
+```ts
+await idb.transaction(['userStore', 'itemStore'], true, async transaction => {
+    transaction.store('itemStore').put({id: 2, name: 'Item 2'})
+    return {
+        users: await transaction.store('userStore').getAll(),
+        items: await transaction.store('itemStore').getAll()
+    }
+})
+```
+
+### Open cursor for advance operations
+```ts
+await idb.store('userStore', true, async store => {
+    const teenagers = []
+    await store.cursor(cursor => {
+        if (cursor.value.age < 18) teenagers.push(cursor.value);
+        cursor.continue();
+    })
+    return teenagers;
+})
+```
+
+## Upgrade Database
+Using `.upgrade()` in `$IDBStoreBuilder` can set the store upgrade handle function to list. The store upgrade function is used for change object structure when the store is upgrading. 
+
+For example, in version 10:
+```ts
+{
+    id: number,
+    name: string
+}
+```
+
+After version 11, we want to change the object structure:
+```ts
+{
+    id: string,
+    name: string,
+    intro: string
+}
+```
+
+You see the `id` is change to `string` type, and come with the new property `intro`. In the following example, we will upgrade this object structure, and this upgrade is only executed when client IDB version is lower than argument `version`.
+
+```ts
+store.upgrade(11, (objects) => {
+    return objects.map({key, value} => {
+        // since we didn't defined the object type in every different version,
+        // the object is any type, please handle the upgrade carefully
+        return { key,
+            value: {
+                ...value,
+                id: value.id.toString(), // convert to string
+                intro: `Hi, my name is ${object.name}` // add new intro property
+            }
+        }
+    })
+})
+```
+
+The upgrade function is set, this will be executed on `$IDBBuilder.open()`.
+
+> [!NOTE]
+> You should leave all the upgrade function in your codebase, unless you are sure the client database version is larger than this upgrade function.

package/ext/idb/package.json

@@ -0,0 +1,13 @@
+{
+    "name": "@amateras/idb",
+    "peerDependencies": {
+        "amateras": "../../"
+    },
+    "imports": {
+      "#structure/*": "./src/structure/*.ts",
+      "#lib/*": "./src/lib/*.ts"
+    },
+    "exports": {
+      "./core": "./src/core.ts"
+    }
+}

package/ext/idb/src/core.ts

@@ -0,0 +1,6 @@
+export * from '#structure/$IDB';
+export * from '#structure/$IDBTransaction';
+export * from '#structure/$IDBStoreBase';
+export * from '#structure/$IDBStore';
+export * from '#structure/$IDBIndex';
+export * from '#structure/$IDBCursor';

package/ext/idb/src/index.ts

@@ -0,0 +1,17 @@
+import { _Object_assign } from "amateras/lib/native"
+import { $IDBBuilder } from "#structure/builder/$IDBBuilder"
+
+declare module 'amateras/core' {
+    export namespace $ {
+        /**
+         * Create {@link $IDBBuilder} with IDB name and version number.
+         * @param name - Database name
+         * @param version - Version number
+         */
+        export function idb<N extends string, V extends number>(name: N, version: V): $IDBBuilder<{name: N, version: V, stores: {}}>;
+    }
+}
+
+_Object_assign($, {
+    idb: (name: string, version: number) => new $IDBBuilder({name, version, stores: {}})
+})

package/ext/idb/src/lib/$IDBRequest.ts

@@ -0,0 +1,8 @@
+import { _Promise } from "../../../../src/lib/native";
+
+export const $IDBRequest = <T>(req: IDBRequest<T>, handle?: (req: IDBRequest<T>, resolve: (value: T) => void) => void) => {
+    return new _Promise<T>((resolve, reject) => {
+        req.onsuccess = _ => handle ? handle(req, resolve) : resolve(req.result);
+        req.onerror = _ => reject(req.error);
+    })
+}

package/ext/idb/src/structure/$IDB.ts

@@ -0,0 +1,63 @@
+import { _Array_from, _null, _Object_assign, _Object_fromEntries, _Promise, isBoolean } from "amateras/lib/native";
+import { $IDBStore, type $IDBStoreConfig } from "./$IDBStore";
+import { $IDBTransaction } from "./$IDBTransaction";
+
+export interface $IDB<Config extends $IDBConfig = any> {
+    /** Object with store name key and `$IDBStoreConfig` value. */
+    readonly stores: Config['stores'];
+}
+export class $IDB<Config extends $IDBConfig = any> {
+    /** {@link IDBDatabase} instance. */
+    readonly idb: IDBDatabase;
+    /** IndexedDB database name. */
+    readonly name: Config['name'];
+    /** IndexedDB database version. */
+    readonly version: Config['version'];
+    constructor(idb: IDBDatabase, config: Omit<Config, 'name' | 'version'>) {
+        this.idb = idb;
+        this.name = idb.name;
+        this.version = idb.version;
+        _Object_assign(this, config);
+    }
+
+    /**
+     * Create new transaction with the store name, you can directly operating the target store with `handle` function. This method will return a `Promise` with the `handle` return type value.
+     * @param name - Store name
+     * @param writable - Enable readwrite mode
+     * @param handle - Function execute on transaction opened
+     * @returns The handle function return type
+     */
+    async store<K extends keyof Config['stores'] & string, T>(name: K, handle: (store: $IDBStore<Config['stores'][K]>) => T): Promise<T>
+    async store<K extends keyof Config['stores'] & string, T>(name: K, writable: boolean, handle: (store: $IDBStore<Config['stores'][K]>) => T): Promise<T>
+    async store<K extends keyof Config['stores'] & string, T>(name: K, resolver: boolean | Function, handle?: Function) {
+        if (isBoolean(resolver)) return this.transaction(name, resolver, $tx => handle!($tx.store(name)));
+        else return this.transaction(name, $tx => resolver($tx.store(name)))
+    }
+
+    /** 
+     * Create new transaction with the store name, you can pass multiple store name into `storeName` argument for operating multiple store in one transaction.
+     * @param store - Store name, allow string array
+     * @param writable - Enable readwrite mode
+     * @param handle - Function execute on transaction opened
+     * @returns The handle function return type
+     */
+    async transaction<K extends keyof Config['stores'] & string, T>(store: K | K[], handle: (transaction: $IDBTransaction<{ stores: Pick<Config['stores'], K> }>) => T): Promise<T>
+    async transaction<K extends keyof Config['stores'] & string, T>(store: K | K[], writable: boolean, handle: (transaction: $IDBTransaction<{ stores: Pick<Config['stores'], K> }>) => T): Promise<T>
+    async transaction<K extends keyof Config['stores'] & string, T>(store: K | K[], resolver?: boolean | Function, handle?: Function) {
+        handle = isBoolean(resolver) ? handle : resolver;
+        resolver = isBoolean(resolver) ? resolver : false;
+        const tx = this.idb.transaction(store, resolver ? 'readwrite' : 'readonly');
+        const $tx = new $IDBTransaction(this, tx);
+        const result = handle!($tx);
+        return new _Promise<T>((resolve, reject) => {
+            tx.oncomplete = _ => resolve(result);
+            tx.onerror = tx.onabort = _ => tx.error && reject(tx.error);
+        })
+    }
+}
+
+export type $IDBConfig = {
+    name: string;
+    version: number;
+    stores: { [key: string]: $IDBStoreConfig }
+}

package/ext/idb/src/structure/$IDBCursor.ts

@@ -0,0 +1,34 @@
+import { _instanceof, _Object_assign, _Promise } from "amateras/lib/native";
+import { $IDBRequest } from "#lib/$IDBRequest";
+import { $IDBStore, type $IDBStoreConfig } from "./$IDBStore";
+import { $IDBIndex } from "./$IDBIndex";
+import type { $IDBStoreBase } from "./$IDBStoreBase";
+
+export interface $IDBCursor {}
+export class $IDBCursor<StoreConfig extends $IDBStoreConfig = any> {
+    #cursor: IDBCursorWithValue;
+    readonly store: $IDBStore<StoreConfig>;
+    readonly direction;
+    constructor(store: $IDBStoreBase, cursor: IDBCursorWithValue) {
+        this.#cursor = cursor;
+        this.store = _instanceof(store, $IDBIndex<StoreConfig>) ? store.store : store as $IDBStore;
+        this.direction = cursor.direction;
+    }
+
+    get value() { return this.#cursor.value }
+    get key() { return this.#cursor.key }
+    get primaryKey() { return this.#cursor.primaryKey }
+
+    async update<T>(value: T) {
+        return $IDBRequest(this.#cursor.update(value))
+    }
+
+    async delete() {
+        return $IDBRequest(this.#cursor.delete())
+    }
+
+    continue(key?: IDBValidKey) { this.#cursor.continue(key) }
+    continuePrimaryKey(key: IDBValidKey, primaryKey: IDBValidKey) { this.#cursor.continuePrimaryKey(key, primaryKey) }
+    advance(count: number) { this.#cursor.advance(count) }
+    abort() { this.#cursor.request.transaction?.abort() }
+}

package/ext/idb/src/structure/$IDBIndex.ts

@@ -0,0 +1,48 @@
+import { _Object_assign } from "amateras/lib/native";
+import type { $IDBStore, $IDBStoreConfig, QueryMultipleKeyPath } from "./$IDBStore";
+import { $IDBStoreBase } from "./$IDBStoreBase";
+import type { $IDBCursor } from "./$IDBCursor";
+
+export class $IDBIndex<StoreConfig extends $IDBStoreConfig = any, Config extends $IDBIndexConfig = any> extends $IDBStoreBase{
+    readonly store: $IDBStore;
+    constructor(store: $IDBStore, index: IDBIndex, config: Config) {
+        super(index);
+        this.store = store;
+        _Object_assign(this, config);
+    }
+}
+
+export interface $IDBIndex<StoreConfig extends $IDBStoreConfig, Config extends $IDBIndexConfig = any> {
+    readonly unique: Config['unique'];
+    readonly multiEntry: Config['multiEntry'];
+    readonly keyPath: Config['keyPath'];
+    
+    /** {@link IDBIndex.cursor} */
+    cursor(handle: (cursor: $IDBCursor) => void, query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): Promise<null>
+
+    /** {@link IDBIndex.keyCursor} */
+    keyCursor(handle: (cursor: $IDBCursor) => void, query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): Promise<null>
+
+    /** {@link IDBIndex.count} */
+    count(query?: $IDBIndexKey<StoreConfig, Config> | IDBKeyRange): Promise<number>;
+
+    /** {@link IDBIndex.get} */
+    get(query: $IDBIndexKey<StoreConfig, Config> | IDBKeyRange): Promise<StoreConfig['schema']>
+
+    /** {@link IDBIndex.getAll} */
+    getAll(query?: $IDBIndexKey<StoreConfig, Config> | IDBKeyRange): Promise<StoreConfig['schema'][]>
+}
+
+export type $IDBIndexConfig = {
+    unique: boolean;
+    multiEntry: boolean;
+    keyPath: string | string[];
+    name: string;
+}
+
+export type $IDBIndexKey<StoreConfig extends $IDBStoreConfig, Config extends $IDBIndexConfig> = 
+    Config['keyPath'] extends string
+    ?   StoreConfig['schema'][Config['keyPath']]
+    :   Config['keyPath'] extends string[]
+        ?   QueryMultipleKeyPath<Config['keyPath'], StoreConfig>
+        :   IDBValidKey;

package/ext/idb/src/structure/$IDBStore.ts

@@ -0,0 +1,103 @@
+import { _instanceof, _Object_assign, _Promise } from "amateras/lib/native";
+import { $IDBIndex, type $IDBIndexConfig } from "./$IDBIndex";
+import { $IDBRequest } from "#lib/$IDBRequest";
+import { $IDBStoreBase } from "./$IDBStoreBase";
+import type { $IDBCursor } from "./$IDBCursor";
+
+export class $IDBStore<Config extends $IDBStoreConfig = any> extends $IDBStoreBase {
+    #store: IDBObjectStore;
+    constructor(store: IDBObjectStore, config: Config) {
+        super(store);
+        this.#store = store;
+        _Object_assign(this, config);
+    }
+
+    /** {@link IDBObjectStore.put} */
+    put<V extends $IDBStoreValueResolver<Config>>(...value: V): Promise<$IDBStoreKey<Config>>
+    put(value: any, key?: any) {
+        return $IDBRequest(this.#store.put(value, key));
+    }
+
+    /** {@link IDBObjectStore.add} */
+    add<V extends $IDBStoreValueResolver<Config>>(value: V): Promise<$IDBStoreKey<Config>>
+    add(value: any, key?: any) {
+        return $IDBRequest(this.#store.add(value, key));
+    }
+
+    /** {@link IDBObjectStore.delete} */
+    delete(query: $IDBStoreKey<Config> | IDBKeyRange): Promise<undefined>;
+    delete(query: IDBValidKey | IDBKeyRange) {
+        return $IDBRequest(this.#store.delete(query));
+    }
+
+    /** {@link IDBObjectStore.clear} */
+    clear() {
+        return $IDBRequest(this.#store.clear())
+    }
+
+    /** Get and return {@link $IDBIndex} */
+    index<K extends keyof Config['indexes'] & string>(name: K): $IDBIndex<Config, Config['indexes'][K]>
+    index(name: keyof Config['indexes'] & string) {
+        return new $IDBIndex(this, this.#store.index(name), this.indexes[name]!)
+    }
+}
+
+export interface $IDBStore<Config extends $IDBStoreConfig = any> {
+    readonly name: Config['name'];
+    readonly indexes: Config['indexes'];
+    readonly schema: Config['schema'];
+    readonly keyPath: Config['keyPath'];
+    readonly autoIncrement: Config['autoIncrement'];
+
+    /** {@link IDBObjectStore.cursor} */
+    cursor(handle: (cursor: $IDBCursor) => void, query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): Promise<null>
+
+    /** {@link IDBObjectStore.keyCursor} */
+    keyCursor(handle: (cursor: $IDBCursor) => void, query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection): Promise<null>
+
+    /** {@link IDBObjectStore.count} */
+    count(query?: $IDBStoreKey<Config> | IDBKeyRange): Promise<number>;
+
+    /** {@link IDBObjectStore.get} */
+    get(query: $IDBStoreKey<Config> | IDBKeyRange): Promise<Config['schema']>
+
+    /** {@link IDBObjectStore.getAll} */
+    getAll(query?: $IDBStoreKey<Config> | IDBKeyRange): Promise<Config['schema'][]>
+}
+
+export type $IDBStoreConfig = {
+    name: string;
+    indexes: { [key: string]: $IDBIndexConfig };
+    schema: any;
+    keyPath: string | string[] | null;
+    autoIncrement: boolean;
+}
+
+export type $IDBStoreValueResolver<Config extends $IDBStoreConfig> = 
+Config['keyPath'] extends string
+    ?   Config['autoIncrement'] extends true
+        ?   [Omit<Config['schema'], Config['keyPath']> & {[key in Config['keyPath']]?: Config['schema'][key]}]
+        :   [Config['schema']]
+    :   Config['keyPath'] extends string[]
+        ?   [Config['schema']] 
+        :   Config['autoIncrement'] extends true 
+            ?   [Config['schema']] 
+            :   [Config['schema'], IDBValidKey];
+
+export type $IDBStoreKey<Config extends $IDBStoreConfig> = 
+    Config['keyPath'] extends string
+        ?   Config['schema'][Config['keyPath']]
+        :   Config['keyPath'] extends string[]
+            ?   QueryMultipleKeyPath<Config['keyPath'], Config>
+            :   Config['autoIncrement'] extends true
+                ?   number
+                :   IDBValidKey;
+
+export type QueryMultipleKeyPath<T extends string[], Config extends { schema: {} }> = 
+    T extends [infer A, ...infer Rest]
+    ?   A extends keyof Config['schema']
+        ?   Rest extends string[]
+            ?   [Config['schema'][A], ...QueryMultipleKeyPath<Rest, Config>]
+            :   [Config['schema'][A]]
+        :   never
+    : []

package/ext/idb/src/structure/$IDBStoreBase.ts

@@ -0,0 +1,30 @@
+import { _Array_from, _instanceof, _null, _Promise } from "amateras/lib/native";
+import { $IDBRequest } from "#lib/$IDBRequest";
+import { $IDBCursor } from "./$IDBCursor";
+
+export abstract class $IDBStoreBase {
+    readonly #instance;
+    constructor(instance: IDBObjectStore | IDBIndex) {
+        this.#instance = instance;
+    }
+
+    cursor(handle: (cursor: $IDBCursor) => void, query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection) {
+        return $IDBRequest(this.#instance.openCursor(query, direction), (req , resolve) => req.result ? handle(new $IDBCursor(this, req.result)) : resolve(null))
+    }
+
+    keyCursor(handle: (cursor: $IDBCursor) => void, query?: IDBValidKey | IDBKeyRange | null, direction?: IDBCursorDirection) {
+        return $IDBRequest(this.#instance.openCursor(query, direction), (req , resolve) => req.result ? handle(new $IDBCursor(this, req.result)) : resolve(null))
+    }
+
+    count(query?: IDBValidKey | IDBKeyRange) {
+        return $IDBRequest(this.#instance.count(query));
+    }
+
+    get(query: IDBValidKey | IDBKeyRange) {
+        return $IDBRequest(this.#instance.get(query))
+    }
+
+    getAll(query?: IDBValidKey | IDBKeyRange) {
+        return $IDBRequest(this.#instance.getAll(query))
+    }
+}

package/ext/idb/src/structure/$IDBTransaction.ts

@@ -0,0 +1,38 @@
+import { _Array_from, _Object_assign, forEach } from "../../../../src/lib/native";
+import type { $IDB } from "./$IDB";
+import { $IDBStore, type $IDBStoreConfig } from "./$IDBStore";
+
+export interface $IDBTransaction {}
+export class $IDBTransaction<Config extends $IDBTransactionConfig = any> {
+    #transaction: IDBTransaction;
+    #$idb: $IDB
+    readonly writable: boolean;
+    readonly stores: Config['stores'] = {};
+    readonly durability: string;
+    constructor($idb: $IDB, transaction: IDBTransaction) {
+        this.#transaction = transaction;
+        this.#$idb = $idb;
+        this.writable = transaction.mode !== 'readonly';
+        this.durability = transaction.durability;
+        forEach(_Array_from(transaction.objectStoreNames), name => {
+            _Object_assign(this.stores, { [name]: $idb.stores[name] })
+        })
+    }
+
+    store<N extends keyof Config['stores'] & string>(name: N): $IDBStore<Config['stores'][N]>
+    store(name: string) {
+        return new $IDBStore(this.#transaction.objectStore(name), this.#$idb.stores[name]);
+    }
+
+    commit() {
+        return this.#transaction.commit();
+    }
+
+    abort() {
+        return this.#transaction.abort();
+    }
+}
+
+export type $IDBTransactionConfig = {
+    stores: { [key: string]: $IDBStoreConfig }
+}