@aeriajs/common 0.0.0

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright 2023 João Santos (joaosan177@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the “Software”), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,13 @@
+# `@aeriajs/common`
+
+## Installation
+
+```sh
+$ yarn add @aeriajs/common
+# or
+$ npm install @aeriajs/common
+```
+
+## Usage
+
+This is an internal utility, not intended for public usage.

package/dist/arraysIntersects.d.ts

@@ -0,0 +1 @@
+export declare const arraysIntersects: <T extends string[]>(subject: string | T, arr: T | undefined) => boolean;

package/dist/arraysIntersects.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arraysIntersects = void 0;
+const arraysIntersects = (subject, arr) => {
+    if (!arr) {
+        return false;
+    }
+    return Array.isArray(subject)
+        ? subject.some((e) => arr.includes(e))
+        : arr.includes(subject);
+};
+exports.arraysIntersects = arraysIntersects;

package/dist/arraysIntersects.mjs

@@ -0,0 +1,8 @@
+export var arraysIntersects = function(subject, arr) {
+    if (!arr) {
+        return false;
+    }
+    return Array.isArray(subject) ? subject.some(function(e) {
+        return arr.includes(e);
+    }) : arr.includes(subject);
+};

package/dist/checkForUndefined.d.ts

@@ -0,0 +1,2 @@
+import type { Property } from '@aeriajs/types';
+export declare const checkForUndefined: (property: Property, propertyName: string, what: Record<string, any>) => boolean;

package/dist/checkForUndefined.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForUndefined = void 0;
+const checkForUndefined = (property, propertyName, what) => {
+    if (property.readOnly || property.isTimestamp) {
+        return false;
+    }
+    return what[propertyName] === null
+        || what[propertyName] === undefined
+        || what[propertyName] === '';
+};
+exports.checkForUndefined = checkForUndefined;

package/dist/checkForUndefined.mjs

@@ -0,0 +1,6 @@
+export var checkForUndefined = function(property, propertyName, what) {
+    if (property.readOnly || property.isTimestamp) {
+        return false;
+    }
+    return what[propertyName] === null || what[propertyName] === undefined || what[propertyName] === "";
+};

package/dist/convertConditionToQuery.d.ts

@@ -0,0 +1,2 @@
+import type { Condition } from '@aeriajs/types';
+export declare const convertConditionToQuery: (condition: Condition, subject?: Record<string, any>) => Record<string, any>;

package/dist/convertConditionToQuery.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertConditionToQuery = void 0;
+const getValueFromPath_js_1 = require("./getValueFromPath.js");
+const convertExpression = (condition, subject) => {
+    const term2 = 'term2' in condition
+        ? typeof condition.term2 === 'string' && condition.term2.startsWith('$.')
+            ? (0, getValueFromPath_js_1.getValueFromPath)(subject, condition.term2.split('$.')[1])
+            : condition.term2
+        : null;
+    switch (condition.operator) {
+        case 'truthy': return {
+            $ne: [
+                null,
+                undefined,
+            ],
+        };
+        case 'equal': return term2;
+        case 'gt': return {
+            $gt: term2,
+        };
+        case 'lt': return {
+            $lt: term2,
+        };
+        case 'gte': return {
+            $gte: term2,
+        };
+        case 'lte': return {
+            $lte: term2,
+        };
+        case 'in': {
+            return Array.isArray(term2)
+                ? {
+                    $in: term2,
+                }
+                : term2;
+        }
+    }
+};
+const convertConditionToQuery = (condition, subject) => {
+    if ('or' in condition) {
+        return {
+            $or: condition.or.map((sub) => (0, exports.convertConditionToQuery)(sub, subject)),
+        };
+    }
+    if ('and' in condition) {
+        return {
+            $and: condition.and.map((sub) => (0, exports.convertConditionToQuery)(sub, subject)),
+        };
+    }
+    if ('not' in condition) {
+        return {
+            $not: (0, exports.convertConditionToQuery)(condition.not, subject),
+        };
+    }
+    return {
+        [condition.term1]: convertExpression(condition, subject),
+    };
+};
+exports.convertConditionToQuery = convertConditionToQuery;

package/dist/convertConditionToQuery.mjs

