xdriver 1.1.1 → 2.0.1

package/lib/com.d.ts

@@ -0,0 +1,16 @@
+export declare function _instance(example: any, type: any): boolean;
+export declare function _copy(src: any, target: any): any;
+export declare class Logger {
+    static trace: boolean;
+    private readonly catalog;
+    constructor(catalog: string);
+    private print;
+    private getFormatDate;
+    debug(msg: string, ...args: any[]): void;
+    warn(msg: string, ...args: any[]): void;
+    info(msg: string, ...args: any[]): void;
+    error(msg: string, ...args: any[]): void;
+    success(msg: string, ...args: any[]): void;
+    static getLogger(catalog?: string): Logger;
+}
+export declare const logger: Logger;

package/lib/com.js

@@ -0,0 +1,61 @@
+export function _instance(example, type) {
+    let pro = type.prototype;
+    example = example.__proto__;
+    while (true) {
+        if (example === null)
+            return false;
+        if (pro === example)
+            return true;
+        example = example.__proto__;
+    }
+}
+export function _copy(src, target) {
+    if (!target)
+        return src;
+    for (let prop in src) {
+        target[prop] = src[prop];
+    }
+    return target;
+}
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["debug"] = 0] = "debug";
+    LogLevel[LogLevel["warn"] = 1] = "warn";
+    LogLevel[LogLevel["info"] = 2] = "info";
+    LogLevel[LogLevel["error"] = 3] = "error";
+})(LogLevel || (LogLevel = {}));
+export class Logger {
+    constructor(catalog) {
+        this.catalog = catalog;
+    }
+    print(fn, ...args) {
+        if (Logger.trace) {
+            console.trace(...args);
+            return;
+        }
+        fn(...args);
+    }
+    getFormatDate() {
+        const date = new Date();
+        return `[${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()} ${date.getHours()}:${date.getMinutes()}:${date.getSeconds()}.${date.getMilliseconds()}]`;
+    }
+    debug(msg, ...args) {
+        this.print(console.debug, `%c${this.getFormatDate()} [DEBUG] <${this.catalog}> ${msg}`, ...args, "color: gray;");
+    }
+    warn(msg, ...args) {
+        this.print(console.warn, `%c${this.getFormatDate()} [WARN] <${this.catalog}> ${msg}`, ...args, "color: #FFCC00;");
+    }
+    info(msg, ...args) {
+        this.print(console.info, `${this.getFormatDate()} [INFO] <${this.catalog}> ${msg}`, ...args);
+    }
+    error(msg, ...args) {
+        this.print(console.error, `%c${this.getFormatDate()} [ERROR] <${this.catalog}> ${msg}`, ...args, "color: #EF4444;");
+    }
+    success(msg, ...args) {
+        this.print(console.log, `%c${this.getFormatDate()} [SUCCESS] <${this.catalog}> ${msg}`, ...args, "color: #10B981;");
+    }
+    static getLogger(catalog = 'default') {
+        return new Logger(catalog);
+    }
+}
+export const logger = Logger.getLogger();

package/lib/const.d.ts

@@ -0,0 +1,21 @@
+export declare const innerDB: IDBFactory;
+export declare enum IndexdbStatus {
+    CONNECT_ING = 0,
+    CONNECT_SUCCESS = 1,
+    CONNECT_ERROR = 2,
+    CONNECT_CHANGE = 3,
+    CONNECT_CLOSE = 4,
+    DATABASE_ERROR = 5,
+    VERSION_CHANGE = 99
+}
+export declare class KeyRange {
+    static leq(x: any): IDBKeyRange;
+    static lt(x: any): IDBKeyRange;
+    static geq(x: any): IDBKeyRange;
+    static gt(x: any): IDBKeyRange;
+    static between(x: any, y: any): IDBKeyRange;
+    static gt_lt(x: any, y: any): IDBKeyRange;
+    static gt_leq(x: any, y: any): IDBKeyRange;
+    static geq_lt(x: any, y: any): IDBKeyRange;
+    static eq(x: any, y: any): IDBKeyRange;
+}

package/lib/const.js

@@ -0,0 +1,41 @@
+let win = window;
+export const innerDB = win.indexedDB || win.mozIndexedDB || win.webkitIndexedDB || win.msIndexedDB;
+export var IndexdbStatus;
+(function (IndexdbStatus) {
+    IndexdbStatus[IndexdbStatus["CONNECT_ING"] = 0] = "CONNECT_ING";
+    IndexdbStatus[IndexdbStatus["CONNECT_SUCCESS"] = 1] = "CONNECT_SUCCESS";
+    IndexdbStatus[IndexdbStatus["CONNECT_ERROR"] = 2] = "CONNECT_ERROR";
+    IndexdbStatus[IndexdbStatus["CONNECT_CHANGE"] = 3] = "CONNECT_CHANGE";
+    IndexdbStatus[IndexdbStatus["CONNECT_CLOSE"] = 4] = "CONNECT_CLOSE";
+    IndexdbStatus[IndexdbStatus["DATABASE_ERROR"] = 5] = "DATABASE_ERROR";
+    IndexdbStatus[IndexdbStatus["VERSION_CHANGE"] = 99] = "VERSION_CHANGE";
+})(IndexdbStatus || (IndexdbStatus = {}));
+export class KeyRange {
+    static leq(x) {
+        return IDBKeyRange.upperBound(x);
+    }
+    static lt(x) {
+        return IDBKeyRange.upperBound(x, true);
+    }
+    static geq(x) {
+        return IDBKeyRange.lowerBound(x);
+    }
+    static gt(x) {
+        return IDBKeyRange.lowerBound(x, true);
+    }
+    static between(x, y) {
+        return IDBKeyRange.bound(x, y);
+    }
+    static gt_lt(x, y) {
+        return IDBKeyRange.bound(x, y, true, true);
+    }
+    static gt_leq(x, y) {
+        return IDBKeyRange.bound(x, y, true, false);
+    }
+    static geq_lt(x, y) {
+        return IDBKeyRange.bound(x, y, false, true);
+    }
+    static eq(x, y) {
+        return IDBKeyRange.only(x);
+    }
+}

