@powfix/core-js 0.22.1 → 0.23.0

package/dist/shared/utils/global/index.d.ts

@@ -0,0 +1,16 @@
+export { atob } from './atob.js';
+export { decodeBase64, encodeBase64 } from './base64.js';
+export { between } from './between.js';
+export { btoa } from './btoa.js';
+export { castArray } from './castArray.js';
+export { circularDistance } from './circularDistance.js';
+export { sleep } from './sleep.js';
+export { fallbackIfMatch } from './fallbackIfMatch.js';
+export { fallbackIfNull } from './fallbackIfNull.js';
+export { fallbackIfNullish } from './fallbackIfNullish.js';
+export { fallbackIfUndefined } from './fallbackIfUndefined.js';
+export { firstNonNullish } from './firstNonNullish.js';
+export { FlattenOptions, UnflattenOptions, flatten, unflatten } from './flat.js';
+export { processFirstNonNullish } from './processFirstNonNullish.js';
+export { pureEnum, pureEnumKeys, pureEnumValues } from './pureEnum.js';
+import 'base-64';

package/dist/shared/utils/global/index.js

@@ -0,0 +1,15 @@
+export * from './atob';
+export * from './base64';
+export * from './between';
+export * from './btoa';
+export * from './castArray';
+export * from './circularDistance';
+export * from './sleep';
+export * from './fallbackIfMatch';
+export * from './fallbackIfNull';
+export * from './fallbackIfNullish';
+export * from './fallbackIfUndefined';
+export * from './firstNonNullish';
+export * from './flat';
+export * from './processFirstNonNullish';
+export * from './pureEnum';

package/dist/shared/utils/global/processFirstNonNullish.cjs

@@ -0,0 +1,40 @@
+'use strict';
+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 _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);
+}
+require('../../../chunk-ETV4XYOV.cjs');
+var firstNonNullish = require('./firstNonNullish');
+function processFirstNonNullish(processor) {
+    for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+        args[_key - 1] = arguments[_key];
+    }
+    var _firstNonNullish;
+    var fallback = (_firstNonNullish = firstNonNullish).firstNonNullish.apply(_firstNonNullish, _to_consumable_array(args));
+    if (fallback == null) {
+        return void 0;
+    }
+    return processor(fallback);
+}
+exports.processFirstNonNullish = processFirstNonNullish;

package/dist/shared/utils/global/processFirstNonNullish.d.ts

@@ -0,0 +1,3 @@
+declare function processFirstNonNullish<T, R>(processor: (nonNullish: NonNullable<T>) => R, ...args: T[]): R | undefined;
+
+export { processFirstNonNullish };

package/dist/shared/utils/global/processFirstNonNullish.js

@@ -0,0 +1,38 @@
+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 _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);
+}
+import '../../../chunk-PKBMQBKP.js';
+import { firstNonNullish } from './firstNonNullish';
+function processFirstNonNullish(processor) {
+    for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+        args[_key - 1] = arguments[_key];
+    }
+    var fallback = firstNonNullish.apply(void 0, _to_consumable_array(args));
+    if (fallback == null) {
+        return void 0;
+    }
+    return processor(fallback);
+}
+export { processFirstNonNullish };

package/dist/shared/utils/global/pureEnum.cjs

@@ -0,0 +1,69 @@
+'use strict';
+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 _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);
+}
+require('../../../chunk-ETV4XYOV.cjs');
+function pureEnum(e) {
+    return Object.entries(e).filter(function(param) {
+        var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
+        return !/^-?\d+$/g.test(key) && typeof value !== "function";
+    });
+}
+function pureEnumKeys(e) {
+    return pureEnum(e).map(function(param) {
+        var _param = _sliced_to_array(param, 1), key = _param[0];
+        return key;
+    });
+}
+function pureEnumValues(e) {
+    return pureEnum(e).map(function(param) {
+        var _param = _sliced_to_array(param, 2), value = _param[1];
+        return value;
+    });
+}
+exports.pureEnum = pureEnum;
+exports.pureEnumKeys = pureEnumKeys;
+exports.pureEnumValues = pureEnumValues;

package/dist/shared/utils/global/pureEnum.d.ts