@@ -0,0 +1,72 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { getValueFromPath } from "./getValueFromPath.mjs";
+var convertExpression = function(condition, subject) {
+    var term2 = "term2" in condition ? typeof condition.term2 === "string" && condition.term2.startsWith("$.") ? getValueFromPath(subject, condition.term2.split("$.")[1]) : condition.term2 : null;
+    switch(condition.operator){
+        case "truthy":
+            return {
+                $ne: [
+                    null,
+                    undefined
+                ]
+            };
+        case "equal":
+            return term2;
+        case "gt":
+            return {
+                $gt: term2
+            };
+        case "lt":
+            return {
+                $lt: term2
+            };
+        case "gte":
+            return {
+                $gte: term2
+            };
+        case "lte":
+            return {
+                $lte: term2
+            };
+        case "in":
+            {
+                return Array.isArray(term2) ? {
+                    $in: term2
+                } : term2;
+            }
+    }
+};
+export var convertConditionToQuery = function(condition, subject) {
+    if ("or" in condition) {
+        return {
+            $or: condition.or.map(function(sub) {
+                return convertConditionToQuery(sub, subject);
+            })
+        };
+    }
+    if ("and" in condition) {
+        return {
+            $and: condition.and.map(function(sub) {
+                return convertConditionToQuery(sub, subject);
+            })
+        };
+    }
+    if ("not" in condition) {
+        return {
+            $not: convertConditionToQuery(condition.not, subject)
+        };
+    }
+    return _define_property({}, condition.term1, convertExpression(condition, subject));
+};

package/dist/date.d.ts

@@ -0,0 +1,7 @@
+export type DateFormatOptions = {
+    hours?: boolean;
+    hoursOnly?: boolean;
+    locale?: string;
+};
+export declare const formatDateTime: (date: Date | string, options?: DateFormatOptions) => string;
+export declare const getRelativeTimeFromNow: (target: any) => string | undefined;

package/dist/date.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelativeTimeFromNow = exports.formatDateTime = void 0;
+const rtf = new Intl.RelativeTimeFormat(undefined, {
+    numeric: 'auto',
+});
+const units = {
+    year: 31536000000,
+    month: 2628000000,
+    day: 86400000,
+    hour: 3600000,
+    minute: 6000,
+    second: 1000,
+};
+const formatDateTime = function (date, options) {
+    const target = date instanceof Date
+        ? date
+        : new Date(date);
+    if (isNaN(target.getDate())) {
+        return '-';
+    }
+    const { hours, hoursOnly, locale = 'navigator' in globalThis
+        ? navigator.language
+        : 'en-US', } = options || {};
+    if (hoursOnly) {
+        return target.toLocaleTimeString();
+    }
+    return hours
+        ? target.toLocaleString(locale)
+        : target.toLocaleDateString(locale);
+};
+exports.formatDateTime = formatDateTime;
+const getRelativeTimeFromNow = function (target) {
+    const now = new Date();
+    const elapsed = now - target;
+    for (const [u, value] of Object.entries(units)) {
+        if (Math.abs(elapsed) > value || u === 'second') {
+            return rtf.format(-1 * Math.round(elapsed / value), u);
+        }
+    }
+};
+exports.getRelativeTimeFromNow = getRelativeTimeFromNow;

package/dist/date.mjs