package/lib/database.d.ts

@@ -0,0 +1,31 @@
+import { IndexdbStatus } from "./const";
+import Table, { Metadata } from "./table";
+interface EventMap {
+    process: (this: Database, status: IndexdbStatus) => void;
+    success: (this: Database, connect: IDBDatabase) => void;
+    blocked: (this: Database, event: IDBVersionChangeEvent) => void;
+    change: (connect: any) => void;
+    error: (evt: Event) => void;
+    close: () => void;
+}
+type EventKey = keyof EventMap;
+export default class Database {
+    private name;
+    private version;
+    database?: IDBDatabase;
+    readonly tableMap: Map<string, Table>;
+    private eventMap;
+    constructor(database: string, version?: number);
+    on<T extends EventKey>(event: T, handle: EventMap[T]): this;
+    get connected(): boolean;
+    connect(name?: string, version?: number): Promise<Database>;
+    drop(): Promise<unknown>;
+    close(): void;
+    createTable(tableName: string, meta?: Omit<Metadata, 'name'>): Table;
+    createTables(tables: Array<string>, meta?: Omit<Metadata, 'name' | 'rows'>): Table[];
+    dropTable(tableName: string): boolean;
+    table(tableName: string): Table | undefined;
+    exists(table: string): boolean;
+    getTables(): MapIterator<Table>;
+}
+export {};

package/lib/database.js

@@ -0,0 +1,146 @@
+import { IndexdbStatus, innerDB } from "./const";
+import Table from "./table";
+import { Logger } from './com';
+const logger = Logger.getLogger('Database');
+export default class Database {
+    constructor(database, version = 1) {
+        this.eventMap = {};
+        this.name = database;
+        this.version = version;
+        this.tableMap = new Map();
+    }
+    on(event, handle) {
+        this.eventMap[event] = handle;
+        return this;
+    }
+    get connected() {
+        return this.database != void 0;
+    }
+    connect(name, version) {
+        var _a;
+        if (!name && version == void 0 && this.connected) {
+            return Promise.resolve(this);
+        }
+        this.name = name || this.name;
+        this.version = version || this.version;
+        const request = innerDB.open(this.name, version);
+        (_a = this.eventMap.process) === null || _a === void 0 ? void 0 : _a.call(this, IndexdbStatus.CONNECT_ING);
+        request.onerror = (e) => {
+            var _a, _b;
+            logger.error('onerror', e);
+            (_a = this.eventMap.process) === null || _a === void 0 ? void 0 : _a.call(this, IndexdbStatus.CONNECT_ERROR);
+            (_b = this.eventMap.error) === null || _b === void 0 ? void 0 : _b.call(this, e);
+        };
+        request.onblocked = (evt) => {
+            var _a, _b;
+            logger.warn(`onblocked change from ${evt.oldVersion} to ${evt.newVersion}`, evt);
+            (_a = this.eventMap.process) === null || _a === void 0 ? void 0 : _a.call(this, IndexdbStatus.CONNECT_CLOSE);
+            (_b = this.eventMap.blocked) === null || _b === void 0 ? void 0 : _b.call(this, evt);
+        };
+        return new Promise((resolve, reject) => {
+            request.onupgradeneeded = (event) => {
+                var _a, _b;
+                logger.info(`Version change from <${event.oldVersion}> to <${event.newVersion}>`, event);
+                (_a = this.eventMap.process) === null || _a === void 0 ? void 0 : _a.call(this, IndexdbStatus.VERSION_CHANGE);
+                const target = event.target;
+                this.database = target.result;
+                (_b = this.eventMap.change) === null || _b === void 0 ? void 0 : _b.call(this, this.database);
+            };
+            request.onsuccess = (e) => {
+                var _a, _b;
+                logger.info(`Connect Success`, e);
+                const target = e.target;
+                let connect = target.result;
+                this.database = connect;
+                let objectStoreNames = connect.objectStoreNames;
+                if (objectStoreNames.length) {
+                    let transaction = connect.transaction(objectStoreNames);
+                    for (let i = 0; i < objectStoreNames.length; i++) {
+                        let table = objectStoreNames.item(i);
+                        if (!table)
+                            continue;
+                        let objectStore = transaction.objectStore(table);
+                        let { indexNames, keyPath: primaryKey, name, autoIncrement = true } = objectStore;
+                        let indexes = [];
+                        for (let j = 0; indexNames && j < indexNames.length; j++) {
+                            let indexName = indexNames.item(j);
+                            if (!indexName)
+                                continue;
+                            let { keyPath, name, multiEntry, unique } = objectStore.index(indexName);
+                            indexes.push({ name, column: keyPath, unique, multiEntry });
+                        }
+                        this.tableMap.set(name, new Table({ name, primaryKey: primaryKey == null ? void 0 : primaryKey, autoIncrement, indexes }, this.database));
+                    }
+                }
+                (_a = this.eventMap.process) === null || _a === void 0 ? void 0 : _a.call(this, IndexdbStatus.CONNECT_SUCCESS);
+                (_b = this.eventMap.success) === null || _b === void 0 ? void 0 : _b.call(this, this.database);
+                resolve(this);
+            };
+        });
+    }
+    drop() {
+        return new Promise((resolve, reject) => {
+            let request = innerDB.deleteDatabase(this.name);
+            request.onerror = function (event) {
+                reject(event);
+            };
+            request.onsuccess = function (event) {
+                resolve(event);
+            };
+            this.close();
+        });
+    }
+    close() {
+        var _a, _b, _c;
+        if (this.connected) {
+            (_a = this.eventMap.process) === null || _a === void 0 ? void 0 : _a.call(this, IndexdbStatus.CONNECT_CLOSE);
+            (_b = this.database) === null || _b === void 0 ? void 0 : _b.close();
+            (_c = this.eventMap.close) === null || _c === void 0 ? void 0 : _c.call(this);
+            this.database = void 0;
+        }
+    }
+    createTable(tableName, meta = {}) {
+        var _a, _b;
+        if (this.exists(tableName)) {
+            throw new Error(`Table ${tableName} is exists`);
+        }
+        const metadata = Object.assign(Object.assign({}, meta), { name: tableName });
+        let { name = '', primaryKey = 'id', autoIncrement = true, indexes = [], rows = [] } = metadata;
+        const store = (_a = this.database) === null || _a === void 0 ? void 0 : _a.createObjectStore(name, { keyPath: primaryKey, autoIncrement });
+        let idxes = indexes.map(({ name, column, unique, multiEntry }) => {
+            store === null || store === void 0 ? void 0 : store.createIndex(name, column, { unique, multiEntry });
+            return { name, column, unique, multiEntry };
+        });
+        (_b = metadata.rows) === null || _b === void 0 ? void 0 : _b.forEach(row => store === null || store === void 0 ? void 0 : store.add(row));
+        let tab = new Table({ name, primaryKey, autoIncrement, indexes: idxes }, this.database);
+        this.tableMap.set(name, tab);
+        return tab;
+    }
+    createTables(tables, meta = {}) {
+        return tables.map(table => {
+            return this.createTable(table, meta);
+        });
+    }
+    dropTable(tableName) {
+        var _a;
+        if (this.exists(tableName)) {
+            (_a = this.database) === null || _a === void 0 ? void 0 : _a.deleteObjectStore(tableName);
+            this.tableMap.delete(tableName);
+            return true;
+        }
+        return false;
+    }
+    table(tableName) {
+        const table = this.tableMap.get(tableName);
+        if (!table) {
+            logger.error(`Table ${tableName} is not exists`);
+        }
+        return table;
+    }
+    exists(table) {
+        return this.tableMap.has(table);
+    }
+    getTables() {
+        return this.tableMap.values();
+    }
+}

