amateras 0.7.4 → 0.10.0

package/packages/i18n/README.md

@@ -1,73 +0,0 @@
-# amateras/i18n
-
-## Usage
-```ts
-import 'amateras';
-import 'amateras/i18n';
-
-const $t = $.i18n()
-// add 'en' locale dictionary context
-.add('en', {
-    homepage: {
-        _: 'Home',
-        hello: 'Hello, $name$!',
-    }
-})
-// set 'en' as locale language
-.locale('en')
-
-$(document.body).content([
-    $('h1').content( $t('homepage') )
-    // <h1><text>Home</text></h1>
-    $t('homepage.hello', {name: 'Amateras'}) 
-    // <text>Hello, Amateras!</text>
-])
-```
-
-## Change Language
-```ts
-$t.locale('zh')
-// all translation text will be updated
-```
-
-## Import Dictionary Context
-
-```ts
-// ./i18n/en.ts
-export default {
-    hello: 'Hello, $name$!'
-}
-
-// ./i18n/zh.ts
-export default {
-    hello: '您好，$name$！'
-}
-
-// ./entry_file.ts
-const $t = $.i18n()
-.add('en', () => import('./i18n/en.ts'))
-.add('zh', () => import('./i18n/zh.ts'))
-// set 'zh' as locale language
-// and fetch file automatically from path
-.locale('zh');
-```
-
-## Directory Shortcut
-
-```ts
-const $t = $.i18n('en')
-.add('en', {
-    page1: {
-        section2: {
-            button3: {
-                text: 'Too deep!'
-            }
-        }
-    }
-})
-
-const $t_button = $t.dir('page1.section2.button3');
-
-$t_button('text') // Too deep!
-$t('page1.section2.button3.text') // Too deep!
-```

package/packages/i18n/package.json

@@ -1,19 +0,0 @@
-{
-    "name": "@amateras/i18n",
-    "peerDependencies": {
-      "@amateras/core": "workspace:*",
-      "@amateras/signal": "workspace:*",
-      "@amateras/utils": "workspace:*"
-    },
-    "imports": {
-      "#structure/*": "./src/structure/*.ts",
-      "#lib/*": "./src/lib/*.ts",
-      "#node/*": "./src/node/*.ts"
-    },
-    "exports": {
-      ".": "./src/index.ts",
-      "./structure/*": "./src/structure/*.ts",
-      "./lib/*": "./src/lib/*.ts",
-      "./node/*": "./src/node/*.ts"
-    }
-}

package/packages/i18n/src/index.ts

