@valkyriestudios/utils 12.37.0 → 12.38.0

package/esm/equal.js

@@ -0,0 +1,67 @@
+function isArrayEqual(a, b) {
+    const a_len = a.length;
+    if (a_len !== b.length)
+        return false;
+    for (let i = a_len - 1; i >= 0; i--) {
+        if (!equal(a[i], b[i]))
+            return false;
+    }
+    return true;
+}
+function isObjectEqual(a, b) {
+    const a_keys = Object.keys(a);
+    const b_keys = Object.keys(b);
+    const a_len = a_keys.length;
+    if (a_len !== b_keys.length)
+        return false;
+    for (let i = a_len - 1; i >= 0; i--) {
+        const key = a_keys[i];
+        if (!equal(a[key], b[key]))
+            return false;
+    }
+    return true;
+}
+function isMapEqual(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const [key, value] of a) {
+        if (!b.has(key) || !equal(value, b.get(key)))
+            return false;
+    }
+    return true;
+}
+function equal(a, b) {
+    if (a === b)
+        return true;
+    switch (typeof a) {
+        case 'number':
+            return Number.isNaN(b) && Number.isNaN(a);
+        case 'object': {
+            if (a === null || b === null)
+                return false;
+            if (Array.isArray(a))
+                return Array.isArray(b) && isArrayEqual(a, b);
+            const proto_a = Object.prototype.toString.call(a);
+            const proto_b = Object.prototype.toString.call(b);
+            if (proto_a !== proto_b)
+                return false;
+            switch (proto_a) {
+                case '[object Date]':
+                    return a.valueOf() === b.valueOf();
+                case '[object Object]':
+                    return isObjectEqual(a, b);
+                case '[object Error]':
+                    return a.name === b.name && a.message === b.message;
+                case '[object RegExp]':
+                    return String(a) === String(b);
+                case '[object Map]':
+                    return isMapEqual(a, b);
+                default:
+                    return false;
+            }
+        }
+        default:
+            return false;
+    }
+}
+export { equal, equal as default };

package/esm/formdata/index.js

@@ -0,0 +1,2 @@
+export { toObject } from './toObject';
+export { isFormData } from './is';

package/esm/formdata/is.js

@@ -0,0 +1,4 @@
+function isFormData(val) {
+    return val instanceof FormData;
+}
+export { isFormData, isFormData as default };

package/esm/formdata/toObject.js

@@ -0,0 +1,89 @@
+import { isDateFormat } from '../date/isFormat';
+const RGX_TOKENS = /[^.[\]]+/g;
+function assign(acc, rawkey, value, single) {
+    let cursor = acc;
+    const keys = rawkey.match(RGX_TOKENS);
+    const keys_len = keys.length;
+    for (let i = 0; i < keys_len; i++) {
+        const key = keys[i];
+        switch (key) {
+            case '__proto__':
+            case 'constructor':
+            case 'prototype':
+                return;
+            default: {
+                if (i < (keys_len - 1)) {
+                    const n_key = Array.isArray(cursor) ? Number(key) : key;
+                    if (!cursor[n_key])
+                        cursor[n_key] = Number.isInteger(+keys[i + 1]) ? [] : {};
+                    cursor = cursor[n_key];
+                }
+                else if (!(key in cursor) || (single && single.has(key))) {
+                    cursor[key] = value;
+                }
+                else {
+                    const cursor_val = cursor[key];
+                    if (Array.isArray(cursor_val)) {
+                        cursor_val.push(value);
+                    }
+                    else {
+                        cursor[key] = [cursor_val, value];
+                    }
+                }
+            }
+        }
+    }
+}
+function toObject(form, config) {
+    if (!(form instanceof FormData))
+        throw new Error('formdata/toObject: Value is not an instance of FormData');
+    const set = config?.raw === true ? null : new Set(Array.isArray(config?.raw) ? config?.raw : []);
+    const set_guard = !!(set && set.size > 0);
+    const single = Array.isArray(config?.single) ? new Set(config.single) : null;
+    const nBool = config?.normalize_bool !== false;
+    const nNull = config?.normalize_null !== false;
+    const nDate = config?.normalize_date !== false;
+    const nNumber = config?.normalize_number !== false;
+    const acc = {};
+    if (set === null) {
+        form.forEach((value, key) => assign(acc, key, value, single));
+    }
+    else {
+        form.forEach((value, key) => {
+            if (set_guard && set.has(key))
+                return assign(acc, key, value, single);
+            switch (value) {
+                case 'true':
+                case 'TRUE':
+                case 'True':
+                    assign(acc, key, nBool ? true : value, single);
+                    break;
+                case 'false':
+                case 'FALSE':
+                case 'False':
+                    assign(acc, key, nBool ? false : value, single);
+                    break;
+                case 'null':
+                case 'NULL':
+                case 'Null':
+                    assign(acc, key, nNull ? null : value, single);
+                    break;
+                default: {
+                    if (typeof value === 'string' && value.length) {
+                        if (nNumber) {
+                            const nVal = Number(value);
+                            if (!isNaN(nVal))
+                                return assign(acc, key, nVal, single);
+                        }
+                        if (nDate &&
+                            isDateFormat(value, 'ISO'))
+                            return assign(acc, key, new Date(value), single);
+                    }
+                    assign(acc, key, value, single);
+                }
+            }
+        });
+    }
+    return acc;
+}
+export { toObject, toObject as default };

