@bbn/bbn 2.0.237 → 2.0.239

package/dist/com.js

@@ -1,13 +1,5 @@
-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());
-    });
-};
 class Cancel extends Error {
+    __BBN_CANCEL__;
     constructor(message) {
         super(message || 'Request canceled');
         this.name = 'Cancel';
@@ -48,7 +40,7 @@ const fetchRequest = (method, url, config = {}, aborter) => {
     const fetchConfig = {
         method,
         headers: new Headers(config.headers || {}),
-        signal: aborter === null || aborter === void 0 ? void 0 : aborter.signal,
+        signal: aborter?.signal,
     };
     const hasBody = methodsWithBody.includes(method.toUpperCase());
     if (config.data != null && hasBody) {
@@ -66,25 +58,25 @@ const fetchRequest = (method, url, config = {}, aborter) => {
         const usp = new URLSearchParams(config.params).toString();
         url += (url.includes('?') ? '&' : '?') + usp;
     }
-    const fetchPromise = fetch(url, fetchConfig).then((res) => __awaiter(void 0, void 0, void 0, function* () {
+    const fetchPromise = fetch(url, fetchConfig).then(async (res) => {
         let data;
         const contentType = res.headers.get('content-type') || '';
         try {
             if (contentType.includes('application/json')) {
-                data = yield res.json();
+                data = await res.json();
             }
             else if (contentType.startsWith('text/')) {
-                data = yield res.text();
+                data = await res.text();
             }
             else if (contentType.includes("multipart/")) {
-                data = yield res.arrayBuffer();
+                data = await res.arrayBuffer();
             }
             else {
-                data = yield res.blob();
+                data = await res.blob();
             }
         }
-        catch (_a) {
-            data = yield res.text();
+        catch {
+            data = await res.text();
         }
         const response = {
             data,
@@ -103,7 +95,7 @@ const fetchRequest = (method, url, config = {}, aborter) => {
             throw error;
         }
         return response;
-    })).catch((err) => {
+    }).catch((err) => {
         if (err.name === 'AbortError') {
             throw new Cancel('Request canceled');
         }
@@ -302,7 +294,7 @@ onProgress, onChunkProgress, headers = {}, uploadId }) => {
             xhr.send(chunk);
         });
     }
-    const promise = (() => __awaiter(void 0, void 0, void 0, function* () {
+    const promise = (async () => {
         try {
             let lastResponse = null;
             for (let chunkIndex = 0; chunkIndex < totalChunks; chunkIndex++) {
@@ -312,7 +304,7 @@ onProgress, onChunkProgress, headers = {}, uploadId }) => {
                 const start = chunkIndex * chunkSize;
                 const end = Math.min(start + chunkSize, totalSize);
                 const chunk = file.slice(start, end);
-                lastResponse = yield createChunkRequest(chunk, chunkIndex);
+                lastResponse = await createChunkRequest(chunk, chunkIndex);
             }
             // All chunks uploaded
             return {
@@ -323,7 +315,7 @@ onProgress, onChunkProgress, headers = {}, uploadId }) => {
         finally {
             currentXhr = null;
         }
-    }))();
+    })();
     // Attach cancel method to the promise
     promise.cancel = () => {
         aborted = true;

package/dist/{vars.d.ts → data.d.ts}

@@ -15,6 +15,7 @@ declare const _default: {
     };
     comparators: string[];
     operators: string[];
+    dbRequestId: number;
     tags: string[];
     colors: {
         darkgrey: string;

package/dist/{vars.js → data.js}

@@ -52,6 +52,7 @@ export default {
     },
     comparators: [">=", "<=", ">", "<", "="],
     operators: ["+", "-", "/", "*"],
+    dbRequestId: 0,
     tags: ['a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'menu', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section', 'select', 'slot', 'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'u', 'ul', 'var', 'video', 'wbr'],
     colors: {
         darkgrey: '#5a6a62',

package/dist/db/classes/Center.d.ts

@@ -0,0 +1,10 @@
+export default class bbnDbCenter {
+    private queues;
+    handleMessage(event: MessageEvent): Promise<boolean>;
+    private execute;
+    private executeManager;
+    private executeObject;
+    private postSuccess;
+    private postError;
+    private serializeError;
+}

package/dist/db/classes/Center.js

@@ -0,0 +1,88 @@
+import bbnDb from './Object.js';
+export default class bbnDbCenter {
+    queues = {};
+    async handleMessage(event) {
+        const command = event.data;
+        const port = event.ports?.[0];
+        bbn.fn.log("Received DB command:", command, port, "END");
+        if (!port || !command?.method?.includes('.')) {
+            return false;
+        }
+        const [scope] = command.method.split('.');
+        if (scope !== 'manager' && scope !== 'object') {
+            return false;
+        }
+        if (!command.id || !command.database) {
+            this.postError(port, command?.id ?? 0, 'Invalid DB command');
+            return true;
+        }
+        const database = command.database;
+        this.queues[database] = (this.queues[database] || Promise.resolve())
+            .catch(() => undefined)
+            .then(async () => {
+            try {
+                const result = await this.execute(command);
+                this.postSuccess(port, command.id, result);
+            }
+            catch (error) {
+                this.postError(port, command.id, this.serializeError(error));
+            }
+        });
+        return true;
+    }
+    async execute(command) {
+        const [scope, action] = command.method.split('.');
+        if (!action) {
+            throw new Error(`Invalid DB method: ${command.method}`);
+        }
+        if (scope === 'manager') {
+            return this.executeManager(action, command.args || []);
+        }
+        if (scope === 'object') {
+            return this.executeObject(action, [command.database, ...(command.args || [])]);
+        }
+        throw new Error(`Unknown DB command scope: ${scope}`);
+    }
+    async executeManager(action, args) {
+        const fn = bbnDb[action];
+        if (typeof fn !== 'function') {
+            throw new Error(`Unknown DB manager method: ${action}`);
+        }
+        return fn.apply(bbnDb, args);
+    }
+    async executeObject(action, args) {
+        const [database, ...methodArgs] = args;
+        if (!database) {
+            throw new Error('Missing database name for object method');
+        }
+        bbn.fn.log(`Executing object method: ${action} on database: ${database}`);
+        const dbo = await bbnDb.open(database);
+        const fn = dbo[action];
+        if (typeof fn !== 'function') {
+            throw new Error(`Unknown DB object method: ${action}`);
+        }
+        return fn.apply(dbo, methodArgs);
+    }
+    postSuccess(port, id, result) {
+        port.postMessage({
+            id,
+            ok: true,
+            result
+        });
+        port.close();
+    }
+    postError(port, id, error) {
+        port.postMessage({
+            id,
+            ok: false,
+            error
+        });
+        port.close();
+    }
+    serializeError(error) {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        return String(error);
+    }
+}

package/dist/db/classes/Object.d.ts

@@ -0,0 +1,3 @@
+import { DbManagerInternal } from '../types.js';
+declare const db: DbManagerInternal;
+export default db;

package/dist/db/classes/Object.js

@@ -0,0 +1,469 @@
+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';
+import transactionDone from '../functions/transactionDone.js';
+import getPrimaryKey from '../functions/getPrimaryKey.js';
+import requestToPromise from '../functions/requestToPromise.js';
+import transformResult from '../functions/transformResult.js';
+import fieldsFromFilter from '../functions/fieldsFromFilter.js';
+import bbnDbObjectProxy from './ObjectProxy.js';
+const idb = globalThis.indexedDB ||
+    globalThis.webkitIndexedDB ||
+    globalThis.mozIndexedDB ||
+    globalThis.OIndexedDB ||
+    globalThis.msIndexedDB;
+class DbObject {
+    _dbName;
+    lastErr = null;
+    constructor(dbName) {
+        this._dbName = dbName;
+    }
+    get dbName() {
+        return this._dbName;
+    }
+    hasMissingStores(database, conn) {
+        const structures = db._structures[database] || {};
+        return Object.keys(structures).some(storeName => !conn.objectStoreNames.contains(storeName));
+    }
+    async getConnection(database = '') {
+        let conn = db._connections[database || this.dbName];
+        if (!conn) {
+            debugger;
+            log("Opening connection through getConnection to database: " + (database || this.dbName));
+            await 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;
+    }
+    async getStore(table, mode) {
+        const connection = await this.getConnection();
+        if (!this.structure[table]) {
+            log("No structure for table: " + table, this.structure, db._structures);
+            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() {
+        return db.close(this.dbName);
+    }
+    async insert(table, data) {
+        const rows = Array.isArray(data) ? data : [data];
+        if (!rows.length) {
+            return 0;
+        }
+        const [tx, store] = await 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);
+            };
+        }
+        await transactionDone(tx);
+        return inserted;
+    }
+    async update(table, data, where, replace = false) {
+        const rows = await 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] = await 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);
+            };
+        }
+        await transactionDone(tx);
+        return updated;
+    }
+    async delete(table, where) {
+        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] = await this.getStore(table, 'readwrite');
+        store.delete(where[primary]);
+        await transactionDone(tx);
+        return 1;
+    }
+    async selectOne(table, field, where = null, order = null, start = 0, limit = 1) {
+        const rows = await this.selectAll(table, [field], where, order, start, limit);
+        return rows?.[0]?.[field];
+    }
+    async select(table, fields = [], where = null, order = null, start = 0) {
+        const rows = await this.selectAll(table, fields, where, order, start, 1);
+        return rows.length ? rows[0] : null;
+    }
+    async selectAll(table, fields = [], where = null, order = null, start = 0, limit = null) {
+        void order;
+        const [tx, store] = await 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?.[primary])) {
+                const ids = where[primary];
+                const max = Math.min(ids.length - start, limit ?? ids.length);
+                const slice = ids.slice(start, start + max);
+                for (const id of slice) {
+                    const row = await requestToPromise(store.get(id));
+                    const transformed = transformResult(row, fields);
+                    if (transformed) {
+                        results.push(transformed);
+                    }
+                }
+                await transactionDone(tx);
+                return results;
+            }
+            const key = isObject(where)
+                ? where[primary]
+                : where;
+            const row = await requestToPromise(store.get(key));
+            const transformed = transformResult(row, fields);
+            if (transformed) {
+                results.push(transformed);
+            }
+            await transactionDone(tx);
+            return results;
+        }
+        await new Promise((resolve, reject) => {
+            const req = store.openCursor();
+            let i = 0;
+            req.onsuccess = (e) => {
+                const cursor = e.target.result;
+                if (!cursor) {
+                    resolve();
+                    return;
+                }
+                const matches = !where || !globalThis.bbn?.fn?.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);
+            };
+        });
+        await transactionDone(tx);
+        return results;
+    }
+    async getColumnValues(table, field, where = null, order = null, start = 0, limit = null) {
+        const rows = await this.selectAll(table, fieldsFromFilter(where, [field]), where, order, start, limit);
+        return rows
+            .map(row => row[field])
+            .filter(v => v !== undefined);
+    }
+    async copyTable(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 = await this.getConnection();
+        if (!connection.objectStoreNames.contains(target)) {
+            connection.close();
+            await db.add(this.dbName, target, this.structure[table]);
+            connection = await this.getConnection();
+        }
+        if (!connection.objectStoreNames.contains(target)) {
+            throw new Error(_('The target table %s does not exist', target));
+        }
+        const rows = await this.selectAll(table, fields, where, order, start, limit);
+        if (!rows.length) {
+            return 0;
+        }
+        const res = await this.insert(target, rows);
+        connection.close();
+        return res;
+    }
+    async deleteTable(table) {
+        await 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];
+            log("Closing connection to database: " + database);
+        }
+        if (this._objects[database]) {
+            delete this._objects[database];
+        }
+    },
+    updateStructure(storeName, structure, database) {
+        log("fn updateStructure, table: " + storeName + ", in SW? " + !globalThis.document);
+        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 });
+                }
+            });
+        }
+    },
+    async importStructure(database, structure) {
+        log("fn importStructure");
+        if (!this._structures[database]) {
+            this._structures[database] = {};
+        }
+        if (!this._connections[database]) {
+            await this.open(database);
+        }
+        const conn = this._connections[database];
+        let upgrade = false;
+        for (const storeName in structure) {
+            if (!structure[storeName]?.keys?.PRIMARY || !structure[storeName]?.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) {
+            await this.reopenWithUpgrade(database);
+        }
+        this.close(database);
+    },
+    async getExistingVersion(name) {
+        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);
+        });
+    },
+    async reopenWithUpgrade(name) {
+        log("fn reopenWithUpgrade", this._structures);
+        if (!this._structures[name]) {
+            throw new Error(_('Impossible to find a structure for the database %s', name));
+        }
+        const existingVersion = await this.getExistingVersion(name) || 0;
+        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 await this.open(name, nextVersion);
+    },
+    async open(database, version) {
+        log("fn open database " + database + " version " + version, this._structures);
+        if (database !== 'bbn') {
+            log("THERE SHOULD BE A DEBUGGER!!!!!!!");
+            debugger;
+        }
+        if (!idb) {
+            throw new Error(_('IndexedDB is not available'));
+        }
+        if (navigator.serviceWorker?.controller) {
+            return new Promise(resolve => resolve(new bbnDbObjectProxy(database)));
+        }
+        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];
+        }
+        await 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];
+    },
+    async add(database, name, structure) {
+        log("fn add " + name);
+        if (!structure?.keys?.PRIMARY || !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));
+        }
+        await 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 = await 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;
+    },
+    async remove(database, name) {
+        log("fn remove");
+        const currentStructure = this._structures[database];
+        if (!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);
+            await 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;
+        }
+    }
+};
+export default db;