@bbn/bbn 2.0.237 → 2.0.238

package/dist/db.js

@@ -1,558 +1,2 @@
-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 _ from './_.js';
-import iterate from './fn/loop/iterate.js';
-import log from './fn/browser/log.js';
-import isObject from './fn/type/isObject.js';
-import isArray from './fn/type/isArray.js';
-import extend from './fn/object/extend.js';
-const idb = globalThis.indexedDB ||
-    globalThis.webkitIndexedDB ||
-    globalThis.mozIndexedDB ||
-    globalThis.OIndexedDB ||
-    globalThis.msIndexedDB;
-const transformResult = (obj, fields) => {
-    if (!obj) {
-        return undefined;
-    }
-    if (fields === null || fields === void 0 ? void 0 : fields.length) {
-        const res = {};
-        iterate(obj, (v, n) => {
-            if (fields.includes(n)) {
-                res[n] = v;
-            }
-        });
-        return res;
-    }
-    return obj;
-};
-const fieldsFromFilter = (filter, fields = []) => {
-    var _a;
-    if ((_a = filter === null || filter === void 0 ? void 0 : filter.conditions) === null || _a === void 0 ? void 0 : _a.length) {
-        filter.conditions.forEach((cond) => {
-            if (cond.field && !fields.includes(cond.field)) {
-                fields.push(cond.field);
-            }
-            else if (cond.conditions) {
-                fieldsFromFilter(cond, fields);
-            }
-        });
-    }
-    else if (isObject(filter)) {
-        iterate(filter, (_v, n) => {
-            if (!fields.includes(n)) {
-                fields.push(n);
-            }
-        });
-    }
-    else if (isArray(filter)) {
-        filter.forEach((cond) => {
-            if (cond.field && !fields.includes(cond.field)) {
-                fields.push(cond.field);
-            }
-            else if (cond.conditions) {
-                fieldsFromFilter(cond, fields);
-            }
-        });
-    }
-    return fields;
-};
-const getPrimaryKey = (structure) => {
-    var _a, _b;
-    if (!((_b = (_a = structure.keys) === null || _a === void 0 ? void 0 : _a.PRIMARY) === null || _b === void 0 ? void 0 : _b.columns)) {
-        throw new Error(_('No primary key defined in the structure'));
-    }
-    const cols = structure.keys.PRIMARY.columns;
-    return cols.length > 1 ? cols : cols[0];
-};
-const requestToPromise = (req) => new Promise((resolve, reject) => {
-    req.onsuccess = () => resolve(req.result);
-    req.onerror = () => reject(req.error);
-});
-const transactionDone = (tx) => new Promise((resolve, reject) => {
-    tx.oncomplete = () => resolve();
-    tx.onabort = () => reject(tx.error);
-    tx.onerror = () => reject(tx.error);
-});
-class DbObject {
-    constructor(dbName) {
-        this.lastErr = null;
-        this.dbName = dbName;
-    }
-    hasMissingStores(database, conn) {
-        const structures = db._structures[database] || {};
-        return Object.keys(structures).some(storeName => !conn.objectStoreNames.contains(storeName));
-    }
-    getConnection() {
-        return __awaiter(this, arguments, void 0, function* (database = '') {
-            let conn = db._connections[database || this.dbName];
-            if (!conn) {
-                debugger;
-                yield db.open(database || this.dbName);
-                if (!db._connections[database || this.dbName]) {
-                    throw new Error(_('The database %s is not open', this.dbName));
-                }
-                conn = db._connections[database || this.dbName];
-            }
-            return conn;
-        });
-    }
-    get structure() {
-        const structure = db._structures[this.dbName];
-        if (!structure) {
-            throw new Error(_('No structure defined for database %s', this.dbName));
-        }
-        return structure;
-    }
-    getStore(table, mode) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const connection = yield this.getConnection();
-            if (!this.structure[table]) {
-                throw new Error(_('Table %s is not defined in database structure %s', table, this.dbName));
-            }
-            if (!connection.objectStoreNames.contains(table)) {
-                throw new Error(_('Table %s does not exist in database %s. Schema upgrade required.', table, this.dbName));
-            }
-            const tx = connection.transaction([table], mode);
-            tx.onabort = () => {
-                this.lastErr = tx.error;
-                log("Abort in store transaction: " + table, tx.error);
-            };
-            tx.onerror = () => {
-                this.lastErr = tx.error;
-                log("Error in store transaction: " + table, tx.error);
-            };
-            try {
-                const os = tx.objectStore(table);
-                return [tx, os];
-            }
-            catch (e) {
-                this.lastErr = e;
-                log("Error getting object store: " + table, e);
-                throw new Error(_('Error getting table %s from database %s', table, this.dbName));
-            }
-        });
-    }
-    lastError() {
-        return this.lastErr;
-    }
-    close() {
-        const conn = db._connections[this.dbName];
-        if (conn) {
-            conn.close();
-            delete db._connections[this.dbName];
-        }
-    }
-    insert(table, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const rows = Array.isArray(data) ? data : [data];
-            if (!rows.length) {
-                return 0;
-            }
-            const [tx, store] = yield this.getStore(table, 'readwrite');
-            let inserted = 0;
-            for (const row of rows) {
-                const req = store.put(row);
-                req.onsuccess = () => {
-                    inserted++;
-                };
-                req.onerror = () => {
-                    this.lastErr = req.error;
-                    log(req.error);
-                };
-            }
-            yield transactionDone(tx);
-            return inserted;
-        });
-    }
-    update(table_1, data_1, where_1) {
-        return __awaiter(this, arguments, void 0, function* (table, data, where, replace = false) {
-            const rows = yield this.selectAll(table, [], where);
-            if (!rows.length) {
-                return 0;
-            }
-            const structure = this.structure[table];
-            const primary = getPrimaryKey(structure);
-            if (Array.isArray(primary)) {
-                throw new Error(_('Composite primary keys are not supported by this update implementation'));
-            }
-            const [tx, store] = yield this.getStore(table, 'readwrite');
-            let updated = 0;
-            for (const row of rows) {
-                const nextRow = extend({}, replace ? { [primary]: row[primary] } : row, data);
-                if (!(primary in nextRow)) {
-                    throw new Error(_('No primary key in the data'));
-                }
-                const req = store.put(nextRow);
-                req.onsuccess = () => {
-                    updated++;
-                };
-                req.onerror = () => {
-                    this.lastErr = req.error;
-                    log(req.error);
-                };
-            }
-            yield transactionDone(tx);
-            return updated;
-        });
-    }
-    delete(table, where) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const structure = this.structure[table];
-            const primary = getPrimaryKey(structure);
-            if (Array.isArray(primary)) {
-                throw new Error(_('Composite primary keys are not supported by this delete implementation'));
-            }
-            if (!(primary in where)) {
-                throw new Error(_('No primary key in the filter'));
-            }
-            const [tx, store] = yield this.getStore(table, 'readwrite');
-            store.delete(where[primary]);
-            yield transactionDone(tx);
-            return 1;
-        });
-    }
-    selectOne(table_1, field_1) {
-        return __awaiter(this, arguments, void 0, function* (table, field, where = null, order = null, start = 0, limit = 1) {
-            var _a;
-            const rows = yield this.selectAll(table, [field], where, order, start, limit);
-            return (_a = rows === null || rows === void 0 ? void 0 : rows[0]) === null || _a === void 0 ? void 0 : _a[field];
-        });
-    }
-    select(table_1) {
-        return __awaiter(this, arguments, void 0, function* (table, fields = [], where = null, order = null, start = 0) {
-            const rows = yield this.selectAll(table, fields, where, order, start, 1);
-            return rows.length ? rows[0] : null;
-        });
-    }
-    selectAll(table_1) {
-        return __awaiter(this, arguments, void 0, function* (table, fields = [], where = null, order = null, start = 0, limit = null) {
-            void order;
-            const [tx, store] = yield this.getStore(table, 'readonly');
-            const structure = this.structure[table];
-            const primary = getPrimaryKey(structure);
-            const results = [];
-            const searchField = isObject(where)
-                ? Object.keys(where)[0]
-                : (!where || isArray(where) ? null : primary);
-            if (!Array.isArray(primary) && searchField === primary) {
-                if (Array.isArray(where === null || where === void 0 ? void 0 : where[primary])) {
-                    const ids = where[primary];
-                    const max = Math.min(ids.length - start, limit !== null && limit !== void 0 ? limit : ids.length);
-                    const slice = ids.slice(start, start + max);
-                    for (const id of slice) {
-                        const row = yield requestToPromise(store.get(id));
-                        const transformed = transformResult(row, fields);
-                        if (transformed) {
-                            results.push(transformed);
-                        }
-                    }
-                    yield transactionDone(tx);
-                    return results;
-                }
-                const key = isObject(where)
-                    ? where[primary]
-                    : where;
-                const row = yield requestToPromise(store.get(key));
-                const transformed = transformResult(row, fields);
-                if (transformed) {
-                    results.push(transformed);
-                }
-                yield transactionDone(tx);
-                return results;
-            }
-            yield new Promise((resolve, reject) => {
-                const req = store.openCursor();
-                let i = 0;
-                req.onsuccess = (e) => {
-                    var _a, _b;
-                    const cursor = e.target.result;
-                    if (!cursor) {
-                        resolve();
-                        return;
-                    }
-                    const matches = !where || !((_b = (_a = globalThis.bbn) === null || _a === void 0 ? void 0 : _a.fn) === null || _b === void 0 ? void 0 : _b.search)
-                        ? true
-                        : 0 === globalThis.bbn.fn.search([cursor.value], where);
-                    if (matches) {
-                        if (i >= start) {
-                            const transformed = transformResult(cursor.value, fields);
-                            if (transformed) {
-                                results.push(transformed);
-                            }
-                            if (limit !== null && results.length >= limit) {
-                                resolve();
-                                return;
-                            }
-                        }
-                        i++;
-                    }
-                    cursor.continue();
-                };
-                req.onerror = () => {
-                    this.lastErr = req.error;
-                    log(req.error);
-                    reject(req.error);
-                };
-            });
-            yield transactionDone(tx);
-            return results;
-        });
-    }
-    getColumnValues(table_1, field_1) {
-        return __awaiter(this, arguments, void 0, function* (table, field, where = null, order = null, start = 0, limit = null) {
-            const rows = yield this.selectAll(table, fieldsFromFilter(where, [field]), where, order, start, limit);
-            return rows
-                .map(row => row[field])
-                .filter(v => v !== undefined);
-        });
-    }
-    copyTable(target_1, table_1) {
-        return __awaiter(this, arguments, void 0, function* (target, table, fields = [], where = null, order = null, start = 0, limit = null) {
-            if (!this.structure[table]) {
-                throw new Error(_('Source table %s does not exist in structure', table));
-            }
-            let connection = yield this.getConnection();
-            if (!connection.objectStoreNames.contains(target)) {
-                connection.close();
-                yield db.add(this.dbName, target, this.structure[table]);
-                connection = yield this.getConnection();
-            }
-            if (!connection.objectStoreNames.contains(target)) {
-                throw new Error(_('The target table %s does not exist', target));
-            }
-            const rows = yield this.selectAll(table, fields, where, order, start, limit);
-            if (!rows.length) {
-                return 0;
-            }
-            const res = yield this.insert(target, rows);
-            connection.close();
-            return res;
-        });
-    }
-    deleteTable(table) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield db.remove(this.dbName, table);
-            return true;
-        });
-    }
-}
-const db = {
-    _structures: {},
-    _connections: {},
-    _objects: {},
-    _stores: {},
-    ok: idb !== undefined,
-    close(database) {
-        const conn = this._connections[database];
-        if (conn) {
-            conn.close();
-            delete this._connections[database];
-        }
-        if (this._objects[database]) {
-            delete this._objects[database];
-        }
-    },
-    updateStructure(storeName, structure, database) {
-        const primary = getPrimaryKey(structure);
-        if (!database.objectStoreNames.contains(storeName)) {
-            const store = database.createObjectStore(storeName, {
-                keyPath: primary
-            });
-            iterate(structure.keys, (a, n) => {
-                if (n !== 'PRIMARY') {
-                    store.createIndex(n, a.columns.length > 1 ? a.columns : a.columns[0], { unique: !!a.unique });
-                }
-            });
-        }
-    },
-    importStructure(database, structure) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
-            if (!this._structures[database]) {
-                this._structures[database] = {};
-            }
-            if (this._connections[database]) {
-                throw new Error(_('Database %s is already open. Close it before adding a new store.', database));
-            }
-            yield this.open(database);
-            let conn = this._connections[database];
-            let upgrade = false;
-            for (const storeName in structure) {
-                if (!((_b = (_a = structure[storeName]) === null || _a === void 0 ? void 0 : _a.keys) === null || _b === void 0 ? void 0 : _b.PRIMARY) || !((_c = structure[storeName]) === null || _c === void 0 ? void 0 : _c.fields)) {
-                    log("Error on importStructure with store " + storeName, structure[storeName]);
-                    throw new Error(_('The database structure for %s is not valid (missing keys, fields, or primary key)', storeName));
-                }
-                this._structures[database][storeName] = structure[storeName];
-                // DB exists already: open temporarily and check if store exists
-                const hasStore = conn.objectStoreNames.contains(storeName);
-                if (!hasStore) {
-                    upgrade = true;
-                }
-            }
-            if (upgrade) {
-                yield this.reopenWithUpgrade(database);
-            }
-            this.close(database);
-        });
-    },
-    getExistingVersion(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const live = this._connections[name];
-            if (live) {
-                return live.version;
-            }
-            return new Promise((resolve, reject) => {
-                if (!idb) {
-                    reject(new Error(_('IndexedDB is not available')));
-                    return;
-                }
-                const req = idb.open(name);
-                req.onsuccess = () => {
-                    const database = req.result;
-                    const version = database.version;
-                    database.close();
-                    resolve(version);
-                };
-                req.onupgradeneeded = () => {
-                    // Database did not exist before; this open created it temporarily.
-                    // Version is therefore effectively 1.
-                    const database = req.result;
-                    const version = database.version;
-                    database.close();
-                    resolve(version);
-                };
-                req.onerror = () => reject(req.error);
-            });
-        });
-    },
-    reopenWithUpgrade(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._structures[name]) {
-                throw new Error(_('Impossible to find a structure for the database %s', name));
-            }
-            const existingVersion = yield this.getExistingVersion(name);
-            const nextVersion = existingVersion + 1;
-            log(_('Going from version %s to version %s for database %s', existingVersion, nextVersion, name));
-            if (this._connections[name]) {
-                this.close(name);
-            }
-            return yield this.open(name, nextVersion);
-        });
-    },
-    open(database, version) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!idb) {
-                throw new Error(_('IndexedDB is not available'));
-            }
-            if (!this._structures[database]) {
-                throw new Error(_('Impossible to find a structure for the database %s', database));
-            }
-            if (this._objects[database] && this._connections[database]) {
-                return this._objects[database];
-            }
-            yield new Promise((resolve, reject) => {
-                const req = version ? idb.open(database, version) : idb.open(database);
-                req.onupgradeneeded = () => {
-                    const db = req.result;
-                    this._connections[database] = req.result;
-                    const dbStructure = this._structures[database] || {};
-                    iterate(dbStructure, (structure, storeName) => {
-                        if (!db.objectStoreNames.contains(storeName)) {
-                            this.updateStructure(storeName, structure, db);
-                        }
-                    });
-                };
-                req.onsuccess = () => {
-                    this._connections[database] = req.result;
-                    resolve(req.result);
-                };
-                req.onerror = () => reject(req.error);
-                req.onblocked = (event) => {
-                    reject(_('open: Upgrade blocked for database %s. Please close other connections to proceed.', database));
-                };
-            });
-            this._objects[database] = new DbObject(database);
-            return this._objects[database];
-        });
-    },
-    add(database, name, structure) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (!((_a = structure === null || structure === void 0 ? void 0 : structure.keys) === null || _a === void 0 ? void 0 : _a.PRIMARY) || !(structure === null || structure === void 0 ? void 0 : structure.fields)) {
-                log("Error on add", structure);
-                throw new Error(_('The database structure for %s is not valid (missing keys, fields, or primary key)', name));
-            }
-            if (!this._structures[database]) {
-                this._structures[database] = {};
-            }
-            this._structures[database][name] = structure;
-            if (this._connections[database]) {
-                throw new Error(_('Database %s is already open. Close it before adding a new store.', database));
-            }
-            yield this.open(database);
-            let conn = this._connections[database];
-            // DB exists already: open temporarily and check if store exists
-            const hasStore = conn.objectStoreNames.contains(name);
-            if (!hasStore) {
-                const tmp = yield this.reopenWithUpgrade(database);
-                if (!this._connections[database]) {
-                    throw new Error(_('The database %s is not open after upgrade', database));
-                }
-                conn = this._connections[database];
-            }
-            this.close(database);
-            return true;
-        });
-    },
-    remove(database, name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const currentStructure = this._structures[database];
-            if (!(currentStructure === null || currentStructure === void 0 ? void 0 : currentStructure[name])) {
-                return;
-            }
-            const old = currentStructure[name];
-            delete currentStructure[name];
-            try {
-                const conn = this._connections[database];
-                if (!conn) {
-                    return;
-                }
-                const nextVersion = conn.version + 1;
-                this.close(database);
-                yield new Promise((resolve, reject) => {
-                    if (!idb) {
-                        reject(new Error(_('IndexedDB is not available')));
-                        return;
-                    }
-                    const req = idb.open(database, nextVersion);
-                    req.onupgradeneeded = () => {
-                        const dbInstance = req.result;
-                        if (dbInstance.objectStoreNames.contains(name)) {
-                            dbInstance.deleteObjectStore(name);
-                            dbInstance.close();
-                        }
-                    };
-                    req.onsuccess = () => {
-                        req.result.close();
-                        resolve();
-                    };
-                    req.onerror = () => reject(req.error);
-                    req.onblocked = () => reject(new Error(_('Remove blocked for database %s', database)));
-                });
-            }
-            catch (e) {
-                currentStructure[name] = old;
-                throw e;
-            }
-        });
-    }
-};
+import db from './db/classes/Object.js';
 export default db;

