adapter-sqlite-cordova
Version:
Run SQLite on the device and IndexedDB in the browser with exactly the same API with nanoSQL 2!
1,184 lines (1,178 loc) • 327 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else {
var a = factory();
for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
}
})(window, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 8);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
var leven = __webpack_require__(3);
var equal = __webpack_require__(4);
exports.blankTableDefinition = {
id: "",
count: 0,
name: "",
rowLocks: {},
model: {},
columns: [],
indexes: {},
actions: [],
queries: {},
views: [],
pkType: "string",
pkCol: [],
isPkNum: false,
ai: false
};
/**
* Searches a sorted array for a given value.
*
* @param {any[]} arr
* @param {*} value
* @param {boolean} indexOf
* @param {number} [startVal]
* @param {number} [endVal]
* @returns {number}
*/
exports.binarySearch = function (arr, value, indexOf, startVal, endVal) {
var start = startVal || 0;
var end = endVal || arr.length;
if (arr[start] >= value)
return indexOf ? -1 : start;
if (arr[end] <= value)
return indexOf ? -1 : end + 1;
var m = Math.floor((start + end) / 2);
if (value == arr[m])
return m;
if (end - 1 == start)
return indexOf ? -1 : end;
if (value > arr[m])
return exports.binarySearch(arr, value, indexOf, m, end);
if (value < arr[m])
return exports.binarySearch(arr, value, indexOf, start, m);
return indexOf ? -1 : end;
};
/**
* Converts a word to title case.
*
* @param {string} str
* @returns
*/
exports.titleCase = function (str) {
return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
};
exports.slugify = function (str) {
return String(str).replace(/\s+/g, "-").replace(/[^0-9a-z\-]/gi, "").toLowerCase();
};
exports.buildQuery = function (selectedDB, nSQL, table, action) {
return {
databaseID: selectedDB,
table: table || nSQL.selectedTable,
parent: nSQL,
action: action,
state: "pending",
result: [],
time: Date.now(),
queryID: exports.fastID(),
extend: [],
comments: [],
tags: []
};
};
exports.keyToDate = function (nSQL, type, pk) {
if (!pk)
return pk;
if (type === "date") {
return Date.parse(pk);
}
return pk;
};
exports.adapterFilters = function (selectedDB, nSQL, query) {
return {
write: function (table, pk, row, complete, error) {
if (!selectedDB)
return;
pk = exports.keyToDate(nSQL, nSQL.getDB(selectedDB)._tables[table].pkType, pk);
nSQL.doFilter(selectedDB, "adapterWrite", { res: { table: table, pk: pk, row: row, complete: complete, error: error }, query: query }, function (result) {
if (!result)
return; // filter took over
var adapter = nSQL.getDB(selectedDB)._tables[result.res.table].mode || nSQL.getDB(selectedDB).adapter;
adapter.write(nSQL.getDB(selectedDB)._tableIds[result.res.table], result.res.pk, result.res.row, function (pk) {
result.res.complete(pk);
}, result.res.error);
}, error);
},
read: function (table, pk, complete, error) {
if (!selectedDB)
return;
pk = exports.keyToDate(nSQL, nSQL.getDB(selectedDB)._tables[table].pkType, pk);
nSQL.doFilter(selectedDB, "adapterRead", { res: { table: table, pk: pk, complete: complete, error: error }, query: query }, function (result) {
if (!result)
return; // filter took over
var adapter = nSQL.getDB(selectedDB)._tables[result.res.table].mode || nSQL.getDB(selectedDB).adapter;
adapter.read(nSQL.getDB(selectedDB)._tableIds[result.res.table], result.res.pk, function (row) {
if (!row) {
result.res.complete(undefined);
return;
}
if (nSQL.getDB(selectedDB)._tables[result.res.table].pkType === "date") {
var setRow = __assign({}, row);
exports.deepSet(nSQL.getDB(selectedDB)._tables[result.res.table].pkCol, setRow, new Date(result.res.pk).toISOString());
result.res.complete(setRow);
}
else {
result.res.complete(row);
}
}, result.res.error);
}, error);
},
readMulti: function (table, type, offsetOrLow, limitOrHigh, reverse, onRow, complete, error) {
if (!selectedDB)
return;
offsetOrLow = exports.keyToDate(nSQL, nSQL.getDB(selectedDB)._tables[table].pkType, offsetOrLow);
limitOrHigh = exports.keyToDate(nSQL, nSQL.getDB(selectedDB)._tables[table].pkType, limitOrHigh);
nSQL.doFilter(selectedDB, "adapterReadMulti", { res: { table: table, type: type, offsetOrLow: offsetOrLow, limitOrHigh: limitOrHigh, reverse: reverse, onRow: onRow, complete: complete, error: error }, query: query }, function (result) {
if (!result)
return; // filter took over
var adapter = nSQL.getDB(selectedDB)._tables[result.res.table].mode || nSQL.getDB(selectedDB).adapter;
adapter.readMulti(nSQL.getDB(selectedDB)._tableIds[result.res.table], result.res.type, result.res.offsetOrLow, result.res.limitOrHigh, result.res.reverse, function (row, i) {
if (nSQL.getDB(selectedDB)._tables[result.res.table].pkType === "date") {
var setRow = __assign({}, row);
var pk = exports.deepGet(nSQL.getDB(selectedDB)._tables[result.res.table].pkCol, setRow);
exports.deepSet(nSQL.getDB(selectedDB)._tables[result.res.table].pkCol, setRow, new Date(pk).toISOString());
result.res.onRow(setRow, i);
}
else {
result.res.onRow(row, i);
}
}, function () {
result.res.complete();
}, result.res.error);
}, error);
},
connect: function (id, complete, error) {
if (!selectedDB)
return;
nSQL.doFilter(selectedDB, "adapterConnect", { res: { id: id, complete: complete, error: error }, query: query }, function (result) {
if (!result)
return; // filter took over
nSQL.getDB(selectedDB).adapter.connect(result.res.id, result.res.complete, result.res.error);
}, error);
},
disconnect: function (complete, error) {
if (!selectedDB)
return;
nSQL.doFilter(selectedDB, "adapterDisconnect", { res: { complete: complete, error: error }, query: query }, function (result) {
if (!result)
return; // filter took over
nSQL.getDB(selectedDB).adapter.disconnect(result.res.complete, result.res.error);
}, error);
},
createTable: function (table, tableData, complete, error) {
if (!selectedDB)
return;
nSQL.doFilter(selectedDB, "adapterCreateTable", { res: { table: table, tableData: tableData, complete: complete, error: error }, query: query }, function (result) {
if (!result)
return; // filter took over
var adapter = tableData.mode || nSQL.getDB(selectedDB).adapter;
adapter.createTable(nSQL.getDB(selectedDB)._tableIds[result.res.table], result.res.tableData, result.res.complete, result.res.error);
}, error);
},
dropTable: function (table, complete, error) {
if (!selectedDB)
return;
nSQL.doFilter(selectedDB, "adapterDropTable", { res: { table: table, complete: complete, error: error }, query: query }, function (result) {
if (!result)
return; // filter took over
var adapter = nSQL.getDB(selectedDB)._tables[result.res.table].mode || nSQL.getDB(selectedDB).adapter;
adapter.dropTable(nSQL.getDB(selectedDB)._tableIds[result.res.table], result.res.complete, result.res.error);
}, error);
},
delete: function (table, pk, complete, error) {
if (!selectedDB)
return;
pk = exports.keyToDate(nSQL, nSQL.getDB(selectedDB)._tables[table].pkType, pk);
nSQL.doFilter(selectedDB, "adapterDelete", { res: { table: table, pk: pk, complete: complete, error: error }, query: query }, function (result) {
if (!result)
return; // filter took over
var adapter = nSQL.getDB(selectedDB)._tables[result.res.table].mode || nSQL.getDB(selectedDB).adapter;
adapter.delete(nSQL.getDB(selectedDB)._tableIds[result.res.table], result.res.pk, result.res.complete, result.res.error);
}, error);
},
getTableIndex: function (table, complete, error) {
if (!selectedDB)
return;
nSQL.doFilter(selectedDB, "adapterGetTableIndex", { res: { table: table, complete: complete, error: error }, query: query }, function (result) {
if (!result)
return; // filter took over
var adapter = nSQL.getDB(selectedDB)._tables[result.res.table].mode || nSQL.getDB(selectedDB).adapter;
adapter.getTableIndex(nSQL.getDB(selectedDB)._tableIds[result.res.table], result.res.complete, result.res.error);
}, error);
},
getTableIndexLength: function (table, complete, error) {
if (!selectedDB)
return;
nSQL.doFilter(selectedDB, "adapterGetTableIndexLength", { res: { table: table, complete: complete, error: error }, query: query }, function (result) {
if (!result)
return; // filter took over
var adapter = nSQL.getDB(selectedDB)._tables[result.res.table].mode || nSQL.getDB(selectedDB).adapter;
adapter.getTableIndexLength(nSQL.getDB(selectedDB)._tableIds[result.res.table], result.res.complete, result.res.error);
}, error);
},
createIndex: function (table, indexName, type, complete, error) {
if (!selectedDB)
return;
nSQL.doFilter(selectedDB, "adapterCreateIndex", { res: { table: table, indexName: indexName, type: type, complete: complete, error: error }, query: query }, function (result) {
if (!result)
return; // filter took over
var adapter = nSQL.getDB(selectedDB)._tables[result.res.table].mode || nSQL.getDB(selectedDB).adapter;
adapter.createIndex(nSQL.getDB(selectedDB)._tableIds[result.res.table], result.res.indexName, result.res.type, result.res.complete, result.res.error);
}, error);
},
deleteIndex: function (table, indexName, complete, error) {
if (!selectedDB)
return;
if (!nSQL.getDB(selectedDB)._tables[table].indexes[indexName]) {
error({ error: "Index " + indexName + " not found!" });
return;
}
nSQL.doFilter(selectedDB, "adapterDeleteIndex", { res: { table: table, indexName: indexName, complete: complete, error: error }, query: query }, function (result) {
if (!result)
return; // filter took over
var adapter = nSQL.getDB(selectedDB)._tables[result.res.table].mode || nSQL.getDB(selectedDB).adapter;
adapter.deleteIndex(nSQL.getDB(selectedDB)._tableIds[result.res.table], result.res.indexName, result.res.complete, result.res.error);
}, error);
},
addIndexValue: function (table, indexName, key, value, complete, error) {
if (!selectedDB)
return;
if (!nSQL.getDB(selectedDB)._tables[table].indexes[indexName]) {
error({ error: "Index " + indexName + " not found!" });
return;
}
var value2 = value === undefined || value === "undefined" ? "__NULL__" : value;
// shift primary key query by offset
if (typeof value2 === "number" && nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props && nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props.offset) {
value2 += nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props.offset || 0;
}
if (nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props && nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props.ignore_case) {
value2 = String(value2 || "").toUpperCase();
}
value2 = exports.keyToDate(nSQL, nSQL.getDB(selectedDB)._tables[table].indexes[indexName].isDate ? "date" : "", value2);
nSQL.doFilter(selectedDB, "adapterAddIndexValue", { res: { table: table, indexName: indexName, key: key, value: value2, complete: complete, error: error }, query: query }, function (result) {
if (!result)
return; // filter took over
var adapter = nSQL.getDB(selectedDB)._tables[result.res.table].mode || nSQL.getDB(selectedDB).adapter;
adapter.addIndexValue(nSQL.getDB(selectedDB)._tableIds[result.res.table], result.res.indexName, result.res.key, result.res.value, result.res.complete, result.res.error);
}, error);
},
deleteIndexValue: function (table, indexName, key, value, complete, error) {
if (!selectedDB)
return;
if (!nSQL.getDB(selectedDB)._tables[table].indexes[indexName]) {
error({ error: "Index " + indexName + " not found!" });
return;
}
var value2 = value === undefined || value === "undefined" ? "__NULL__" : value;
// shift primary key query by offset
if (typeof value2 === "number" && nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props && nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props.offset) {
value2 += nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props.offset || 0;
}
if (nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props && nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props.ignore_case) {
value2 = String(value2 || "").toUpperCase();
}
value2 = exports.keyToDate(nSQL, nSQL.getDB(selectedDB)._tables[table].indexes[indexName].isDate ? "date" : "", value2);
nSQL.doFilter(selectedDB, "adapterDeleteIndexValue", { res: { table: table, indexName: indexName, key: key, value: value2, complete: complete, error: error }, query: query }, function (result) {
if (!result)
return; // filter took over
var adapter = nSQL.getDB(selectedDB)._tables[result.res.table].mode || nSQL.getDB(selectedDB).adapter;
adapter.deleteIndexValue(nSQL.getDB(selectedDB)._tableIds[result.res.table], result.res.indexName, result.res.key, result.res.value, result.res.complete, result.res.error);
}, error);
},
readIndexKey: function (table, indexName, pk, onRowPK, complete, error) {
if (!selectedDB)
return;
if (!nSQL.getDB(selectedDB)._tables[table].indexes[indexName]) {
error({ error: "Index " + indexName + " not found!" });
return;
}
var key = pk === "NULL" ? "__NULL__" : pk;
// shift primary key query by offset
if (typeof key === "number" && nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props && nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props.offset) {
key += nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props.offset || 0;
}
key = exports.keyToDate(nSQL, nSQL.getDB(selectedDB)._tables[table].indexes[indexName].isDate ? "date" : "", key);
if (nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props && nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props.ignore_case) {
key = String(key || "").toUpperCase();
}
nSQL.doFilter(selectedDB, "adapterReadIndexKey", { res: { table: table, indexName: indexName, pk: key, onRowPK: onRowPK, complete: complete, error: error }, query: query }, function (result) {
if (!result)
return; // filter took over
var adapter = nSQL.getDB(selectedDB)._tables[result.res.table].mode || nSQL.getDB(selectedDB).adapter;
adapter.readIndexKey(nSQL.getDB(selectedDB)._tableIds[result.res.table], result.res.indexName, result.res.pk, result.res.onRowPK, result.res.complete, result.res.error);
}, error);
},
readIndexKeys: function (table, indexName, type, offsetOrLow, limitOrHigh, reverse, onRowPK, complete, error) {
if (!selectedDB)
return;
var lower = offsetOrLow;
var higher = limitOrHigh;
if (!nSQL.getDB(selectedDB)._tables[table].indexes[indexName]) {
error({ error: "Index " + indexName + " not found!" });
return;
}
// shift range query by offset
if (typeof lower === "number" && typeof higher === "number" && type === "range") {
if (nSQL.getDB(selectedDB)._tables[table].indexes[indexName] && nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props.offset) {
lower += nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props.offset || 0;
higher += nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props.offset || 0;
}
}
lower = exports.keyToDate(nSQL, nSQL.getDB(selectedDB)._tables[table].indexes[indexName].isDate ? "date" : "", lower);
higher = exports.keyToDate(nSQL, nSQL.getDB(selectedDB)._tables[table].indexes[indexName].isDate ? "date" : "", higher);
if (type === "range" && nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props && nSQL.getDB(selectedDB)._tables[table].indexes[indexName].props.ignore_case) {
lower = String(lower || "").toUpperCase();
higher = String(higher || "").toUpperCase();
}
nSQL.doFilter(selectedDB, "adapterReadIndexKeys", { res: { table: table, indexName: indexName, type: type, offsetOrLow: lower, limitOrHigh: higher, reverse: reverse, onRowPK: onRowPK, complete: complete, error: error }, query: query }, function (result) {
if (!result)
return; // filter took over
var adapter = nSQL.getDB(selectedDB)._tables[result.res.table].mode || nSQL.getDB(selectedDB).adapter;
adapter.readIndexKeys(nSQL.getDB(selectedDB)._tableIds[result.res.table], result.res.indexName, result.res.type, result.res.offsetOrLow, result.res.limitOrHigh, result.res.reverse, function (key, id) {
if (key !== "__NULL__")
result.res.onRowPK(key, id);
}, result.res.complete, result.res.error);
}, error);
}
};
};
exports.maybeDate = function (value) {
var parsed = Date.parse(value);
return isNaN(parsed) ? value : parsed;
};
exports.mutateRowTypes = function (selectedDB, replaceObj, table, nSQL) {
if (!selectedDB)
return replaceObj;
if (!nSQL.getDB(selectedDB)._tables[table]) {
throw new Error("nSQL: Table \"" + table + "\" not found!");
}
var resolveModel = function (cols, useObj, nestedModel) {
if (!useObj)
return useObj;
if (nestedModel && nestedModel.length) {
if (nestedModel.indexOf("[]") !== -1) {
if (Array.isArray(useObj)) {
return useObj.map(function (a) { return resolveModel(cols, a, nestedModel.slice(0, nestedModel.lastIndexOf("[]"))); });
}
else {
return [];
}
}
}
cols.forEach(function (m) {
if (m.model) {
if (m.type.indexOf("[]") !== -1) {
var arr = typeof useObj !== "undefined" ? useObj[m.key] : [];
if (!Array.isArray(arr)) {
useObj[m.key] = [];
}
else {
useObj[m.key] = arr.map(function (a) { return resolveModel(m.model, a, m.type.slice(0, m.type.lastIndexOf("[]"))); });
}
}
else {
useObj[m.key] = resolveModel(m.model, typeof useObj !== "undefined" ? useObj[m.key] : undefined);
}
}
else {
switch (m.type) {
case "date":
useObj[m.key] = new Date(useObj[m.key]).toISOString();
break;
default:
useObj[m.key] = useObj[m.key];
}
}
});
return useObj;
};
return resolveModel(nSQL.getDB(selectedDB)._tables[table].columns, replaceObj);
};
exports.noop = function () { };
exports.throwErr = function (err) {
throw new Error(err);
};
exports.nan = function (input) {
return isNaN(input) || input === null ? 0 : parseFloat(input);
};
/**
* Object.assign, but faster.
*
* @param {*} obj
* @returns
*/
exports.assign = function (obj) {
return obj ? JSON.parse(JSON.stringify(obj)) : obj;
};
/**
* Compare two javascript variables for equality.
* Works with primitives, arrays and objects recursively.
*
* @param {*} obj1
* @param {*} obj2
* @returns {boolean}
*/
exports.objectsEqual = function (obj1, obj2) {
if (obj1 === obj2)
return true;
if (typeof obj1 !== "object")
return false; // primitives will always pass === when they're equal, so we have primitives that don't match.
if (!obj1 || !obj2)
return false; // if either object is undefined they don't match
return equal(obj1, obj2);
};
// tslint:disable-next-line
var _nanoSQLQueue = /** @class */ (function () {
function _nanoSQLQueue(processItem, onError, onComplete) {
this.processItem = processItem;
this.onError = onError;
this.onComplete = onComplete;
this._items = [];
this._going = false;
this._done = false;
this._count = 0;
this._triggeredComplete = false;
this._progressBuffer = this._progressBuffer.bind(this);
}
_nanoSQLQueue.prototype._progressBuffer = function () {
var _this = this;
if (this._triggeredComplete) {
return;
}
// quueue as finished
if (this._done && !this._items.length) {
this._triggeredComplete = true;
if (this.onComplete)
this.onComplete();
return;
}
// queue has paused
if (!this._items.length) {
this._going = false;
return;
}
var next = function () {
_this._count++;
_this._count % 100 === 0 ? exports.setFast(_this._progressBuffer) : _this._progressBuffer();
};
// process queue
var item = this._items.shift() || [];
if (item[1]) {
item[1](item[0], next, this.onError ? this.onError : exports.noop);
}
else if (this.processItem) {
this.processItem(item[0], this._count, next, this.onError ? this.onError : exports.noop);
}
};
_nanoSQLQueue.prototype.finished = function () {
this._done = true;
if (this._triggeredComplete) {
return;
}
if (!this._going && !this._items.length) {
this._triggeredComplete = true;
if (this.onComplete)
this.onComplete();
}
};
_nanoSQLQueue.prototype.newItem = function (item, processFn) {
this._items.push([item, processFn]);
if (!this._going) {
this._going = true;
this._progressBuffer();
}
};
return _nanoSQLQueue;
}());
exports._nanoSQLQueue = _nanoSQLQueue;
/**
* Quickly and efficiently fire asynchronous operations in sequence, returns once all operations complete.
*
* @param {any[]} items
* @param {(item: any, i: number, next: (result?: any) => void) => void} callback
* @returns {Promise<any[]>}
*/
exports.chainAsync = function (items, callback) {
return new Promise(function (res, rej) {
if (!items || !items.length) {
res([]);
return;
}
var results = [];
var i = 0;
var step = function () {
if (i < items.length) {
callback(items[i], i, function (result) {
results.push(result || 0);
i++;
i % 250 === 0 ? exports.setFast(function () {
step();
}) : step();
}, function (err) {
rej(err);
});
}
else {
res(results);
}
};
step();
});
};
/**
* Quickly and efficiently fire asynchronous operations in parallel, returns once all operations are complete.
*
* @param {any[]} items
* @param {(item: any, i: number, done: (result?: any) => void) => void} callback
* @returns {Promise<any[]>}
*/
exports.allAsync = function (items, callback) {
if (!items || !items.length) {
return Promise.resolve([]);
}
return Promise.all((items || []).map(function (item, i) {
return new Promise(function (res, rej) {
callback(item, i, res, rej);
});
}));
};
var ua = typeof window === "undefined" ? "" : (navigator.userAgent || "");
// Detects iOS device OR Safari running on desktop
exports.isSafari = ua.length === 0 ? false : (/^((?!chrome|android).)*safari/i.test(ua)) || (/iPad|iPhone|iPod/.test(ua) && !window["MSStream"]);
// Detect Edge or Internet Explorer
exports.isMSBrowser = ua.length === 0 ? false : ua.indexOf("MSIE ") > 0 || ua.indexOf("Trident/") > 0 || ua.indexOf("Edge/") > 0;
// Detect Android Device
exports.isAndroid = /Android/.test(ua);
/**
* Generate a random 16 bit number using strongest entropy/crypto available.
*
* @returns {number}
*/
exports.random16Bits = function () {
if (typeof crypto === "undefined") {
return Math.round(Math.random() * Math.pow(2, 16)); // Less random fallback.
}
else {
if (crypto.getRandomValues) { // Browser crypto
var buf = new Uint16Array(1);
crypto.getRandomValues(buf);
return buf[0];
}
else if (typeof global !== "undefined" && global._crypto.randomBytes) { // NodeJS crypto
return global._crypto.randomBytes(2).reduce(function (prev, cur) { return cur * prev; });
}
else {
return Math.round(Math.random() * Math.pow(2, 16)); // Less random fallback.
}
}
};
exports.throttle = function (scope, func, limit) {
var waiting = false;
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
if (waiting)
return;
waiting = true;
setTimeout(function () {
func.apply(scope, args);
waiting = false;
}, limit);
};
};
/**
* Generate a TimeID for use in the database.
*
* @param {boolean} [ms]
* @returns {string}
*/
exports.timeid = function (ms) {
var time = Math.round((new Date().getTime()) / (ms ? 1 : 1000)).toString();
while (time.length < (ms ? 13 : 10)) {
time = "0" + time;
}
var seed = (exports.random16Bits() + exports.random16Bits()).toString(16);
while (seed.length < 5) {
seed = "0" + seed;
}
return time + "-" + seed;
};
/**
* See if two arrays intersect.
*
* @param {any[]} arr1
* @param {any[]} arr2
* @returns {boolean}
*/
exports.intersect = function (arr1, arr2) {
if (!arr1 || !arr2)
return false;
if (!arr1.length || !arr2.length)
return false;
return (arr1 || []).filter(function (item) { return (arr2 || []).indexOf(item) !== -1; }).length > 0;
};
exports.fastID = function () {
return [0, 0].map(function (s) { return Math.round(Math.random() * 1024).toString(16); }).join("");
};
/**
* Generates a valid V4 UUID using the strongest crypto available.
*
* @returns {string}
*/
exports.uuid = function () {
var r, s, b = "";
return [b, b, b, b, b, b, b, b].reduce(function (prev, cur, i) {
r = exports.random16Bits();
s = (i === 3 ? 4 : (i === 4 ? (r % 16 & 0x3 | 0x8).toString(16) : b));
r = r.toString(16);
while (r.length < 4)
r = "0" + r;
return prev + ([2, 3, 4, 5].indexOf(i) > -1 ? "-" : b) + (s + r).slice(0, 4);
}, b);
};
/**
* A quick and dirty hashing function, turns a string into a md5 style hash.
* Stolen from https://github.com/darkskyapp/string-hash
*
* @param {string} str
* @returns {string}
*/
exports.hash = function (str) {
var hash = 5381, i = str.length;
while (i) {
hash = (hash * 33) ^ str.charCodeAt(--i);
}
return (hash >>> 0).toString(16);
};
/**
* Generate a row ID given the primary key type.
*
* @param {string} primaryKeyType
* @param {number} [incrimentValue]
* @returns {*}
*/
exports.generateID = function (primaryKeyType, incrimentValue) {
var idTypes = {
"int": function (value) { return value; },
"date": function (value) { return value; },
"float": function (value) { return value; },
"uuid": exports.uuid,
"timeId": function () { return exports.timeid(); },
"timeIdms": function () { return exports.timeid(true); }
};
return idTypes[primaryKeyType] ? idTypes[primaryKeyType](incrimentValue || 1) : undefined;
};
exports.cleanArgs2 = function (selectedDB, args, dataModel, nSQL) {
var returnObj = {};
var conformType = function (strType, obj, dModel) {
if (strType.indexOf("[]") !== -1) {
var arrayOf_1 = strType.slice(0, strType.lastIndexOf("[]"));
// value should be array but isn't, cast it to one
if (!Array.isArray(obj))
return [];
// we have an array, cast array of types
return obj.map(function (v) { return conformType(arrayOf_1, v, dModel); });
}
if (typeof dModel === "string") {
var findModel_1 = dModel.replace(/\[\]/gmi, "");
var typeModel = Object.keys(nSQL.getDB(selectedDB).config.types || {}).reduce(function (prev, cur) {
if (cur === findModel_1)
return (nSQL.getDB(selectedDB).config.types || {})[cur];
return prev;
}, undefined);
if (!typeModel) {
throw new Error("Can't find type " + findModel_1 + "!");
}
return conformType(dModel, args, typeModel);
}
else {
var returnObj_1 = {};
var getOtherCols_1 = false;
var definedCols_1 = [];
Object.keys(dModel).forEach(function (colAndType) {
var split = colAndType.split(":");
if (split[0] === "*") {
getOtherCols_1 = true;
}
else {
definedCols_1.push(split[0]);
returnObj_1[split[0]] = exports.cast(selectedDB, split[1], obj[split[0]], false, nSQL);
}
});
if (getOtherCols_1 && exports.isObject(obj)) {
Object.keys(obj).filter(function (k) { return definedCols_1.indexOf(k) === -1; }).forEach(function (key) {
returnObj_1[key] = obj[key];
});
}
return returnObj_1;
}
};
return conformType(typeof dataModel === "string" ? dataModel : "", args, dataModel);
};
/**
* Clean the arguments from an object given an array of arguments and their types.
*
* @param {string[]} argDeclarations
* @param {StdObject<any>} args
* @returns {StdObject<any>}
*/
exports.cleanArgs = function (selectedDB, argDeclarations, args, nSQL) {
var a = {};
var i = argDeclarations.length;
var customTypes = Object.keys(nSQL.getDB(selectedDB).config.types || {});
while (i--) {
var k2 = argDeclarations[i].split(":");
if (k2.length > 1) {
a[k2[0]] = exports.cast(selectedDB, k2[1], args[k2[0]] || undefined, true, nSQL);
}
else {
a[k2[0]] = args[k2[0]] || undefined;
}
}
return a;
};
/**
* Determine if a given value is a javascript object or not. Exludes Arrays, Functions, Null, Undefined, etc.
*
* @param {*} val
* @returns {boolean}
*/
exports.isObject = function (val) {
return Object.prototype.toString.call(val) === "[object Object]";
};
exports.objSort = function (path, rev) {
return function (a, b) {
var result = path ? (exports.deepGet(path, a) > exports.deepGet(path, b) ? -1 : 1) : (a > b ? -1 : 1);
return rev ? result * -1 : result;
};
};
/**
* Recursively resolve function values provided a string and row
*
*
* @param {string} fnString // TRIM(UPPER(column))
* @param {*} row // {column: " value "}
* @param {*} prev // aggregate previous value for aggregate functions
* @returns {InanoSQLFunctionResult}
* @memberof _nanoSQLQuery
*/
exports.execFunction = function (query, fnString, row, prev) {
var _a;
var fnArgs = fnString.match(/\((.*)\)/gmi);
if (!fnArgs[0])
return { result: undefined };
var args = fnArgs[0].substr(1, fnArgs[0].length - 2).split(/\,\s?(?![^\(]*\))/).map(function (s) { return s.trim(); });
var fnName = fnString.split("(").shift();
var calcArgs = args.map(function (s) {
if (s.indexOf("(") !== -1) {
var result = exports.execFunction(query, s, row, prev).result;
if (typeof result === "number")
return result;
if (typeof result === "string")
return '"' + result + '"';
return result;
}
else {
return s;
}
});
if (!query.parent.functions[fnName]) {
return { result: undefined };
}
return (_a = query.parent.functions[fnName]).call.apply(_a, [query, row, prev].concat(calcArgs));
};
/**
* Cast a javascript variable to a given type. Supports typescript primitives and more specific types.
*
* @param {string} type
* @param {*} [val]
* @returns {*}
*/
exports.cast = function (selectedDB, type, val, allowUknownTypes, nSQL) {
if (type === "any" || type === "blob" || type === "*")
return val;
// recursively cast arrays
if (type.indexOf("[]") !== -1) {
var arrayOf_2 = type.slice(0, type.lastIndexOf("[]"));
// value should be array but isn't, cast it to one
if (!Array.isArray(val))
return [];
// we have an array, cast array of types
return val.map(function (v) { return exports.cast(selectedDB, arrayOf_2, v, allowUknownTypes); });
}
if (val === undefined)
return val;
var t = typeof val;
var entityMap = {
"&": "&",
"<": "<",
">": ">",
"\"": """,
"'": "'",
"/": "/",
"`": "`",
"=": "="
};
var types = nSQL && selectedDB ? nSQL.getDB(selectedDB).config.types || {} : {};
// custom type found
if (Object.keys(types).indexOf(type) !== -1) {
if (exports.isObject(val)) {
var keys = [];
var customType = "";
var typeObj = types[type];
var returnObj = Object.keys(typeObj).reduce(function (prev, cur) {
var key = cur.split(":");
prev[key[0]] = exports.cast(selectedDB, key[1], val[key[0]], allowUknownTypes, nSQL);
return prev;
}, {});
return returnObj;
}
return {};
}
var doCast = function (castType, castVal) {
switch (castType) {
case "safestr": return doCast("string", castVal).replace(/[&<>"'`=\/]/gmi, function (s) { return entityMap[s]; });
case "int": return (t !== "number" || castVal % 1 !== 0) ? Math.round(exports.nan(castVal)) : castVal;
case "number":
case "float": return t !== "number" ? exports.nan(castVal) : castVal;
case "array": return Array.isArray(castVal) ? castVal : [];
case "date":
case "uuid":
case "timeId":
case "timeIdms":
case "string": return t !== "string" ? String(castVal) : castVal;
case "object":
case "obj":
case "map": return exports.isObject(castVal) ? castVal : {};
case "boolean":
case "bool": return castVal === true || castVal === 1 ? true : false;
}
// doesn't match known types, return null;
return allowUknownTypes ? val : null;
};
if (typeof val === "undefined" || val === null)
return null;
var newVal = doCast(String(type || "").toLowerCase(), val);
// force numerical values to be a number and not NaN.
if (newVal !== undefined && ["int", "float", "number"].indexOf(type) > -1) {
return isNaN(newVal) ? 0 : newVal;
}
return newVal;
};
exports.rad2deg = function (rad) {
return rad * 180 / Math.PI;
};
exports.deg2rad = function (deg) {
return deg * (Math.PI / 180);
};
/**
* "As the crow flies" or Haversine formula, used to calculate the distance between two points on a sphere.
*
* The unit used for the radius will determine the unit of the answer. If the radius is in km, distance provided will be in km.
*
* The radius is in km by default.
*
* @param {number} lat1
* @param {number} lon1
* @param {number} lat2
* @param {number} lon2
* @param {number} radius
* @returns {number}
*/
exports.crowDistance = function (lat1, lon1, lat2, lon2, radius) {
if (radius === void 0) { radius = 6371; }
var dLat = exports.deg2rad(lat2 - lat1);
var dLon = exports.deg2rad(lon2 - lon1);
var a = Math.pow(Math.sin(dLat / 2), 2) +
Math.cos(exports.deg2rad(lat1)) * Math.cos(exports.deg2rad(lat2)) *
Math.pow(Math.sin(dLon / 2), 2);
return radius * (2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)));
};
exports.levenshtein = function (word1, word2) {
return leven(word1, word2);
};
var objectPathCache = {};
// turn path into array of strings, ie value[hey][there].length => [value, hey, there, length];
exports.resolvePath = function (pathQuery) {
if (!pathQuery)
return [];
if (objectPathCache[pathQuery]) {
return objectPathCache[pathQuery].slice();
}
var path = pathQuery.indexOf("[") !== -1 ?
// handle complex mix of dots and brackets like "users.value[meta][value].length"
pathQuery.split(/\.|\[/gmi).map(function (v) { return v.replace(/\]/gmi, ""); }) :
// handle simple dot paths like "users.meta.value.length"
pathQuery.split(".");
objectPathCache[pathQuery] = path;
return objectPathCache[pathQuery].slice();
};
exports.fnRegex = /^[\"|\'](.*)[\"|\']$/gmi;
exports.getFnValue = function (row, valueOrPath) {
if (typeof valueOrPath === "number")
return valueOrPath;
var regexResult = exports.fnRegex.exec(valueOrPath);
return regexResult ? regexResult[1] : exports.deepGet(valueOrPath, row);
};
/**
* Recursively freeze a javascript object to prevent it from being modified.
*
* @param {*} obj
* @returns
*/
exports.deepFreeze = function (obj) {
Object.getOwnPropertyNames(obj || {}).forEach(function (name) {
var prop = obj[name];
if (typeof prop === "object" && prop !== null) {
obj[name] = exports.deepFreeze(prop);
}
});
// Freeze self (no-op if already frozen)
return Object.freeze(obj);
};
exports.deepSet = function (pathQuery, object, value) {
var safeSet = function (getPath, pathIdx, setObj) {
if (!getPath[pathIdx + 1]) { // end of path
setObj[getPath[pathIdx]] = value;
return;
}
else if (!setObj[getPath[pathIdx]] || (!Array.isArray(setObj[getPath[pathIdx]]) && !exports.isObject(setObj[getPath[pathIdx]]))) { // nested value doesn't exist yet
if (isNaN(getPath[pathIdx + 1])) { // assume number queries are for arrays, otherwise an object
setObj[getPath[pathIdx]] = {};
}
else {
setObj[getPath[pathIdx]] = [];
}
}
safeSet(getPath, pathIdx + 1, setObj[getPath[pathIdx]]);
};
safeSet(Array.isArray(pathQuery) ? pathQuery : exports.resolvePath(pathQuery), 0, object);
return object;
};
/**
* Take an object and a string describing a path like "value.length" or "val[length]" and safely get that value in the object.
*
* objQuery("hello", {hello: 2}) => 2
* objQuery("hello.length", {hello: [0]}) => 1
* objQuery("hello[0]", {hello: ["there"]}) => "there"
* objQuery("hello[0].length", {hello: ["there"]}) => 5
* objQuery("hello.color.length", {"hello.color": "blue"}) => 4
*
* @param {string} pathQuery
* @param {*} object
* @param {boolean} [ignoreFirstPath]
* @returns {*}
*/
exports.deepGet = function (pathQuery, object) {
var safeGet = function (getPath, pathIdx, object) {
if (!getPath[pathIdx] || !object)
return object;
return safeGet(getPath, pathIdx + 1, object[getPath[pathIdx]]);
};
return safeGet(Array.isArray(pathQuery) ? pathQuery : exports.resolvePath(pathQuery), 0, object);
};
exports.maybeAssign = function (obj) {
return Object.isFrozen(obj) ? exports.assign(obj) : obj;
};
var fastApply = function (args) {
return args[0].apply(null, Array.prototype.slice.call(args, 1));
};
exports.setFast = typeof Promise !== "undefined" ? function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
Promise.resolve().then(function () {
fastApply(args);
});
} : function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
setTimeout(function () {
fastApply(args);
}, 0);
};
//# sourceMappingURL=utilities.js.map
/***/ }),
/* 1 */
/***/ (function(module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.VERSION = 2.33;
;
var InanoSQLFKActions;
(function (InanoSQLFKActions) {
InanoSQLFKActions[InanoSQLFKActions["NONE"] = 0] = "NONE";
InanoSQLFKActions[InanoSQLFKActions["CASCADE"] = 1] = "CASCADE";
InanoSQLFKActions[InanoSQLFKActions["RESTRICT"] = 2] = "RESTRICT";
InanoSQLFKActions[InanoSQLFKActions["SET_NULL"] = 3] = "SET_NULL";
})(InanoSQLFKActions = exports.InanoSQLFKActions || (exports.InanoSQLFKActions = {}));
var IWhereType;
(function (IWhereType) {
IWhereType[IWhereType["fast"] = 0] = "fast";
IWhereType[IWhereType["medium"] = 1] = "medium";
IWhereType[IWhereType["slow"] = 2] = "slow";
IWhereType[IWhereType["fn"] = 3] = "fn";
IWhereType[IWhereType["none"] = 4] = "none"; // no where, return all rows
})(IWhereType = exports.IWhereType || (exports.IWhereType = {}));
//# sourceMappingURL=interfaces.js.map
/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
var utilities_1 = __webpack_require__(0);
exports.err = new Error("Memory index doesn't support this action!");
var nanoSQLMemoryIndex = /** @class */ (function () {
function nanoSQLMemoryIndex(assign, useCache) {
this.assign = assign;
this.useCache = useCache;
}
nanoSQLMemoryIndex.prototype.connect = function (id, complete, error) {
error(exports.err);
};
nanoSQLMemoryIndex.prototype.disconnect = function (complete, error) {
error(exports.err);
};
nanoSQLMemoryIndex.prototype.createTable = function (tableName, tableData, complete, error) {
error(exports.err);
};
nanoSQLMemoryIndex.prototype.dropTable = function (table, complete, error) {
error(exports.err);
};
nanoSQLMemoryIndex.prototype.write = function (table, pk, row, complete, error) {
error(exports.err);
};
nanoSQLMemoryIndex.prototype.read = function (table, pk, complete, error) {
error(exports.err);
};
nanoSQLMemoryIndex.prototype.delete = function (table, pk, complete, error) {
error(exports.err);
};
nanoSQLMemoryIndex.prototype.readMulti = function (table, type, offsetOrLow, limitOrHigh, reverse, onRow, complete, error) {