@anfenn/dync 1.0.0

package/dist/dexie-DJFApKsM.d.ts

@@ -0,0 +1,444 @@
+import dexie from 'dexie';
+import { d as StorageSchemaDefinitionOptions, S as SQLiteDatabaseDriver, e as SQLiteAdapterOptions, a as SQLiteRunResult, b as SQLiteQueryResult } from './types-CSbIAfu2.js';
+
+type TableSchemaDefinition = string | SQLiteTableDefinition;
+interface SQLiteTableDefinition {
+    columns: Record<string, SQLiteColumnDefinition>;
+    indexes?: SQLiteIndexDefinition[];
+    tableConstraints?: string[];
+    withoutRowId?: boolean;
+    strict?: boolean;
+}
+interface SQLiteColumnDefinition {
+    type?: string;
+    length?: number;
+    nullable?: boolean;
+    unique?: boolean;
+    default?: SQLiteDefaultValue;
+    check?: string;
+    references?: SQLiteForeignKeyReference | string;
+    collate?: string;
+    generatedAlwaysAs?: string;
+    stored?: boolean;
+    constraints?: string[];
+}
+type SQLiteDefaultValue = string | number | boolean | null;
+interface SQLiteForeignKeyReference {
+    table: string;
+    column?: string;
+    onDelete?: SQLiteForeignKeyAction;
+    onUpdate?: SQLiteForeignKeyAction;
+    match?: string;
+}
+type SQLiteForeignKeyAction = 'SET NULL' | 'SET DEFAULT' | 'RESTRICT' | 'NO ACTION' | 'CASCADE';
+interface SQLiteIndexDefinition {
+    name?: string;
+    columns: string[];
+    unique?: boolean;
+    where?: string;
+    collate?: string;
+    orders?: Array<'ASC' | 'DESC'>;
+}
+
+declare class DexieQueryContext {
+    private readonly adapter;
+    constructor(adapter: DexieAdapter);
+    table<T = any>(name: string): StorageTable<T>;
+    transaction<T>(mode: TransactionMode, tableNames: string[], callback: (context: StorageTransactionContext) => Promise<T>): Promise<T>;
+}
+
+interface MemoryRecord {
+    _localId?: string;
+    id?: unknown;
+    updated_at?: string;
+    [key: string]: unknown;
+}
+interface MemoryCollectionState<T extends MemoryRecord> {
+    predicate: (record: T, key: string) => boolean;
+    orderBy?: {
+        index: string | string[];
+        direction: 'asc' | 'desc';
+    };
+    reverse: boolean;
+    offset: number;
+    limit?: number;
+    distinct: boolean;
+}
+
+declare class MemoryCollection<T extends MemoryRecord = MemoryRecord> implements StorageCollection<T> {
+    private readonly table;
+    private readonly state;
+    constructor(table: MemoryTable<T>, state: MemoryCollectionState<T>);
+    getState(): MemoryCollectionState<T>;
+    matches(record: T, key: string): boolean;
+    clone(_props?: Record<string, unknown>): StorageCollection<T>;
+    reverse(): StorageCollection<T>;
+    offset(offset: number): StorageCollection<T>;
+    limit(count: number): StorageCollection<T>;
+    toCollection(): StorageCollection<T>;
+    distinct(): StorageCollection<T>;
+    jsFilter(predicate: (item: T) => boolean): StorageCollection<T>;
+    or(index: string): StorageWhereClause<T>;
+    first(): Promise<T | undefined>;
+    last(): Promise<T | undefined>;
+    each(callback: (item: T, index: number) => void | Promise<void>): Promise<void>;
+    eachKey(callback: (key: unknown, index: number) => void | Promise<void>): Promise<void>;
+    eachPrimaryKey(callback: (key: unknown, index: number) => void | Promise<void>): Promise<void>;
+    eachUniqueKey(callback: (key: unknown, index: number) => void | Promise<void>): Promise<void>;
+    keys(): Promise<unknown[]>;
+    primaryKeys(): Promise<unknown[]>;
+    uniqueKeys(): Promise<unknown[]>;
+    count(): Promise<number>;
+    sortBy(key: string): Promise<T[]>;
+    delete(): Promise<number>;
+    modify(changes: Partial<T> | ((item: T) => void | Promise<void>)): Promise<number>;
+    toArray(): Promise<T[]>;
+    private withState;
+    private combinePredicate;
+    private materializeEntries;
+}
+
+declare class MemoryWhereClause<T extends MemoryRecord = MemoryRecord> implements StorageWhereClause<T> {
+    private readonly table;
+    private readonly index;
+    private readonly baseCollection?;
+    constructor(table: MemoryTable<T>, index: string | string[], baseCollection?: MemoryCollection<T>);
+    equals(value: any): StorageCollection<T>;
+    above(value: any): StorageCollection<T>;
+    aboveOrEqual(value: any): StorageCollection<T>;
+    below(value: any): StorageCollection<T>;
+    belowOrEqual(value: any): StorageCollection<T>;
+    between(lower: any, upper: any, includeLower?: boolean, includeUpper?: boolean): StorageCollection<T>;
+    inAnyRange(ranges: Array<[any, any]>, options?: {
+        includeLower?: boolean;
+        includeUpper?: boolean;
+    }): StorageCollection<T>;
+    startsWith(prefix: string): StorageCollection<T>;
+    startsWithIgnoreCase(prefix: string): StorageCollection<T>;
+    startsWithAnyOf(...prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOf(prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOfIgnoreCase(...prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOfIgnoreCase(prefixes: string[]): StorageCollection<T>;
+    equalsIgnoreCase(value: string): StorageCollection<T>;
+    anyOf(...values: any[]): StorageCollection<T>;
+    anyOf(values: any[]): StorageCollection<T>;
+    anyOfIgnoreCase(...values: string[]): StorageCollection<T>;
+    anyOfIgnoreCase(values: string[]): StorageCollection<T>;
+    noneOf(...values: any[]): StorageCollection<T>;
+    noneOf(values: any[]): StorageCollection<T>;
+    notEqual(value: any): StorageCollection<T>;
+    private createCollection;
+    private flattenArgs;
+}
+
+declare class MemoryTable<T extends MemoryRecord = MemoryRecord> implements StorageTable<T> {
+    readonly name: string;
+    readonly schema: unknown;
+    readonly primaryKey: unknown;
+    readonly hook: unknown;
+    readonly raw: {
+        add: (item: T) => Promise<unknown>;
+        put: (item: T) => Promise<unknown>;
+        update: (key: unknown, changes: Partial<T>) => Promise<number>;
+        delete: (key: unknown) => Promise<void>;
+        get: (key: unknown) => Promise<T | undefined>;
+        bulkAdd: (items: T[]) => Promise<unknown>;
+        bulkPut: (items: T[]) => Promise<unknown>;
+        bulkUpdate: (keysAndChanges: Array<{
+            key: unknown;
+            changes: Partial<T>;
+        }>) => Promise<number>;
+        bulkDelete: (keys: Array<unknown>) => Promise<void>;
+        clear: () => Promise<void>;
+    };
+    private readonly records;
+    constructor(name: string);
+    add(item: T): Promise<unknown>;
+    put(item: T): Promise<unknown>;
+    update(key: unknown, changes: Partial<T>): Promise<number>;
+    delete(key: unknown): Promise<void>;
+    clear(): Promise<void>;
+    private baseClear;
+    get(key: unknown): Promise<T | undefined>;
+    toArray(): Promise<T[]>;
+    count(): Promise<number>;
+    bulkAdd(items: T[]): Promise<unknown>;
+    private baseBulkAdd;
+    bulkPut(items: T[]): Promise<unknown>;
+    private baseBulkPut;
+    bulkGet(keys: Array<unknown>): Promise<Array<T | undefined>>;
+    bulkUpdate(keysAndChanges: Array<{
+        key: unknown;
+        changes: Partial<T>;
+    }>): Promise<number>;
+    private baseBulkUpdate;
+    bulkDelete(keys: Array<unknown>): Promise<void>;
+    private baseBulkDelete;
+    where(index: string | string[]): StorageWhereClause<T>;
+    orderBy(index: string | string[]): StorageCollection<T>;
+    reverse(): StorageCollection<T>;
+    offset(offset: number): StorageCollection<T>;
+    limit(count: number): StorageCollection<T>;
+    mapToClass(_ctor: new (...args: any[]) => any): StorageTable<T>;
+    each(callback: (item: T) => void | Promise<void>): Promise<void>;
+    jsFilter(predicate: (item: T) => boolean): StorageCollection<T>;
+    private createCollection;
+    createCollectionFromPredicate(predicate: (record: T, key: string) => boolean, template?: MemoryCollection<T>): MemoryCollection<T>;
+    createWhereClause(index: string | string[], baseCollection?: MemoryCollection<T>): MemoryWhereClause<T>;
+    entries(): Array<[string, T]>;
+    cloneRecord(record: T): T;
+    deleteByKey(key: string): void;
+    getMutableRecord(key: string): T | undefined;
+    setMutableRecord(key: string, record: T): void;
+    resolvePublicKey(record: T, key: string): unknown;
+    getIndexValue(record: T, index: string | string[]): unknown;
+    compareEntries(left: T, right: T, index: string | string[]): number;
+    compareValues(left: unknown, right: unknown): number;
+    private normalizeComparableValue;
+    private baseAdd;
+    private basePut;
+    private baseUpdate;
+    private baseDelete;
+    private baseGet;
+    private createPrimaryKey;
+    private resolveKey;
+}
+
+declare class MemoryAdapter implements StorageAdapter {
+    readonly type = "MemoryAdapter";
+    readonly name: string;
+    readonly tables: Map<string, MemoryTable<any>>;
+    constructor(name: string);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    delete(): Promise<void>;
+    query<R>(callback: (ctx: MemoryQueryContext) => Promise<R>): Promise<R>;
+    defineSchema(_version: number, schema: Record<string, string>, _options?: StorageSchemaDefinitionOptions): void;
+    table<T = any>(name: string): StorageTable<T>;
+    transaction<T>(_mode: TransactionMode, tableNames: string[], callback: (context: StorageTransactionContext) => Promise<T>): Promise<T>;
+    private ensureTable;
+}
+
+declare class MemoryQueryContext {
+    private readonly adapter;
+    constructor(adapter: MemoryAdapter);
+    table<T = any>(name: string): StorageTable<T>;
+    transaction<T>(mode: TransactionMode, tableNames: string[], callback: (context: StorageTransactionContext) => Promise<T>): Promise<T>;
+}
+
+declare class SQLiteAdapter implements StorageAdapter {
+    readonly type = "SQLiteAdapter";
+    readonly name: string;
+    private readonly options;
+    private readonly schemas;
+    private readonly versionSchemas;
+    private readonly versionOptions;
+    private readonly tableCache;
+    private driver;
+    private openPromise?;
+    private isOpen;
+    private schemaApplied;
+    private transactionDepth;
+    private targetVersion;
+    constructor(driver: SQLiteDatabaseDriver, options?: SQLiteAdapterOptions);
+    get driverType(): string;
+    /**
+     * Opens the database connection and applies schema.
+     * This is called automatically when performing operations,
+     * so explicit calls are optional but safe (idempotent).
+     * When called explicitly after schema changes, it will run any pending migrations.
+     */
+    open(): Promise<void>;
+    private ensureOpen;
+    private performOpen;
+    close(): Promise<void>;
+    delete(): Promise<void>;
+    defineSchema(version: number, schema: Record<string, TableSchemaDefinition>, options?: StorageSchemaDefinitionOptions): void;
+    private refreshActiveSchema;
+    table<T = any>(name: string): StorageTable<T>;
+    transaction<T>(_mode: TransactionMode, tableNames: string[], callback: (context: StorageTransactionContext) => Promise<T>): Promise<T>;
+    execute(statement: string, values?: any[]): Promise<void>;
+    run(statement: string, values?: any[]): Promise<SQLiteRunResult>;
+    query<R>(callback: (ctx: SqliteQueryContext) => Promise<R>): Promise<R>;
+    query(statement: string, values?: any[]): Promise<SQLiteQueryResult>;
+    queryRows(statement: string, values?: any[]): Promise<Array<Record<string, any>>>;
+    /**
+     * Ensures the database is open and returns the driver.
+     * This is the main entry point for all public database operations.
+     */
+    private getDriver;
+    /**
+     * Internal execute that uses driver directly.
+     * Used during the open process to avoid recursion.
+     */
+    private internalExecute;
+    /**
+     * Internal run that uses driver directly.
+     * Used during the open process to avoid recursion.
+     */
+    private internalRun;
+    /**
+     * Internal queryRows that uses driver directly.
+     * Used during the open process to avoid recursion.
+     */
+    private internalQueryRows;
+    /**
+     * Internal query that uses driver directly.
+     * Used during migrations to avoid recursion.
+     */
+    private internalQuery;
+    private logSql;
+    private getStoredSchemaVersion;
+    private setStoredSchemaVersion;
+    private runPendingMigrations;
+    private runMigrationStep;
+    private getMigrationHandler;
+    private applySchema;
+    private buildCreateTableStatement;
+    private buildStructuredColumnDefinition;
+    private formatColumnType;
+    private formatDefaultValue;
+    private buildReferencesClause;
+    private buildIndexStatements;
+    private generateIndexName;
+    private parseStructuredSchema;
+    private normalizeColumns;
+}
+
+declare class SqliteQueryContext {
+    private readonly driver;
+    private readonly adapter;
+    constructor(driver: SQLiteDatabaseDriver, adapter: SQLiteAdapter);
+    table<T = any>(name: string): StorageTable<T>;
+    transaction<T>(mode: TransactionMode, tableNames: string[], callback: (context: StorageTransactionContext) => Promise<T>): Promise<T>;
+    execute(statement: string): Promise<void>;
+    run(statement: string, values?: any[]): Promise<SQLiteRunResult>;
+    queryRows(statement: string, values?: any[]): Promise<Array<Record<string, any>>>;
+}
+
+type TransactionMode = 'r' | 'rw';
+interface StorageAdapter {
+    readonly type: string;
+    readonly name: string;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    delete(): Promise<void>;
+    defineSchema(version: number, schema: Record<string, TableSchemaDefinition>, options?: StorageSchemaDefinitionOptions): void;
+    table<T = any>(name: string): StorageTable<T>;
+    transaction<T>(mode: TransactionMode, tableNames: string[], callback: (context: StorageTransactionContext) => Promise<T>): Promise<T>;
+    query<R>(callback: (ctx: DexieQueryContext | SqliteQueryContext | MemoryQueryContext) => Promise<R>): Promise<R>;
+}
+interface StorageTransactionContext {
+    tables: Record<string, StorageTable<any>>;
+}
+interface StorageCollection<T = any> {
+    first(): Promise<T | undefined>;
+    last(): Promise<T | undefined>;
+    each(callback: (item: T, index: number) => void | Promise<void>): Promise<void>;
+    eachKey(callback: (key: unknown, index: number) => void | Promise<void>): Promise<void>;
+    eachPrimaryKey(callback: (key: unknown, index: number) => void | Promise<void>): Promise<void>;
+    eachUniqueKey(callback: (key: unknown, index: number) => void | Promise<void>): Promise<void>;
+    keys(): Promise<unknown[]>;
+    primaryKeys(): Promise<unknown[]>;
+    uniqueKeys(): Promise<unknown[]>;
+    count(): Promise<number>;
+    sortBy(key: string): Promise<T[]>;
+    distinct(): StorageCollection<T>;
+    jsFilter(predicate: (item: T) => boolean): StorageCollection<T>;
+    or(index: string): StorageWhereClause<T>;
+    clone(props?: Record<string, unknown>): StorageCollection<T>;
+    reverse(): StorageCollection<T>;
+    offset(offset: number): StorageCollection<T>;
+    limit(count: number): StorageCollection<T>;
+    toCollection(): StorageCollection<T>;
+    delete(): Promise<number>;
+    modify(changes: Partial<T> | ((item: T) => void | Promise<void>)): Promise<number>;
+    toArray(): Promise<T[]>;
+}
+interface StorageWhereClause<T = any> {
+    equals(value: any): StorageCollection<T>;
+    above(value: any): StorageCollection<T>;
+    aboveOrEqual(value: any): StorageCollection<T>;
+    below(value: any): StorageCollection<T>;
+    belowOrEqual(value: any): StorageCollection<T>;
+    between(lower: any, upper: any, includeLower?: boolean, includeUpper?: boolean): StorageCollection<T>;
+    inAnyRange(ranges: Array<[any, any]>, options?: {
+        includeLower?: boolean;
+        includeUpper?: boolean;
+    }): StorageCollection<T>;
+    startsWith(prefix: string): StorageCollection<T>;
+    startsWithIgnoreCase(prefix: string): StorageCollection<T>;
+    startsWithAnyOf(...prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOf(prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOfIgnoreCase(...prefixes: string[]): StorageCollection<T>;
+    startsWithAnyOfIgnoreCase(prefixes: string[]): StorageCollection<T>;
+    equalsIgnoreCase(value: string): StorageCollection<T>;
+    anyOf(...values: any[]): StorageCollection<T>;
+    anyOf(values: any[]): StorageCollection<T>;
+    anyOfIgnoreCase(...values: string[]): StorageCollection<T>;
+    anyOfIgnoreCase(values: string[]): StorageCollection<T>;
+    noneOf(...values: any[]): StorageCollection<T>;
+    noneOf(values: any[]): StorageCollection<T>;
+    notEqual(value: any): StorageCollection<T>;
+}
+interface StorageTable<T = any> {
+    readonly name: string;
+    readonly schema: unknown;
+    readonly hook: unknown;
+    add(item: T): Promise<unknown>;
+    put(item: T): Promise<unknown>;
+    update(key: unknown, changes: Partial<T>): Promise<number>;
+    delete(key: unknown): Promise<void>;
+    clear(): Promise<void>;
+    get(key: unknown): Promise<T | undefined>;
+    toArray(): Promise<T[]>;
+    count(): Promise<number>;
+    bulkAdd(items: T[]): Promise<unknown>;
+    bulkPut(items: T[]): Promise<unknown>;
+    bulkGet(keys: Array<unknown>): Promise<Array<T | undefined>>;
+    bulkUpdate(keysAndChanges: Array<{
+        key: unknown;
+        changes: Partial<T>;
+    }>): Promise<number>;
+    bulkDelete(keys: Array<unknown>): Promise<void>;
+    where(index: string | string[]): StorageWhereClause<T>;
+    orderBy(index: string | string[]): StorageCollection<T>;
+    reverse(): StorageCollection<T>;
+    offset(offset: number): StorageCollection<T>;
+    limit(count: number): StorageCollection<T>;
+    mapToClass(ctor: new (...args: any[]) => any): StorageTable<T>;
+    each(callback: (item: T) => void | Promise<void>): Promise<void>;
+    jsFilter(predicate: (item: T) => boolean): StorageCollection<T>;
+    readonly raw: {
+        add(item: T): Promise<unknown>;
+        put(item: T): Promise<unknown>;
+        update(key: unknown, changes: Partial<T>): Promise<number>;
+        delete(key: unknown): Promise<void>;
+        get(key: unknown): Promise<T | undefined>;
+        bulkAdd(items: T[]): Promise<unknown>;
+        bulkPut(items: T[]): Promise<unknown>;
+        bulkUpdate(keysAndChanges: Array<{
+            key: unknown;
+            changes: Partial<T>;
+        }>): Promise<number>;
+        bulkDelete(keys: Array<unknown>): Promise<void>;
+        clear(): Promise<void>;
+    };
+}
+
+declare class DexieAdapter implements StorageAdapter {
+    readonly type = "DexieAdapter";
+    readonly name: string;
+    readonly db: dexie;
+    private readonly tableCache;
+    constructor(databaseName: string);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    delete(): Promise<void>;
+    query<R>(callback: (ctx: DexieQueryContext) => Promise<R>): Promise<R>;
+    defineSchema(version: number, schema: Record<string, TableSchemaDefinition>, _options?: StorageSchemaDefinitionOptions): void;
+    table<T = any>(name: string): StorageTable<T>;
+    transaction<T>(mode: TransactionMode, tableNames: string[], callback: (context: StorageTransactionContext) => Promise<T>): Promise<T>;
+}
+
+export { DexieQueryContext as D, MemoryAdapter as M, SQLiteAdapter as S, type TableSchemaDefinition as T, MemoryQueryContext as a, SqliteQueryContext as b, type StorageAdapter as c, type StorageTable as d, DexieAdapter as e };