package/lib/driver.d.ts

@@ -0,0 +1,14 @@
+import Database from "./database";
+import { Row, Rows } from "./table";
+export default class Driver extends Database {
+    insert(table: string, data: Array<Record<string, any>>): Promise<any[]> | undefined;
+    query(table: string, query?: IDBValidKey | IDBKeyRange, count?: number): Promise<Rows> | undefined;
+    select(table: string, key?: IDBValidKey | IDBKeyRange, index?: string, count?: number): Promise<Rows> | undefined;
+    selectByKey(table: string, key: IDBValidKey | IDBKeyRange): Promise<Row> | undefined;
+    count(table: string, key: IDBValidKey | IDBKeyRange): Promise<number> | undefined;
+    update(table: string, modify: Row, key?: IDBValidKey | IDBKeyRange | null, count?: number): Promise<IDBValidKey> | undefined;
+    merge(table: string, row: Row | Rows): Promise<IDBValidKey> | Promise<any[]> | undefined;
+    delete(table: string, key: IDBValidKey | IDBKeyRange): Promise<any[]> | undefined;
+    truncate(table: string): Promise<undefined> | undefined;
+    static connect(database: string, version: number | undefined, initialize: (driver: Driver) => void): Promise<Driver>;
+}

package/lib/driver.js

@@ -0,0 +1,59 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Database from "./database";
+export default class Driver extends Database {
+    insert(table, data) {
+        var _a;
+        return (_a = this.table(table)) === null || _a === void 0 ? void 0 : _a.insert(data);
+    }
+    query(table, query, count = 1000) {
+        var _a;
+        return (_a = this.table(table)) === null || _a === void 0 ? void 0 : _a.query(query, count);
+    }
+    select(table, key, index, count = 1000) {
+        var _a;
+        return (_a = this.table(table)) === null || _a === void 0 ? void 0 : _a.select(key, count, index);
+    }
+    selectByKey(table, key) {
+        var _a;
+        return (_a = this.table(table)) === null || _a === void 0 ? void 0 : _a.queryByKey(key);
+    }
+    count(table, key) {
+        var _a;
+        return (_a = this.table(table)) === null || _a === void 0 ? void 0 : _a.count(key);
+    }
+    update(table, modify, key, count) {
+        var _a;
+        return (_a = this.table(table)) === null || _a === void 0 ? void 0 : _a.update(modify, key, count);
+    }
+    merge(table, row) {
+        var _a;
+        return (_a = this.table(table)) === null || _a === void 0 ? void 0 : _a.merge(row);
+    }
+    delete(table, key) {
+        var _a;
+        return (_a = this.table(table)) === null || _a === void 0 ? void 0 : _a.delete(key);
+    }
+    truncate(table) {
+        var _a;
+        return (_a = this.table(table)) === null || _a === void 0 ? void 0 : _a.clear();
+    }
+    static connect(database_1) {
+        return __awaiter(this, arguments, void 0, function* (database, version = 1, initialize) {
+            const driver = new Driver(database, version);
+            driver.on('change', () => {
+                initialize(driver);
+            });
+            yield driver.connect();
+            return driver;
+        });
+    }
+    ;
+}

package/lib/index.d.ts

@@ -1,7 +1,6 @@
-import { IndexdbStatus, TransactionMode, CursorDirection, KeyRange } from "./Const";
-import Driver from "./Driver";
-import Database from "./Database";
-import Table from "./Table";
-import TableIndex from "./TableIndex";
-export { IndexdbStatus, TransactionMode, CursorDirection, KeyRange, Database, TableIndex, Table };
-export default Driver;
+import { IndexdbStatus, KeyRange } from "./const";
+import Driver from "./driver";
+import Database from "./database";
+import Table from "./table";
+export { IndexdbStatus, KeyRange, Database, Table, Driver };
+export default Driver;

package/lib/index.js