package/esm/function/debounce.js

@@ -0,0 +1,39 @@
+import { isFunction } from './is';
+import { isIntegerAbove } from '../number/isIntegerAbove';
+function debounce(fn, wait) {
+    if (!isFunction(fn))
+        throw new Error('functions/debounce: Expected a function');
+    if (!isIntegerAbove(wait, 0))
+        throw new Error('functions/debounce: Wait should be an integer above 0');
+    let timeout;
+    let self;
+    let current_args;
+    let current_rslt;
+    const clear = () => {
+        if (!timeout)
+            return;
+        clearTimeout(timeout);
+        timeout = null;
+    };
+    const flush = () => {
+        if (!timeout)
+            return;
+        current_rslt = fn.apply(self, current_args);
+        clearTimeout(timeout);
+        timeout = null;
+    };
+    const debouncedFn = function (...args) {
+        self = this;
+        current_args = args;
+        clear();
+        timeout = setTimeout(() => {
+            timeout = null;
+            current_rslt = fn.apply(self, current_args);
+        }, wait);
+        return current_rslt;
+    };
+    debouncedFn.cancel = clear;
+    debouncedFn.flush = flush;
+    return debouncedFn;
+}
+export { debounce, debounce as default };

package/esm/function/index.js

@@ -0,0 +1,9 @@
+export { debounce } from './debounce';
+export { noop } from './noop';
+export { noopresolve } from './noopresolve';
+export { noopreturn } from './noopreturn';
+export { sleep } from './sleep';
+export { isFunction } from './is';
+export { isFunction as isFn } from './is';
+export { isAsyncFunction } from './isAsync';
+export { isAsyncFunction as isAsyncFn } from './isAsync';

package/esm/function/is.js

@@ -0,0 +1,4 @@
+function isFunction(val) {
+    return typeof val === 'function';
+}
+export { isFunction, isFunction as default };

package/esm/function/isAsync.js

@@ -0,0 +1,4 @@
+function isAsyncFunction(val) {
+    return typeof val === 'function' && val.constructor.name === 'AsyncFunction';
+}
+export { isAsyncFunction, isAsyncFunction as default };

package/esm/function/noop.js

@@ -0,0 +1,2 @@
+function noop() { }
+export { noop, noop as default };

package/esm/function/noopresolve.js

@@ -0,0 +1,4 @@
+function noopresolve(val) {
+    return new Promise(resolve => resolve(val));
+}
+export { noopresolve, noopresolve as default };

package/esm/function/noopreturn.js

@@ -0,0 +1,4 @@
+function noopreturn(val) {
+    return val;
+}
+export { noopreturn, noopreturn as default };

package/esm/function/sleep.js

@@ -0,0 +1,6 @@
+function sleep(ms = 1000) {
+    return new Promise(resolve => {
+        setTimeout(() => resolve(), Number.isFinite(ms) && ms > 0 ? Math.round(ms) : 0);
+    });
+}
+export { sleep, sleep as default };

package/esm/hash/fnv1A.js