@@ -1,140 +0,0 @@
-import "@amateras/core"
-import { _Array_from, _instanceof, _Object_assign } from "@amateras/utils"
-import { I18n } from "#structure/I18n"
-import { I18nDictionary, type I18nDictionaryContext, type I18nDictionaryContextImporter } from "#structure/I18nDictionary";
-import { $Node, type $NodeContentResolver } from "@amateras/core/node/$Node";
-import { I18nTranslation as _I18nTranslation, I18nTranslation, type I18nTranslationOptions } from "#structure/I18nTranslation";
-
-$Node.setters.add((value, set) => {
-    if (_instanceof(value, _I18nTranslation)) {
-        value.content$.signal.subscribe(set);
-        return value.content$.value();
-    }
-})
-
-_Object_assign($, {
-    i18n(defaultLocale: string) {
-        const i18n = new I18n(defaultLocale);
-        const i18nFn = (key: string, options?: I18nTranslationOptions) => i18n.translate(key, options);
-        _Object_assign(i18nFn, { 
-            i18n,
-            locale(locale: string) {
-                if (!arguments.length) return i18n.locale();
-                i18n.locale(locale);
-                return this;
-            },
-            add(lang: string, context: I18nDictionaryContext | I18nDictionaryContextImporter) {
-                i18n.map.set(lang, new I18nDictionary(context));
-                return this;
-            },
-            delete(lang: string) {
-                i18n.map.delete(lang);
-                return this;
-            },
-            dir(path: string) {
-                return (key: string, options?: I18nTranslationOptions) => i18n.translate(`${path}.${key}`, options)
-            }
-        })
-        return i18nFn
-    }
-})
-
-type ResolvedAsyncDictionary<F extends I18nDictionaryContextImporter> = Awaited<ReturnType<F>>['default'];
-
-type I18nTranslationKey<T> = 
-    T extends I18nDictionaryContext
-    ?   {
-            [K in keyof T]: K extends string
-            ?   K extends '_' 
-                ?   never 
-                :   T[K] extends string
-                    ?   `${K}`
-                    :   '_' extends keyof T[K]
-                        ?   `${K}` | `${K}.${I18nTranslationKey<T[K]>}`
-                        :   `${K}.${I18nTranslationKey<T[K]>}`
-            :   never;
-        }[keyof T]
-    :   never;
-
-type I18nTranslationDirKey<T> = 
-    T extends I18nDictionaryContext
-    ?   {
-            [K in keyof T]: K extends string
-            ?   T[K] extends string 
-                ?   never
-                :   `${K}` | `${K}.${I18nTranslationDirKey<T[K]>}`
-            :   never;
-        }[keyof T]
-    :   never;
-
-type I18nTranslationParams<K extends string, T extends I18nDictionaryContext> = 
-    FindTranslationByKey<K, T> extends infer O
-    ?   O extends string
-        ?   FindParam<O>
-        :   never
-    :   never
-
-type FindParam<T extends string> = 
-    T extends `${string}$${infer Param}$${infer Rest}`
-    ?   Param extends `${string}${' '}${string}`
-        ?   Prettify<{} & FindParam<Rest>>
-        :   Prettify<Record<Param, $NodeContentResolver<I18nTranslation>> & FindParam<Rest>>
-    :   {}
-
-type FindTranslationByKey<K extends string, T extends I18nDictionaryContext> = 
-    K extends `${infer Prefix}.${infer Rest}`
-    ?   Prefix extends keyof T
-        ?   T[Prefix] extends I18nDictionaryContext
-            ?   FindTranslationByKey<Rest, T[Prefix]>
-            :   T[Prefix]
-        :   ''
-    :   T[K] extends object
-        ?   '_' extends keyof T[K]
-            ?   T[K]['_']
-            :   never
-        :   T[K]
-
-type GetDictionaryContextByKey<K extends string, T extends I18nDictionaryContext> =
-    K extends `${infer Prefix}.${infer Rest}`
-    ?   Prefix extends keyof T
-        ?   T[Prefix] extends I18nDictionaryContext
-            ?   GetDictionaryContextByKey<Rest, T[Prefix]>
-            :   never
-        :   never
-    :   T[K] extends object
-        ?   T[K]
-        :   never
-
-type Mixin<A, B> = 
-    (Omit<A, keyof B> & Omit<B, keyof A>) & {
-        [key in (keyof A & keyof B)]: 
-            A[key] extends object
-            ?   B[key] extends object
-                ?   Mixin<A[key], B[key]>
-                :   A[key] | B[key]
-            :   A[key] | B[key]  
-    }
-
-declare module "@amateras/core" {
-    export namespace $ {
-        export interface I18nFunction<D extends I18nDictionaryContext = {}> {
-            <K extends I18nTranslationKey<D>, P extends I18nTranslationParams<K, D>>(path: K, ...params: P extends Record<string, never> ? [] : [P]): I18nTranslation;
-            i18n: I18n;
-            locale(): string;
-            locale(lang?: $Parameter<string>): this;
-            add<F extends I18nDictionaryContext | I18nDictionaryContextImporter>(lang: string, dictionary: F): I18nFunction<Mixin<D, (F extends I18nDictionaryContextImporter ? ResolvedAsyncDictionary<F> : F)>>;
-            delete(lang: string): this;
-            dir<K extends I18nTranslationDirKey<D>>(path: K): I18nFunction<GetDictionaryContextByKey<K, D>>
-        }
-        export function i18n(defaultLocale: string): I18nFunction;
-        export type I18nTranslation = _I18nTranslation;
-
-        export interface $NodeContentMap {
-            i18n: I18nTranslation
-        }
-
-        export interface $NodeParameterMap<T> {
-            i18n: I18nTranslation
-        }
-    }
-}

package/packages/i18n/src/structure/I18n.ts

@@ -1,44 +0,0 @@
-import '@amateras/signal';
-import { _instanceof, _null } from "@amateras/utils";
-import { I18nDictionary } from "#structure/I18nDictionary";
-import { I18nTranslation, type I18nTranslationOptions } from "./I18nTranslation";
-
-export class I18n {
-    locale$ = $.signal<string>('');
-    map = new Map<string, I18nDictionary>();
-    #defaultLocale: string;
-    constructor(defaultLocale: string) {
-        this.#defaultLocale = defaultLocale;
-        this.locale$.set(defaultLocale);
-    }
-
-    defaultLocale(): string;
-    defaultLocale(locale: string): this;
-    defaultLocale(locale?: string) {
-        if (!arguments.length) return this.#defaultLocale;
-        if (locale) this.locale$.set(locale);
-        return this;
-    }
-
-    locale(): string;
-    locale(locale: string): this;
-    locale(locale?: string) {
-        if (!arguments.length) return this.locale$.value();
-        if (locale) {
-            if (!this.map.has(locale)) locale = locale.split('-')[0]!;
-            if (this.map.has(locale)) this.locale$.set(locale)
-        }
-        return this;
-    }
-
-    dictionary(locale = this.locale$.value()) {
-        if (!locale) return _null;
-        const dictionary = this.map.get(locale);
-        return dictionary;
-    }
-
-    translate(key: string, options?: I18nTranslationOptions) {
-        return new I18nTranslation(this, key, options);
-    }
-}
-

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