@@ -1,7 +1,6 @@
-import { IndexdbStatus, TransactionMode, CursorDirection, KeyRange } from "./Const";
-import Driver from "./Driver";
-import Database from "./Database";
-import Table from "./Table";
-import TableIndex from "./TableIndex";
-export { IndexdbStatus, TransactionMode, CursorDirection, KeyRange, Database, TableIndex, Table };
-export default Driver;
+import { IndexdbStatus, KeyRange } from "./const";
+import Driver from "./driver";
+import Database from "./database";
+import Table from "./table";
+export { IndexdbStatus, KeyRange, Database, Table, Driver };
+export default Driver;

package/lib/table.d.ts

@@ -0,0 +1,40 @@
+export type Index = {
+    name: string;
+    column: Array<string> | string;
+    unique?: boolean;
+    multiEntry?: boolean;
+};
+export type ITable = {
+    name: string;
+    primaryKey?: string | string[];
+    autoIncrement?: boolean;
+    indexes?: Array<Index>;
+};
+export type Row = Record<string, any>;
+export type Rows = Array<Row>;
+export type Metadata = ITable & {
+    rows?: Rows;
+};
+export default class Table implements ITable {
+    readonly name: string;
+    readonly primaryKey: string | string[];
+    readonly autoIncrement: boolean;
+    readonly indexes: Array<Index>;
+    readonly database?: IDBDatabase;
+    constructor(table: ITable | string, database?: IDBDatabase);
+    insert(data: Row | Rows): Promise<any[]>;
+    update(modify: Row, key?: IDBValidKey | IDBKeyRange | null, count?: number): Promise<IDBValidKey>;
+    merge(row: Row): Promise<IDBValidKey> | Promise<any[]>;
+    delete(key: IDBValidKey | IDBKeyRange): Promise<any[]>;
+    clear(): Promise<undefined>;
+    dropIndex(name: string): void;
+    keys(key?: IDBValidKey | IDBKeyRange | null, count?: number): Promise<IDBValidKey[]>;
+    count(key?: IDBValidKey | IDBKeyRange): Promise<number>;
+    query(key?: IDBValidKey | IDBKeyRange, count?: number): Promise<Rows>;
+    select(key?: IDBValidKey | IDBKeyRange, count?: number, index?: string): Promise<Rows>;
+    queryByKey(key: IDBValidKey | IDBKeyRange): Promise<Row>;
+    fetch(key?: IDBValidKey | IDBKeyRange, direction?: IDBCursorDirection): Promise<Rows>;
+    queryByIndex(indexName: string, key?: IDBValidKey | IDBKeyRange, count?: number): Promise<Rows>;
+    deplete(key?: IDBValidKey | IDBKeyRange, direction?: IDBCursorDirection): Promise<Rows>;
+    multiple(indexName: string, key?: IDBValidKey | IDBKeyRange, direction?: IDBCursorDirection): Promise<Rows>;
+}

package/lib/table.js

@@ -0,0 +1,183 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { _copy, _instance, Logger } from "./com";
+const logger = Logger.getLogger('Table');
+const _getObjectStore = (table, mode = 'readonly') => {
+    var _a;
+    const trans = (_a = table.database) === null || _a === void 0 ? void 0 : _a.transaction(table.name, mode);
+    if (!trans) {
+        throw new Error('database not open');
+    }
+    trans.oncomplete = (event) => {
+        logger.debug(`Table ${table.name} transaction success`, event);
+    };
+    trans.onerror = (event) => {
+        logger.error(`Table ${table.name} transaction error`, event);
+    };
+    return trans.objectStore(table.name);
+};
+const _request = (request) => __awaiter(void 0, void 0, void 0, function* () {
+    return new Promise((resolve, reject) => {
+        request.onsuccess = (e) => {
+            resolve(e.target.result);
+        };
+        request.onerror = (e) => {
+            reject(e.target.error);
+        };
+    });
+});
+export default class Table {
+    constructor(table, database) {
+        this.primaryKey = "id";
+        this.autoIncrement = false;
+        this.indexes = [];
+        let metadata;
+        if (typeof table === 'string') {
+            metadata = { name: table };
+        }
+        else {
+            metadata = Object.assign({}, table);
+        }
+        const { name = '', primaryKey = 'id', autoIncrement = true, indexes = [] } = metadata;
+        this.name = name;
+        this.primaryKey = primaryKey;
+        this.autoIncrement = autoIncrement;
+        this.database = database;
+        this.indexes = (indexes || []).map(idx => {
+            return Object.assign({ unique: false, multiEntry: false }, idx);
+        });
+    }
+    insert(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const store = _getObjectStore(this, 'readwrite');
+            let results = [];
+            let rows = Array.isArray(data) ? data : [data];
+            for (let row of rows) {
+                let result = yield _request(store.add(row));
+                results.push(result);
+            }
+            return results;
+        });
+    }
+    update(modify, key, count) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const store = _getObjectStore(this, 'readwrite');
+            if (!key || !_instance(key, IDBKeyRange)) {
+                return _request(store.put(modify, key));
+            }
+            let rows = yield _request(store.getAll(key, count));
+            rows = _instance(rows, Array) ? rows : [rows];
+            let results = [];
+            for (let row of rows) {
+                let rs = yield _request(store.put(_copy(modify, row)));
+                results.push(rs);
+            }
+            return results;
+        });
+    }
+    merge(row) {
+        let { primaryKey } = this;
+        let keys = Array.isArray(primaryKey) ? primaryKey : [primaryKey];
+        let keyArray = [];
+        for (let key of keys) {
+            keyArray.push(row[key]);
+        }
+        if (keyArray.length) {
+            return this.update(row, keyArray);
+        }
+        return this.insert(row);
+    }
+    delete(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!key) {
+                return Promise.reject('key is required');
+            }
+            let objectStore = _getObjectStore(this, 'readwrite');
+            let rows = yield _request(objectStore.getAll(key));
+            yield _request(objectStore.delete(key));
+            return rows;
+        });
+    }
+    clear() {
+        return _request(_getObjectStore(this, 'readwrite').clear());
+    }
+    dropIndex(name) {
+        return _getObjectStore(this, 'readwrite').deleteIndex(name);
+    }
+    keys(key, count) {
+        return _request(_getObjectStore(this).getAllKeys(key, count));
+    }
+    count(key) {
+        return _request(_getObjectStore(this).count(key));
+    }
+    query(key, count) {
+        return _request(_getObjectStore(this).getAll(key, count));
+    }
+    select(key, count, index) {
+        if (!index) {
+            return this.query(key, count);
+        }
+        return this.queryByIndex(index, key, count);
+    }
+    queryByKey(key) {
+        return _request(_getObjectStore(this).get(key));
+    }
+    fetch(key, direction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const store = _getObjectStore(this);
+            let cursor = yield _request(store.openCursor(key, direction));
+            if (!cursor) {
+                return [];
+            }
+            let rows = [];
+            while (cursor.value) {
+                rows.push(cursor.value);
+                cursor.continue();
+            }
+            return rows;
+        });
+    }
+    queryByIndex(indexName, key, count) {
+        const store = _getObjectStore(this);
+        const index = store.index(indexName);
+        return _request(index.getAll(key || null, count));
+    }
+    deplete(key_1) {
+        return __awaiter(this, arguments, void 0, function* (key, direction = 'next') {
+            const store = _getObjectStore(this, 'readwrite');
+            const cursor = yield _request(store.openCursor(key, direction));
+            if (!cursor) {
+                return [];
+            }
+            let rows = [];
+            while (cursor.value) {
+                rows.push(cursor.value);
+                cursor.continue();
+            }
+            return rows;
+        });
+    }
+    multiple(indexName_1, key_1) {
+        return __awaiter(this, arguments, void 0, function* (indexName, key, direction = 'next') {
+            const store = _getObjectStore(this);
+            const index = store.index(indexName);
+            const cursor = yield _request(index.openCursor(key, direction));
+            if (!cursor) {
+                return [];
+            }
+            let rows = [];
+            while (cursor.value) {
+                rows.push(cursor.value);
+                cursor.continue();
+            }
+            return rows;
+        });
+    }
+}

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/com.ts","../src/const.ts","../src/database.ts","../src/driver.ts","../src/index.ts","../src/table.ts"],"version":"5.9.3"}