@@ -0,0 +1,101 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var rtf = new Intl.RelativeTimeFormat(undefined, {
+    numeric: "auto"
+});
+var units = {
+    year: 31536000000,
+    month: 2628000000,
+    day: 86400000,
+    hour: 3600000,
+    minute: 6000,
+    second: 1000
+};
+export var formatDateTime = function formatDateTime(date, options) {
+    var target = _instanceof(date, Date) ? date : new Date(date);
+    if (isNaN(target.getDate())) {
+        return "-";
+    }
+    var _ref = options || {}, hours = _ref.hours, hoursOnly = _ref.hoursOnly, _ref_locale = _ref.locale, locale = _ref_locale === void 0 ? "navigator" in globalThis ? navigator.language : "en-US" : _ref_locale;
+    if (hoursOnly) {
+        return target.toLocaleTimeString();
+    }
+    return hours ? target.toLocaleString(locale) : target.toLocaleDateString(locale);
+};
+export var getRelativeTimeFromNow = function getRelativeTimeFromNow(target) {
+    var now = new Date();
+    var elapsed = now - target;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = Object.entries(units)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _sliced_to_array(_step.value, 2), u = _step_value[0], value = _step_value[1];
+            if (Math.abs(elapsed) > value || u === "second") {
+                return rtf.format(-1 * Math.round(elapsed / value), u);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+};

package/dist/deepClone.d.ts

@@ -0,0 +1 @@
+export declare const deepClone: <const TObject>(obj: TObject) => TObject;

package/dist/deepClone.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepClone = void 0;
+const deepClone = (obj) => {
+    return typeof 'structuredClone' === 'function'
+        ? structuredClone(obj)
+        : JSON.parse(JSON.stringify(obj));
+};
+exports.deepClone = deepClone;

package/dist/deepClone.mjs

@@ -0,0 +1,3 @@
+export var deepClone = function(obj) {
+    return typeof "structuredClone" === "function" ? structuredClone(obj) : JSON.parse(JSON.stringify(obj));
+};

package/dist/deepMerge.d.ts

@@ -0,0 +1,5 @@
+export type MergeOptions = {
+    arrays?: false;
+    callback?: (key: string, leftVal: any, rightVal: any) => any;
+};
+export declare const deepMerge: <const TLeft extends Record<string, any>, const TRight extends Record<string, any>>(left: TLeft, right: TRight, options?: MergeOptions) => TLeft & TRight;

package/dist/deepMerge.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepMerge = void 0;
+const deepMerge = (left, right, options) => {
+    const result = Object.assign({}, left);
+    const { arrays = true } = options || {};
+    for (const key in right) {
+        const leftVal = result[key];
+        const rightVal = right[key];
+        if (options?.callback) {
+            const res = options.callback(key, leftVal, rightVal);
+            if (res !== undefined) {
+                result[key] = res;
+                continue;
+            }
+        }
+        if (Array.isArray(leftVal) && Array.isArray(rightVal)) {
+            result[key] = arrays
+                ? result[key].concat(...rightVal)
+                : rightVal;
+            continue;
+        }
+        if (rightVal instanceof Function) {
+            result[key] = rightVal;
+            continue;
+        }
+        if (leftVal instanceof Object && rightVal instanceof Object) {
+            if (rightVal.constructor !== Object) {
+                result[key] = rightVal;
+                continue;
+            }
+            result[key] = (0, exports.deepMerge)(leftVal, rightVal, options);
+            continue;
+        }
+        result[key] = rightVal;
+    }
+    return result;
+};
+exports.deepMerge = deepMerge;

package/dist/deepMerge.mjs

@@ -0,0 +1,66 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+export var deepMerge = function(left, right, options) {
+    var result = Object.assign({}, left);
+    var _ref = options || {}, _ref_arrays = _ref.arrays, arrays = _ref_arrays === void 0 ? true : _ref_arrays;
+    for(var key in right){
+        var leftVal = result[key];
+        var rightVal = right[key];
+        if (options === null || options === void 0 ? void 0 : options.callback) {
+            var res = options.callback(key, leftVal, rightVal);
+            if (res !== undefined) {
+                result[key] = res;
+                continue;
+            }
+        }
+        if (Array.isArray(leftVal) && Array.isArray(rightVal)) {
+            var _result_key;
+            result[key] = arrays ? (_result_key = result[key]).concat.apply(_result_key, _to_consumable_array(rightVal)) : rightVal;
+            continue;
+        }
+        if (_instanceof(rightVal, Function)) {
+            result[key] = rightVal;
+            continue;
+        }
+        if (_instanceof(leftVal, Object) && _instanceof(rightVal, Object)) {
+            if (rightVal.constructor !== Object) {
+                result[key] = rightVal;
+                continue;
+            }
+            result[key] = deepMerge(leftVal, rightVal, options);
+            continue;
+        }
+        result[key] = rightVal;
+    }
+    return result;
+};

package/dist/dynamicImport.d.ts

@@ -0,0 +1 @@
+export declare const dynamicImport: (path: string) => Promise<any>;

package/dist/dynamicImport.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dynamicImport = void 0;
+const dynamicImport = async (path) => {
+    try {
+        return require(path);
+    }
+    catch (err) {
+    }
+    const fn = new Function(`return (async () => {
+      const { pathToFileURL } = await import('url')
+      return import(pathToFileURL('${path.replace(/\\/g, '\\\\')}'))
+    })()`);
+    return fn();
+};
+exports.dynamicImport = dynamicImport;

package/dist/dynamicImport.mjs

@@ -0,0 +1,145 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+export var dynamicImport = function() {
+    var _ref = _async_to_generator(function(path) {
+        var fn;
+        return _ts_generator(this, function(_state) {
+            try {
+                return [
+                    2,
+                    require(path)
+                ];
+            } catch (err) {}
+            fn = new Function("return (async () => {\n      const { pathToFileURL } = await import('url')\n      return import(pathToFileURL('".concat(path.replace(/\\/g, "\\\\"), "'))\n    })()"));
+            return [
+                2,
+                fn()
+            ];
+        });
+    });
+    return function dynamicImport(path) {
+        return _ref.apply(this, arguments);
+    };
+}();