@@ -0,0 +1,51 @@
+export const FNV_32 = 2166136261;
+export const FNV_64 = 1099511628211;
+const REPL_NAN = 'nan';
+const REPL_TRUE = 'true';
+const REPL_FALSE = 'false';
+const REPL_UNDEF = 'undefined';
+const REPL_NULL = 'null';
+function fnv1A(data, offset = FNV_32) {
+    let hash = offset;
+    let sanitized;
+    switch (typeof data) {
+        case 'string':
+            sanitized = data;
+            break;
+        case 'number':
+            sanitized = Number.isNaN(data) || !Number.isFinite(data) ? REPL_NAN : String(data);
+            break;
+        case 'boolean':
+            sanitized = data ? REPL_TRUE : REPL_FALSE;
+            break;
+        case 'undefined':
+            sanitized = REPL_UNDEF;
+            break;
+        case 'object':
+            if (data === null) {
+                sanitized = REPL_NULL;
+            }
+            else if (Array.isArray(data) || Object.prototype.toString.call(data) === '[object Object]') {
+                sanitized = JSON.stringify(data);
+            }
+            else if (data instanceof RegExp) {
+                sanitized = String(data);
+            }
+            else if (data instanceof Date) {
+                sanitized = String(data.getTime());
+            }
+            else {
+                throw new TypeError('An FNV1A Hash could not be calculated for this datatype');
+            }
+            break;
+        default:
+            throw new TypeError('An FNV1A Hash could not be calculated for this datatype');
+    }
+    const len = sanitized.length;
+    for (let i = 0; i < len; i++) {
+        hash ^= sanitized.charCodeAt(i);
+        hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+    }
+    return hash >>> 0;
+}
+export { fnv1A, fnv1A as default };

package/esm/hash/guid.js

@@ -0,0 +1,31 @@
+const HEX = [];
+for (let i = 0; i < 256; i++) {
+    HEX[i] = (i < 16 ? '0' : '') + i.toString(16);
+}
+function guid() {
+    const d0 = (Math.random() * 0xffffffff) | 0;
+    const d1 = (Math.random() * 0xffffffff) | 0;
+    const d2 = (Math.random() * 0xffffffff) | 0;
+    const d3 = (Math.random() * 0xffffffff) | 0;
+    return HEX[d0 & 0xff] +
+        HEX[(d0 >> 8) & 0xff] +
+        HEX[(d0 >> 16) & 0xff] +
+        HEX[(d0 >> 24) & 0xff] +
+        '-' +
+        HEX[d1 & 0xff] +
+        HEX[(d1 >> 8) & 0xff] +
+        '-' +
+        HEX[((d1 >> 16) & 0x0f) | 0x40] +
+        HEX[(d1 >> 24) & 0xff] +
+        '-' +
+        HEX[(d2 & 0x3f) | 0x80] +
+        HEX[(d2 >> 8) & 0xff] +
+        '-' +
+        HEX[(d2 >> 16) & 0xff] +
+        HEX[(d2 >> 24) & 0xff] +
+        HEX[d3 & 0xff] +
+        HEX[(d3 >> 8) & 0xff] +
+        HEX[(d3 >> 16) & 0xff] +
+        HEX[(d3 >> 24) & 0xff];
+}
+export { guid, guid as default };

package/esm/hash/index.js

@@ -0,0 +1,2 @@
+export { fnv1A } from './fnv1A';
+export { guid } from './guid';

package/esm/is.js

@@ -0,0 +1,63 @@
+import { equal } from './equal';
+import { isArray, isNeArray } from './array';
+import { isBoolean } from './boolean';
+import { isDate } from './date';
+import { isFormData } from './formdata';
+import { isFn, isAsyncFn } from './function';
+import { isRegExp } from './regexp';
+import { isObject, isNeObject } from './object';
+import { isNum, isNumBetween, isNumLt, isNumLte, isNumGt, isNumGte, isInt, isIntBetween, isIntLt, isIntLte, isIntGt, isIntGte, } from './number';
+import { isString, isStringBetween, isNeString, } from './string';
+const Is = Object.freeze({
+    Array: isArray,
+    NeArray: isNeArray,
+    NotEmptyArray: isNeArray,
+    Boolean: isBoolean,
+    Date: isDate,
+    Formdata: isFormData,
+    Function: isFn,
+    AsyncFunction: isAsyncFn,
+    Num: isNum,
+    NumBetween: isNumBetween,
+    NumAbove: isNumGt,
+    NumAboveOrEqual: isNumGte,
+    NumBelow: isNumLt,
+    NumBelowOrEqual: isNumLte,
+    NumGt: isNumGt,
+    NumGte: isNumGte,
+    NumLt: isNumLt,
+    NumLte: isNumLte,
+    Number: isNum,
+    NumberBetween: isNumBetween,
+    NumberAbove: isNumGt,
+    NumberAboveOrEqual: isNumGte,
+    NumberBelow: isNumLt,
+    NumberBelowOrEqual: isNumLte,
+    Int: isInt,
+    IntBetween: isIntBetween,
+    IntAbove: isIntGt,
+    IntAboveOrEqual: isIntGte,
+    IntBelow: isIntLt,
+    IntBelowOrEqual: isIntLte,
+    IntGt: isIntGt,
+    IntGte: isIntGte,
+    IntLt: isIntLt,
+    IntLte: isIntLte,
+    Integer: isInt,
+    IntegerBetween: isIntBetween,
+    IntegerBelow: isIntLt,
+    IntegerBelowOrEqual: isIntLte,
+    IntegerAbove: isIntGt,
+    IntegerAboveOrEqual: isIntGte,
+    RegExp: isRegExp,
+    Object: isObject,
+    NeObject: isNeObject,
+    NotEmptyObject: isNeObject,
+    String: isString,
+    StringBetween: isStringBetween,
+    NeString: isNeString,
+    NotEmptyString: isNeString,
+    Equal: equal,
+    Eq: equal,
+});
+export { Is, Is as default };