package/package.json

@@ -1,16 +1,15 @@
 {
   "name": "xdriver",
-  "version": "1.1.1",
+  "version": "2.0.1",
   "description": "A simple driver for IndexDB",
   "main": "./lib/index",
   "files": [
     "lib/"
   ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
     "build": "tsc",
-    "build0": "tsc && babel lib --out-dir dist && cd lib && del *.js*",
-    "build-test": "tsc &&  webpack --mode production"
+    "build:babel": "tsc && babel lib --out-dir dist && cd lib && del *.js*",
+    "build:webpack": "tsc &&  webpack --mode production"
   },
   "repository": {
     "type": "git",

package/lib/Const.d.ts

@@ -1,32 +0,0 @@
-export declare const innerDB: any;
-export declare enum TransactionMode {
-    READ_ONLY = "readonly",
-    READ_WRITE = "readwrite",
-    READ_WRITE_FLUSH = "readwriteflush",
-    VERSION_CHANGE = "versionchange"
-}
-export declare enum CursorDirection {
-    NEXT,
-    NEXT_NO_DUPLICATE,
-    PREV,
-    PREV_NO_DUPLICATE
-}
-export declare class KeyRange {
-    static leq(x: any): any;
-    static lt(x: any): any;
-    static geq(x: any): any;
-    static gt(x: any): any;
-    static between(x: any, y: any): any;
-    static gt_lt(x: any, y: any): any;
-    static gt_leq(x: any, y: any): any;
-    static geq_lt(x: any, y: any): any;
-    static eq(x: any): any;
-}
-export declare enum IndexdbStatus {
-    CONNECT_ING = 0,
-    CONNECT_SUCCESS = 1,
-    CONNECT_ERROR = 2,
-    CONNECT_CHANGE = 3,
-    CONNECT_CLOSE = 4,
-    DATABASE_ERROR = 0
-}

package/lib/Const.js

@@ -1,57 +0,0 @@
-let win = window;
-const DBCursor = win.IDBCursor;
-const DBKeyRange = win.IDBKeyRange || win.webkitIDBKeyRange || win.msIDBKeyRange;
-export const innerDB = win.indexedDB || win.mozIndexedDB || win.webkitIndexedDB || win.msIndexedDB;
-const DBTransaction = win.IDBTransaction || win.webkitIDBTransaction || win.msIDBTransaction;
-export var TransactionMode;
-(function (TransactionMode) {
-    TransactionMode["READ_ONLY"] = "readonly";
-    TransactionMode["READ_WRITE"] = "readwrite";
-    TransactionMode["READ_WRITE_FLUSH"] = "readwriteflush";
-    TransactionMode["VERSION_CHANGE"] = "versionchange";
-})(TransactionMode || (TransactionMode = {}));
-export var CursorDirection;
-(function (CursorDirection) {
-    CursorDirection[CursorDirection["NEXT"] = DBCursor.NEXT] = "NEXT";
-    CursorDirection[CursorDirection["NEXT_NO_DUPLICATE"] = DBCursor.NEXT_NO_DUPLICATE] = "NEXT_NO_DUPLICATE";
-    CursorDirection[CursorDirection["PREV"] = DBCursor.PREV] = "PREV";
-    CursorDirection[CursorDirection["PREV_NO_DUPLICATE"] = DBCursor.PREV_NO_DUPLICATE] = "PREV_NO_DUPLICATE";
-})(CursorDirection || (CursorDirection = {}));
-export class KeyRange {
-    static leq(x) {
-        return DBKeyRange.upperBound(x);
-    }
-    static lt(x) {
-        return DBKeyRange.upperBound(x, true);
-    }
-    static geq(x) {
-        return DBKeyRange.lowerBound(x);
-    }
-    static gt(x) {
-        return DBKeyRange.lowerBound(x, true);
-    }
-    static between(x, y) {
-        return DBKeyRange.bound(x, y);
-    }
-    static gt_lt(x, y) {
-        return DBKeyRange.bound(x, y, true, true);
-    }
-    static gt_leq(x, y) {
-        return DBKeyRange.bound(x, y, true, false);
-    }
-    static geq_lt(x, y) {
-        return DBKeyRange.bound(x, y, false, true);
-    }
-    static eq(x) {
-        return DBKeyRange.only(x);
-    }
-}
-export var IndexdbStatus;
-(function (IndexdbStatus) {
-    IndexdbStatus[IndexdbStatus["CONNECT_ING"] = 0] = "CONNECT_ING";
-    IndexdbStatus[IndexdbStatus["CONNECT_SUCCESS"] = 1] = "CONNECT_SUCCESS";
-    IndexdbStatus[IndexdbStatus["CONNECT_ERROR"] = 2] = "CONNECT_ERROR";
-    IndexdbStatus[IndexdbStatus["CONNECT_CHANGE"] = 3] = "CONNECT_CHANGE";
-    IndexdbStatus[IndexdbStatus["CONNECT_CLOSE"] = 4] = "CONNECT_CLOSE";
-    IndexdbStatus[IndexdbStatus["DATABASE_ERROR"] = 0] = "DATABASE_ERROR";
-})(IndexdbStatus || (IndexdbStatus = {}));

package/lib/Database.d.ts

@@ -1,22 +0,0 @@
-import Table from "./Table";
-export default class Database {
-    private name;
-    private version;
-    connect: any;
-    private initialized;
-    readonly tables: Map<string, Table>;
-    readonly events: any;
-    constructor(name: string, version?: number);
-    initialize(initialized: Function): this;
-    on(event: any, fn?: Function): this;
-    isOpen(): boolean;
-    open(name?: string | undefined, version?: any): Promise<unknown>;
-    drop(): Promise<unknown>;
-    close(): void;
-    createTable(tableName: string, options?: object): Table;
-    createTables(tables: Array<string>, options?: object): Table[];
-    dropTable(tableName: string): boolean;
-    protected table(tableName: string): Table;
-    exists(table: string): boolean;
-    getTables(): IterableIterator<Table>;
-}

package/lib/Database.js

@@ -1,161 +0,0 @@
-import { _instance } from "./Utils";
-import { IndexdbStatus, innerDB } from "./Const";
-import Table from "./Table";
-import { TableIndex } from "./index";
-export default class Database {
-    constructor(name, version) {
-        this.version = 1;
-        this.events = {
-            process: (status) => {
-            },
-            success: () => {
-            },
-            close: () => {
-            },
-            change: () => {
-            },
-            error: () => {
-            }
-        };
-        this.name = name;
-        this.version = version;
-        this.connect = null;
-        this.initialized = () => { };
-        this.tables = new Map();
-    }
-    initialize(initialized) {
-        if (this.isOpen()) {
-            throw new Error('You must be call this method before open');
-        }
-        this.initialized = initialized;
-        return this;
-    }
-    on(event, fn) {
-        if (!_instance(event, Object)) {
-            Object.keys(event).forEach((e) => this.on(e, event[e]));
-        }
-        else {
-            if (!(event in this.events)) {
-                throw new Error(`Unsupport event type ${event}!`);
-            }
-            this.events[event.toString()] = fn;
-        }
-        return this;
-    }
-    isOpen() {
-        return this.connect != null;
-    }
-    open(name, version) {
-        if (!name && !version && this.isOpen()) {
-            return Promise.resolve(this);
-        }
-        this.name = name || this.name;
-        this.version = version || this.version;
-        const request = innerDB.open(this.name, version);
-        this.events.process(IndexdbStatus.CONNECT_ING);
-        request.onerror = (e) => {
-            const error = e.target.error;
-            this.events.process(IndexdbStatus.CONNECT_ERROR);
-            this.events.error.call(this, error);
-        };
-        request.onclose = (e) => {
-            this.events.process(IndexdbStatus.CONNECT_CLOSE);
-            this.events.close.call(this, e.target.result);
-        };
-        return new Promise((resolve, reject) => {
-            request.onsuccess = (e) => {
-                let connect = e.target.result;
-                let objectStoreNames = connect.objectStoreNames;
-                let transaction = connect.transaction(objectStoreNames);
-                for (let i = 0; i < objectStoreNames.length; i++) {
-                    let table = objectStoreNames.item(i);
-                    let objectStore = transaction.objectStore(table);
-                    let { indexNames = [], keyPath: primaryKey, name, autoIncrement = true } = objectStore;
-                    let indexes = [];
-                    for (let j = 0; j < indexNames.length; j++) {
-                        let indexName = indexNames.item(j);
-                        let { keyPath, name, multiEntry, unique } = objectStore.index(indexName);
-                        indexes.push(new TableIndex(name, keyPath, unique, multiEntry));
-                    }
-                    this.tables.set(name, new Table({ name, primaryKey, autoIncrement, indexes }, this));
-                }
-                this.connect = connect;
-                this.events.process(IndexdbStatus.CONNECT_SUCCESS);
-                this.connect.onerror = this.connect.onabort = (e) => {
-                    const error = e.target.error;
-                    this.events.process(IndexdbStatus.DATABASE_ERROR);
-                    this.events.error.call(this, error);
-                };
-                this.events.success.call(this, this.connect);
-                resolve(this);
-            };
-            request.onupgradeneeded = (e) => {
-                this.events.process(IndexdbStatus.CONNECT_SUCCESS);
-                this.connect = e.target.result;
-                this.events.change.call(this, this.connect);
-                this.initialized();
-            };
-        });
-    }
-    drop() {
-        this.close();
-        return new Promise((resolve, reject) => {
-            let request = innerDB.deleteDatabase(this.name);
-            request.onerror = function (event) {
-                reject(event);
-            };
-            request.onsuccess = function (event) {
-                resolve(event);
-            };
-        });
-    }
-    close() {
-        if (this.isOpen()) {
-            this.events.process(IndexdbStatus.CONNECT_CLOSE);
-            this.connect.close();
-            this.events.close.call(this, this.connect);
-            this.connect = null;
-        }
-    }
-    createTable(tableName, options) {
-        if (this.exists(tableName)) {
-            throw new Error(`Table ${tableName} is exists`);
-        }
-        let { name = '', primaryKey = 'id', autoIncrement = true, indexes = [], data = [] } = Object.assign({ name: tableName }, options);
-        const store = this.connect.createObjectStore(name, { keyPath: primaryKey, autoIncrement });
-        let idxes = indexes.map(({ name, column, unique, multiEntry }) => {
-            store.createIndex(name, column, { unique, multiEntry });
-            return new TableIndex(name, column, unique, multiEntry);
-        });
-        data.forEach(item => store.add(item));
-        let tab = new Table({ name, primaryKey, autoIncrement, indexes: idxes }, this);
-        this.tables.set(name, tab);
-        return tab;
-    }
-    createTables(tables, options) {
-        return tables.map(table => {
-            return this.createTable(table, options);
-        });
-    }
-    dropTable(tableName) {
-        if (this.exists(tableName)) {
-            this.tables.delete(tableName);
-            this.connect.deleteObjectStore(tableName);
-            return true;
-        }
-        return false;
-    }
-    table(tableName) {
-        let table = this.tables.get(tableName);
-        if (typeof table !== "undefined") {
-            return table;
-        }
-        throw new Error(`table ${tableName} not exists!`);
-    }
-    exists(table) {
-        return this.tables.has(table);
-    }
-    getTables() {
-        return this.tables.values();
-    }
-}

package/lib/Driver.d.ts

@@ -1,14 +0,0 @@
-import { KeyRange } from "./Const";
-import Database from "./Database";
-declare class Driver extends Database {
-    insert(table: string, data: Array<any>): Promise<unknown>;
-    query(table: string, keyRange?: KeyRange, limit?: number): any;
-    select(table: string, where: any, options?: any): any;
-    selectByKey(table: string, key: any): any;
-    count(table: string, keyRange?: KeyRange): any;
-    update(table: string, modify: any, where: any): Promise<unknown> | undefined;
-    merge(table: string, row: any): Promise<unknown> | undefined;
-    delete(table: string, key: any): any;
-    truncate(table: string): any;
-}
-export default Driver;

package/lib/Driver.js

@@ -1,31 +0,0 @@
-import Database from "./Database";
-class Driver extends Database {
-    insert(table, data) {
-        return this.table(table).insert(data);
-    }
-    query(table, keyRange, limit) {
-        return this.table(table).query(keyRange, limit);
-    }
-    select(table, where, options) {
-        return this.table(table).select(where, options);
-    }
-    selectByKey(table, key) {
-        return this.table(table).queryByKey(key);
-    }
-    count(table, keyRange) {
-        return this.table(table).count(keyRange);
-    }
-    update(table, modify, where) {
-        return this.table(table).update(modify, where);
-    }
-    merge(table, row) {
-        return this.table(table).merge(row);
-    }
-    delete(table, key) {
-        return this.table(table).delete(key);
-    }
-    truncate(table) {
-        return this.table(table).clear();
-    }
-}
-export default Driver;

package/lib/Table.d.ts

@@ -1,31 +0,0 @@
-import { KeyRange, CursorDirection } from "./Const";
-import TableIndex from "./TableIndex";
-import Database from "./Database";
-export default class Table {
-    readonly name: string;
-    readonly primaryKey: string;
-    readonly autoIncrement: boolean;
-    readonly indexes: Array<TableIndex>;
-    readonly database: Database;
-    constructor({ name, primaryKey, autoIncrement, indexes }: {
-        name?: string | undefined;
-        primaryKey?: string | undefined;
-        autoIncrement?: boolean | undefined;
-        indexes?: never[] | undefined;
-    }, database: Database);
-    insert(data: Array<any>): Promise<unknown>;
-    update(modify: any, where?: any): Promise<unknown> | undefined;
-    merge(row: any): Promise<unknown> | undefined;
-    delete(key: any): any;
-    clear(): any;
-    dropIndex(name: string): any;
-    keys(keyRange?: KeyRange, limit?: number): any;
-    count(keyRange?: KeyRange): any;
-    query(keyRange?: KeyRange, limit?: number): any;
-    select(where: any, options?: any): any;
-    queryByKey(key: any): any;
-    fetch(keyRange?: KeyRange, direction?: CursorDirection): Promise<unknown>;
-    queryByIndex(name: string, key: any, count?: number): any;
-    deplete(direction?: any): Promise<unknown>;
-    multiple(indexName: string, each: Function, keyRange?: KeyRange, cursorDirection?: CursorDirection): Promise<unknown>;
-}

package/lib/Table.js

@@ -1,173 +0,0 @@
-import { _copy, _instance } from "./Utils";
-import { CursorDirection, TransactionMode } from "./Const";
-const _getObjectStore = (table, mode = TransactionMode.READ_ONLY) => {
-    const connect = table.database.connect;
-    const trans = connect.transaction(table.name, mode);
-    trans.oncomplete = (e) => console.debug(e);
-    trans.onerror = (e) => console.debug(e);
-    return trans.objectStore(table.name);
-};
-const _request = (request, success) => {
-    return new Promise((resolve, reject) => {
-        request.onsuccess = (e) => {
-            !success ? resolve(e.target.result) : success(e.target.result, resolve);
-        };
-        request.onerror = (e) => {
-            reject(e.target.error);
-        };
-    });
-};
-export default class Table {
-    constructor({ name = '', primaryKey = 'id', autoIncrement = true, indexes = [] }, database) {
-        this.primaryKey = "id";
-        this.autoIncrement = false;
-        this.indexes = [];
-        this.name = name;
-        this.primaryKey = primaryKey;
-        this.autoIncrement = autoIncrement;
-        this.database = database;
-        this.indexes = indexes;
-    }
-    insert(data) {
-        const arr = _instance(data, Array) ? data : [data];
-        const store = _getObjectStore(this, TransactionMode.READ_WRITE);
-        return new Promise((resolve) => {
-            let results = [];
-            arr.forEach((item, index) => {
-                _request(store.add(item)).then((rs) => {
-                    results.push(rs);
-                    if (index + 1 === arr.length)
-                        resolve(results);
-                });
-            });
-        });
-    }
-    update(modify, where) {
-        const store = _getObjectStore(this, TransactionMode.READ_WRITE);
-        if (!where) {
-            _request(store.put(modify));
-        }
-        else {
-            return new Promise((resolve, reject) => {
-                _request(store.getAll(where)).then((rs) => {
-                    rs = _instance(rs, Array) ? rs : [rs];
-                    let rows = [];
-                    rs.forEach((item, index) => {
-                        _request(store.put(_copy(modify, item))).then((r) => {
-                            rows.push(r);
-                            if (index + 1 === rs.length) {
-                                resolve(rows);
-                            }
-                        });
-                    });
-                }).catch((err) => reject(err));
-            });
-        }
-    }
-    merge(row) {
-        let { primaryKey } = this;
-        if (row[primaryKey]) {
-            let where = {};
-            where[primaryKey] = primaryKey;
-            let modify = Object.assign({}, row);
-            delete modify[primaryKey];
-            return this.update(modify, where);
-        }
-        else {
-            return this.insert(row);
-        }
-    }
-    delete(key) {
-        return _request(_getObjectStore(this, TransactionMode.READ_WRITE).delete(key));
-    }
-    clear() {
-        return _request(_getObjectStore(this, TransactionMode.READ_WRITE).clear());
-    }
-    dropIndex(name) {
-        return _getObjectStore(this, TransactionMode.READ_WRITE).deleteIndex(name);
-    }
-    keys(keyRange, limit) {
-        const store = _getObjectStore(this);
-        const request = store.getAllKeys(keyRange, limit);
-        return _request(request);
-    }
-    count(keyRange) {
-        const request = _getObjectStore(this).count(keyRange);
-        return _request(request);
-    }
-    query(keyRange, limit) {
-        const request = _getObjectStore(this).getAll(keyRange, limit);
-        return _request(request);
-    }
-    select(where, options) {
-        if (!where) {
-            return this.query();
-        }
-        let { index = '', limit = void 0, useIndex = false } = options || {};
-        if (useIndex && index) {
-            return this.queryByIndex(index, where, limit);
-        }
-        return this.query(where, limit);
-    }
-    queryByKey(key) {
-        const request = _getObjectStore(this).get(key);
-        return _request(request);
-    }
-    fetch(keyRange, direction) {
-        const store = _getObjectStore(this);
-        const request = store.openCursor(null, direction);
-        return new Promise((resolve, reject) => {
-            let rows = [];
-            _request(request, (cursor) => {
-                if (!cursor) {
-                    resolve(rows);
-                    return;
-                }
-                rows.push(cursor.value);
-                cursor.continue();
-            }).catch((err) => {
-                reject(err);
-            });
-        });
-    }
-    queryByIndex(name, key, count) {
-        const store = _getObjectStore(this);
-        const index = store.index(name);
-        return _request(index.getAll(key, count));
-    }
-    deplete(direction = CursorDirection.NEXT) {
-        const store = _getObjectStore(this, TransactionMode.READ_WRITE);
-        const request = store.openCursor(null, direction);
-        return new Promise((resolve, reject) => {
-            let rows = [];
-            _request(request, (cursor) => {
-                if (!cursor) {
-                    resolve(rows);
-                    return;
-                }
-                rows.push(cursor.value);
-                cursor.continue();
-                store.delete(cursor.key);
-            }).catch((err) => {
-                reject(err);
-            });
-        });
-    }
-    multiple(indexName, each, keyRange, cursorDirection) {
-        const store = _getObjectStore(this);
-        const index = store.index(indexName);
-        const request = index.openCursor(keyRange, cursorDirection || CursorDirection.NEXT);
-        return new Promise((resolve, reject) => {
-            let rows = [];
-            _request(request, (cursor) => {
-                if (!cursor) {
-                    resolve(rows);
-                }
-                rows.push(cursor.value);
-                cursor.continue();
-            }).catch((err) => {
-                reject(err);
-            });
-        });
-    }
-}

package/lib/TableIndex.d.ts

@@ -1,7 +0,0 @@
-export default class TableIndex {
-    readonly name: string;
-    readonly column: Array<string> | string;
-    readonly unique: boolean;
-    readonly multiEntry: boolean;
-    constructor(name: string, column: Array<string> | string, unique?: boolean, multiEntry?: boolean);
-}

package/lib/TableIndex.js

@@ -1,10 +0,0 @@
-export default class TableIndex {
-    constructor(name, column, unique, multiEntry) {
-        this.unique = false;
-        this.multiEntry = false;
-        this.name = name;
-        this.column = column;
-        this.unique = !!unique;
-        this.multiEntry = !!multiEntry;
-    }
-}

package/lib/Utils.d.ts

@@ -1,2 +0,0 @@
-export declare function _instance(example: any, type: any): boolean;
-export declare function _copy(src: any, target: any): any;

package/lib/Utils.js

@@ -1,19 +0,0 @@
-export function _instance(example, type) {
-    let pro = type.prototype;
-    example = example.__proto__;
-    while (true) {
-        if (example === null)
-            return false;
-        if (pro === example)
-            return true;
-        example = example.__proto__;
-    }
-}
-export function _copy(src, target) {
-    if (!target)
-        return src;
-    for (let prop in src) {
-        target[prop] = src[prop];
-    }
-    return target;
-}