@@ -0,0 +1,18 @@
+type NonFunction<T, Type extends "keys" | "values"> = {
+    [K in keyof T]: T[K] extends Function ? never : Type extends "keys" ? K : T[K];
+}[keyof T] extends infer R ? (R extends never ? never : R) : never;
+type PureEnumReturnType<E extends object> = [NonFunction<E, "keys">, NonFunction<E, "values">][];
+/**
+ * @deprecated Use Enum instead.
+ */
+declare function pureEnum<E extends object>(e: E): PureEnumReturnType<E>;
+/**
+ * @deprecated Use Enum instead.
+ */
+declare function pureEnumKeys<E extends object>(e: E): NonFunction<E, "keys">[];
+/**
+ * @deprecated Use Enum instead.
+ */
+declare function pureEnumValues<E extends object>(e: E): NonFunction<E, "values">[];
+
+export { pureEnum, pureEnumKeys, pureEnumValues };

package/dist/shared/utils/global/pureEnum.js

@@ -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_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+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);
+}
+import '../../../chunk-PKBMQBKP.js';
+function pureEnum(e) {
+    return Object.entries(e).filter(function(param) {
+        var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
+        return !/^-?\d+$/g.test(key) && typeof value !== "function";
+    });
+}
+function pureEnumKeys(e) {
+    return pureEnum(e).map(function(param) {
+        var _param = _sliced_to_array(param, 1), key = _param[0];
+        return key;
+    });
+}
+function pureEnumValues(e) {
+    return pureEnum(e).map(function(param) {
+        var _param = _sliced_to_array(param, 2), value = _param[1];
+        return value;
+    });
+}
+export { pureEnum, pureEnumKeys, pureEnumValues };

package/dist/shared/utils/global/sleep.cjs

@@ -0,0 +1,8 @@
+'use strict';
+require('../../../chunk-ETV4XYOV.cjs');
+var sleep = function(ms) {
+    return new Promise(function(resolve) {
+        return setTimeout(resolve, ms);
+    });
+};
+exports.sleep = sleep;

package/dist/shared/utils/global/sleep.d.ts

@@ -0,0 +1,3 @@
+declare const sleep: (ms: number) => Promise<unknown>;
+
+export { sleep };

package/dist/shared/utils/global/sleep.js

@@ -0,0 +1,7 @@
+import '../../../chunk-PKBMQBKP.js';
+var sleep = function(ms) {
+    return new Promise(function(resolve) {
+        return setTimeout(resolve, ms);
+    });
+};
+export { sleep };

package/dist/shared/utils/index.cjs

@@ -0,0 +1,190 @@
+'use strict';
+var global = require('./global');
+var ArrayUtils = require('./ArrayUtils');
+var AxiosUtils = require('./AxiosUtils');
+var StringUtils = require('./StringUtils');
+var Uint8ArrayUtils = require('./Uint8ArrayUtils');
+var UuidUtils = require('./UuidUtils');
+var BooleanUtils = require('./BooleanUtils');
+var Calc = require('./Calc');
+var CoordinateUtils = require('./CoordinateUtils');
+var DateUtils = require('./DateUtils');
+var Enum = require('./Enum');
+var Enum_types = require('./Enum.types');
+var I18nUtils = require('./I18nUtils');
+var NumberUtils = require('./NumberUtils');
+var ObjectIdUtils = require('./ObjectIdUtils');
+var Point3Utils = require('./Point3Utils');
+var RandomUtils = require('./RandomUtils');
+var Validator = require('./Validator');
+var JuminNumberUtils = require('./JuminNumberUtils');
+var Sequencer = require('./Sequencer');
+var tryCatch = require('./try-catch');
+Object.keys(global).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return global[k];
+        }
+    });
+});
+Object.keys(ArrayUtils).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return ArrayUtils[k];
+        }
+    });
+});
+Object.keys(AxiosUtils).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return AxiosUtils[k];
+        }
+    });
+});
+Object.keys(StringUtils).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return StringUtils[k];
+        }
+    });
+});
+Object.keys(Uint8ArrayUtils).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return Uint8ArrayUtils[k];
+        }
+    });
+});
+Object.keys(UuidUtils).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return UuidUtils[k];
+        }
+    });
+});
+Object.keys(BooleanUtils).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return BooleanUtils[k];
+        }
+    });
+});
+Object.keys(Calc).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return Calc[k];
+        }
+    });
+});
+Object.keys(CoordinateUtils).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return CoordinateUtils[k];
+        }
+    });
+});
+Object.keys(DateUtils).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return DateUtils[k];
+        }
+    });
+});
+Object.keys(Enum).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return Enum[k];
+        }
+    });
+});
+Object.keys(Enum_types).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return Enum_types[k];
+        }
+    });
+});
+Object.keys(I18nUtils).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return I18nUtils[k];
+        }
+    });
+});
+Object.keys(NumberUtils).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return NumberUtils[k];
+        }
+    });
+});
+Object.keys(ObjectIdUtils).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return ObjectIdUtils[k];
+        }
+    });
+});
+Object.keys(Point3Utils).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return Point3Utils[k];
+        }
+    });
+});
+Object.keys(RandomUtils).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return RandomUtils[k];
+        }
+    });
+});
+Object.keys(Validator).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return Validator[k];
+        }
+    });
+});
+Object.keys(JuminNumberUtils).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return JuminNumberUtils[k];
+        }
+    });
+});
+Object.keys(Sequencer).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return Sequencer[k];
+        }
+    });
+});
+Object.keys(tryCatch).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return tryCatch[k];
+        }
+    });
+});