package/dist/dt/classes/{date.d.ts → Date.d.ts}

@@ -1,5 +1,5 @@
 import { Temporal } from 'temporal-polyfill';
-import bbnDt from './dt.js';
+import bbnDt from './Dt.js';
 export default class bbnDtDate extends bbnDt<Temporal.PlainDate> {
     readonly kind: bbnDtKind;
     constructor(y?: any, m?: number, d?: number);

package/dist/dt/classes/{date.js → Date.js}

@@ -1,7 +1,8 @@
 import { Temporal } from 'temporal-polyfill';
-import bbnDt from './dt.js';
+import bbnDt from './Dt.js';
 import getRow from '../../fn/object/getRow.js';
 export default class bbnDtDate extends bbnDt {
+    kind = 'date';
     constructor(y, m, d) {
         let value;
         if (!y) {
@@ -26,7 +27,6 @@ export default class bbnDtDate extends bbnDt {
             value = new Temporal.PlainDate(y, m, d || 1);
         }
         super(value);
-        this.kind = 'date';
     }
     compareSameKind(other) {
         const cmp = Temporal.PlainDate.compare(this.value, other.value);
@@ -48,7 +48,12 @@ export default class bbnDtDate extends bbnDt {
     }
     fdate(long = false, weekday = false) {
         const date = new Date(this.year(), this.month() - 1, this.day());
-        const opt = Object.assign({ year: 'numeric', month: long ? 'long' : 'numeric', day: 'numeric' }, (weekday ? { weekday: (long ? 'long' : 'short') } : {}));
+        const opt = {
+            year: 'numeric',
+            month: long ? 'long' : 'numeric',
+            day: 'numeric',
+            ...(weekday ? { weekday: (long ? 'long' : 'short') } : {}),
+        };
         const d = new Intl.DateTimeFormat([bbn.env.lang, ...navigator.languages], opt);
         return d.format(date);
     }

package/dist/dt/classes/{dateTime.d.ts → DateTime.d.ts}

@@ -1,5 +1,5 @@
 import { Temporal } from 'temporal-polyfill';
-import bbnDt from './dt.js';
+import bbnDt from './Dt.js';
 export default class bbnDtDateTime extends bbnDt<Temporal.PlainDateTime> {
     readonly kind: bbnDtKind;
     constructor(y?: any, m?: number, d?: number, h?: number, i?: number, s?: number, ms?: number);

package/dist/dt/classes/{dateTime.js → DateTime.js}

@@ -1,7 +1,8 @@
 import { Temporal } from 'temporal-polyfill';
-import bbnDt from './dt.js';
+import bbnDt from './Dt.js';
 import getRow from '../../fn/object/getRow.js';
 export default class bbnDtDateTime extends bbnDt {
+    kind = 'dateTime';
     constructor(y, m, d, h, i, s, ms) {
         let value;
         if (!y) {
@@ -25,7 +26,6 @@ export default class bbnDtDateTime extends bbnDt {
             value = new Temporal.PlainDateTime(y, m, d || 1, h || 0, i || 0, s || 0, ms || 0);
         }
         super(value);
-        this.kind = 'dateTime';
     }
     format(format) {
         // long
@@ -43,7 +43,13 @@ export default class bbnDtDateTime extends bbnDt {
             return '';
         }
         const date = new Date(this.year(), this.month() - 1, this.day(), this.hour(), this.minute(), this.second());
-        const opt = Object.assign(Object.assign({ year: 'numeric', month: long ? 'long' : '2-digit', day: '2-digit' }, (weekday ? { weekday: (long ? 'long' : 'short') } : {})), (withTime ? { hour: (long ? '2-digit' : 'numeric'), minute: '2-digit' } : {}));
+        const opt = {
+            year: 'numeric',
+            month: long ? 'long' : '2-digit',
+            day: '2-digit',
+            ...(weekday ? { weekday: (long ? 'long' : 'short') } : {}),
+            ...(withTime ? { hour: (long ? '2-digit' : 'numeric'), minute: '2-digit' } : {})
+        };
         const d = new Intl.DateTimeFormat([bbn.env.lang, ...navigator.languages], opt);
         return d.format(date);
     }

package/dist/dt/classes/{dt.d.ts → Dt.d.ts}

@@ -1,6 +1,6 @@
 import { Temporal } from 'temporal-polyfill';
 import { bbnDtTemporal } from '../vars/types.js';
-import bbnDtDuration from './duration.js';
+import bbnDtDuration from './Duration.js';
 export declare abstract class bbnDt<TValue extends bbnDtTemporal> {
     #private;
     abstract readonly kind: bbnDtKind;