@@ -1,31 +0,0 @@
-import { _instanceof, isFunction, isObject } from "@amateras/utils";
-
-export class I18nDictionary {
-    #context: I18nDictionaryContext | Promise<I18nDictionaryContext> | null = null;
-    #fetch: I18nDictionaryContextImporter | null = null;
-    constructor(resolver: I18nDictionaryContext | I18nDictionaryContextImporter) {
-        if (isFunction(resolver)) this.#fetch = resolver;
-        else this.#context = resolver;
-    }
-
-    async context(): Promise<I18nDictionaryContext> {
-        if (this.#context) return await this.#context;
-        if (!this.#fetch) throw 'I18n Context Fetch Error';
-        return this.#context = this.#fetch().then((module) => module.default);
-    }
-
-    async find(path: string, context?: I18nDictionaryContext): Promise<string | undefined> {
-        if (!context) context = await this.context();
-        const [snippet, ...rest] = path.split('.') as [string, ...string[]];
-        const target = context[snippet];
-        if (isObject(target)) {
-            if (rest.length) return this.find(rest.join('.'), target);
-            else return target['_'] as string;
-        } 
-        if (rest.length) return path;
-        else return target;
-    }
-}
-
-export type I18nDictionaryContext = {[key: string]: string | I18nDictionaryContext}
-export type I18nDictionaryContextImporter = () => Promise<{default: I18nDictionaryContext}>

package/packages/i18n/src/structure/I18nTranslation.ts

@@ -1,41 +0,0 @@
-import { _Array_from, _null, isUndefined } from "@amateras/utils";
-import type { I18n } from "#structure/I18n";
-import { $Node, type $NodeContentResolver, type $NodeContentTypes } from "@amateras/core/node/$Node";
-import { $HTMLElement } from "@amateras/core/node/$HTMLElement";
-
-export class I18nTranslation extends $HTMLElement {
-    i18n: I18n;
-    key: string;
-    options: I18nTranslationOptions | undefined;
-    content$ = $.signal('');
-    constructor(i18n: I18n, key: string, options?: I18nTranslationOptions) {
-        super('t')
-        this.i18n = i18n;
-        this.key = key;
-        this.options = options;
-        i18n.locale$.signal.subscribe(() => this.update())
-        this.update();
-    }
-    
-    async update() {
-        const {key, i18n, options} = this;
-        const contentUpdate = (content: $NodeContentResolver<this>) => {
-            this.content(content);
-            this.content$.set(this.textContent() ?? '')
-        }
-        update: {
-            const dictionary = i18n.dictionary();
-            if (!dictionary) { contentUpdate(key); break update }
-            const target = await dictionary.find(key);
-            if (isUndefined(target)) break update;
-            const snippets = target.split(/\$[a-zA-Z0-9_]+\$/);
-            if (snippets.length === 1 || !options) { contentUpdate(target); break update }
-            const matches = target.matchAll(/(\$([a-zA-Z0-9_]+)\$)/g);
-            const content = snippets.map(text => [text, options[matches.next().value?.at(2)!] ?? null]).flat();
-            contentUpdate(content);
-        }
-        return this;
-    }
-}
-
-export type I18nTranslationOptions = {[key: string]: any}

package/packages/idb/README.md

@@ -1,127 +0,0 @@
-# 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/packages/idb/package.json

@@ -1,19 +0,0 @@
-{
-    "name": "@amateras/idb",
-    "peerDependencies": {
-      "@amateras/core": "workspace:*",
-      "@amateras/signal": "workspace:*",
-      "@amateras/utils": "workspace:*"
-    },
-    "imports": {
-      "#structure/*": "./src/structure/*.ts",
-      "#lib/*": "./src/lib/*.ts",
-      "#node/*": "./src/node/*.ts"
-    },
-    "exports": {
-      ".": "./src/index.ts",
-      "./structure/*": "./src/structure/*.ts",
-      "./lib/*": "./src/lib/*.ts",
-      "./node/*": "./src/node/*.ts"
-    }
-}

package/packages/idb/src/core.ts

@@ -1,6 +0,0 @@
-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/packages/idb/src/index.ts

@@ -1,17 +0,0 @@
-import { _Object_assign } from "@amateras/utils"
-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/packages/idb/src/lib/$IDBRequest.ts

@@ -1,8 +0,0 @@
-import { _Promise } from "@amateras/utils";
-
-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/packages/idb/src/structure/$IDB.ts

@@ -1,63 +0,0 @@
-import { _Array_from, _null, _Object_assign, _Object_fromEntries, _Promise, isBoolean } from "@amateras/utils";
-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/packages/idb/src/structure/$IDBCursor.ts

@@ -1,34 +0,0 @@
-import { _instanceof, _Object_assign, _Promise } from "@amateras/utils";
-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/packages/idb/src/structure/$IDBIndex.ts

@@ -1,48 +0,0 @@
-import { _Object_assign } from "@amateras/utils";
-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;