package/dist/shared/utils/index.d.ts

@@ -0,0 +1,44 @@
+export { atob } from './global/atob.js';
+export { decodeBase64, encodeBase64 } from './global/base64.js';
+export { between } from './global/between.js';
+export { btoa } from './global/btoa.js';
+export { castArray } from './global/castArray.js';
+export { circularDistance } from './global/circularDistance.js';
+export { sleep } from './global/sleep.js';
+export { fallbackIfMatch } from './global/fallbackIfMatch.js';
+export { fallbackIfNull } from './global/fallbackIfNull.js';
+export { fallbackIfNullish } from './global/fallbackIfNullish.js';
+export { fallbackIfUndefined } from './global/fallbackIfUndefined.js';
+export { firstNonNullish } from './global/firstNonNullish.js';
+export { FlattenOptions, UnflattenOptions, flatten, unflatten } from './global/flat.js';
+export { processFirstNonNullish } from './global/processFirstNonNullish.js';
+export { pureEnum, pureEnumKeys, pureEnumValues } from './global/pureEnum.js';
+export { ArrayUtils } from './ArrayUtils.js';
+export { AxiosUtils } from './AxiosUtils.js';
+export { StringUtils } from './StringUtils.js';
+export { Uint8ArrayUtils } from './Uint8ArrayUtils.js';
+export { UuidUtils } from './UuidUtils.js';
+export { parseBoolean } from './BooleanUtils.js';
+export { Calc } from './Calc.js';
+export { CoordinateUtils } from './CoordinateUtils.js';
+export { DateUtils } from './DateUtils.js';
+export { Enum } from './Enum.js';
+export { EnumEntries, EnumEntry } from './Enum.types.js';
+export { I18nUtils } from './I18nUtils.js';
+export { NumberUtils } from './NumberUtils.js';
+export { ObjectIdUtils } from './ObjectIdUtils.js';
+export { Point3Utils } from './Point3Utils.js';
+export { RandomUtils } from './RandomUtils.js';
+export { Validator } from './Validator.js';
+export { JuminNumberUtils } from './JuminNumberUtils.js';
+export { Sequence, Sequencer, SequencerEvent, SequencerOption, SequencerStatus } from './Sequencer.js';
+export { TryCatch } from './try-catch/TryCatch.js';
+import 'base-64';
+import 'axios';
+import '../interfaces/Coordinate.js';
+import 'moment';
+import '../constants/DATE.js';
+import 'i18next';
+import '../interfaces/Point3.js';
+import '../interfaces/Point2.js';
+import 'eventemitter3';

package/dist/shared/utils/index.js

@@ -0,0 +1,21 @@
+export * from './global';
+export * from './ArrayUtils';
+export * from './AxiosUtils';
+export * from './StringUtils';
+export * from './Uint8ArrayUtils';
+export * from './UuidUtils';
+export * from './BooleanUtils';
+export * from './Calc';
+export * from './CoordinateUtils';
+export * from './DateUtils';
+export * from './Enum';
+export * from './Enum.types';
+export * from './I18nUtils';
+export * from './NumberUtils';
+export * from './ObjectIdUtils';
+export * from './Point3Utils';
+export * from './RandomUtils';
+export * from './Validator';
+export * from './JuminNumberUtils';
+export * from './Sequencer';
+export * from './try-catch';