package/esm/modules/PubSub.js

@@ -0,0 +1,187 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PubSub_instances, _PubSub_subscriptions, _PubSub_name, _PubSub_log, _PubSub_store_by_default, _PubSub_publishToSubscriber;
+import { isArray } from '../array/is';
+import { isFunction } from '../function/is';
+import { noop } from '../function/noop';
+import { guid } from '../hash/guid';
+import { isObject } from '../object/is';
+import { isNotEmptyObject } from '../object/isNotEmpty';
+import { isNotEmptyString } from '../string/isNotEmpty';
+class PubSub {
+    constructor(options = {}) {
+        _PubSub_instances.add(this);
+        _PubSub_subscriptions.set(this, new Map());
+        _PubSub_name.set(this, 'PubSub');
+        _PubSub_log.set(this, noop);
+        _PubSub_store_by_default.set(this, false);
+        if (!isObject(options))
+            throw new Error('PubSub@ctor: options should be an object');
+        if ('logger' in options) {
+            if (!isFunction(options.logger))
+                throw new Error('PubSub@ctor: logger should be a function');
+            __classPrivateFieldSet(this, _PubSub_log, options.logger, "f");
+        }
+        if ('name' in options) {
+            if (!isNotEmptyString(options.name))
+                throw new Error('PubSub@ctor: name should be a non-empty string');
+            __classPrivateFieldSet(this, _PubSub_name, options.name.trim(), "f");
+        }
+        if ('store' in options) {
+            if (options.store !== true && options.store !== false)
+                throw new Error('PubSub@ctor: store should be a boolean');
+            __classPrivateFieldSet(this, _PubSub_store_by_default, !!options.store, "f");
+        }
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _PubSub_name, "f");
+    }
+    publish(event, data, store) {
+        if (!isNotEmptyString(event))
+            return;
+        let entry = __classPrivateFieldGet(this, _PubSub_subscriptions, "f").get(event);
+        const shouldStore = store !== undefined ? store : __classPrivateFieldGet(this, _PubSub_store_by_default, "f");
+        if (!entry) {
+            if (!shouldStore)
+                return;
+            entry = { value: data, subscribers: new Map() };
+            __classPrivateFieldGet(this, _PubSub_subscriptions, "f").set(event, entry);
+        }
+        else if (shouldStore) {
+            entry.value = data;
+        }
+        const entriesArray = [...entry.subscribers.entries()];
+        for (const [client_id, client_handler] of entriesArray) {
+            __classPrivateFieldGet(this, _PubSub_instances, "m", _PubSub_publishToSubscriber).call(this, event, entry, client_id, client_handler, data);
+        }
+        if (!shouldStore && !entry.subscribers.size)
+            __classPrivateFieldGet(this, _PubSub_subscriptions, "f").delete(event);
+    }
+    subscribe(events, client_id, override = true) {
+        if (!isNotEmptyObject(events))
+            return null;
+        const uid = isNotEmptyString(client_id) ? client_id : guid();
+        for (const event of Object.keys(events)) {
+            const raw_payload = events[event];
+            let normalized_payload = null;
+            if (isFunction(raw_payload)) {
+                normalized_payload = { run: raw_payload, once: false };
+            }
+            else if (isFunction(raw_payload?.run)) {
+                normalized_payload = {
+                    run: raw_payload.run,
+                    once: raw_payload.once === true,
+                };
+            }
+            if (!normalized_payload)
+                continue;
+            let entry = __classPrivateFieldGet(this, _PubSub_subscriptions, "f").get(event);
+            if (!entry) {
+                entry = { subscribers: new Map(), value: undefined };
+                __classPrivateFieldGet(this, _PubSub_subscriptions, "f").set(event, entry);
+            }
+            if (override === false && entry.subscribers.has(uid))
+                continue;
+            entry.subscribers.set(uid, normalized_payload);
+            if (entry.value !== undefined) {
+                __classPrivateFieldGet(this, _PubSub_instances, "m", _PubSub_publishToSubscriber).call(this, event, entry, uid, normalized_payload, entry.value);
+            }
+        }
+        return uid;
+    }
+    unsubscribe(client_id, event) {
+        if (!isNotEmptyString(client_id))
+            return;
+        const events = isNotEmptyString(event)
+            ? [event]
+            : isArray(event)
+                ? event
+                : [...__classPrivateFieldGet(this, _PubSub_subscriptions, "f").keys()];
+        for (let i = 0; i < events.length; i++) {
+            const ev = events[i];
+            if (!isNotEmptyString(ev))
+                continue;
+            const entry = __classPrivateFieldGet(this, _PubSub_subscriptions, "f").get(ev);
+            if (entry) {
+                entry.subscribers.delete(client_id);
+                if (!entry.subscribers.size) {
+                    __classPrivateFieldGet(this, _PubSub_subscriptions, "f").delete(ev);
+                }
+            }
+        }
+    }
+    clientIds(event) {
+        const events = isNotEmptyString(event)
+            ? [event]
+            : isArray(event)
+                ? event
+                : [...__classPrivateFieldGet(this, _PubSub_subscriptions, "f").keys()];
+        const result = new Set();
+        for (let i = 0; i < events.length; i++) {
+            const entry = __classPrivateFieldGet(this, _PubSub_subscriptions, "f").get(events[i]);
+            if (entry) {
+                for (const key of entry.subscribers.keys()) {
+                    result.add(key);
+                }
+            }
+        }
+        return result;
+    }
+    clear(event) {
+        if (isNotEmptyString(event)) {
+            __classPrivateFieldGet(this, _PubSub_subscriptions, "f").delete(event);
+        }
+        else if (isArray(event)) {
+            for (let i = 0; i < event.length; i++) {
+                const ev = event[i];
+                if (isNotEmptyString(ev)) {
+                    __classPrivateFieldGet(this, _PubSub_subscriptions, "f").delete(ev);
+                }
+            }
+        }
+        else {
+            __classPrivateFieldSet(this, _PubSub_subscriptions, new Map(), "f");
+        }
+    }
+}
+_PubSub_subscriptions = new WeakMap(), _PubSub_name = new WeakMap(), _PubSub_log = new WeakMap(), _PubSub_store_by_default = new WeakMap(), _PubSub_instances = new WeakSet(), _PubSub_publishToSubscriber = function _PubSub_publishToSubscriber(event, map, client_id, sub, data) {
+    try {
+        const out = sub.run(data);
+        if (sub.once)
+            map.subscribers.delete(client_id);
+        if (isFunction(out?.catch) && isFunction(out?.then)) {
+            Promise.resolve(out).catch(err => {
+                __classPrivateFieldGet(this, _PubSub_log, "f").call(this, {
+                    name: __classPrivateFieldGet(this, _PubSub_name, "f"),
+                    event,
+                    client_id,
+                    msg: '[async] ' + __classPrivateFieldGet(this, _PubSub_name, "f") + '@publish: ' + (err?.message || 'Unknown Error'),
+                    on: new Date(),
+                    data,
+                    err: err,
+                });
+            });
+        }
+    }
+    catch (err) {
+        __classPrivateFieldGet(this, _PubSub_log, "f").call(this, {
+            name: __classPrivateFieldGet(this, _PubSub_name, "f"),
+            event,
+            client_id,
+            msg: '[sync] ' + __classPrivateFieldGet(this, _PubSub_name, "f") + '@publish: ' + (err?.message || 'Unknown Error'),
+            on: new Date(),
+            data,
+            err: err,
+        });
+    }
+};
+export { PubSub, PubSub as default };