@koine/utils 2.0.0-beta.72 → 2.0.0-beta.74

package/cookie.d.ts

@@ -12,7 +12,4 @@ export type CookieAttributesServer = CookieAttributes & {
     decode?: (input: string) => string;
 };
 export type CookieAttributesClient = CookieAttributes;
-export declare let defaultAttributesClient: {
-    path: string;
-};
 export {};

package/cookie.js

@@ -0,0 +1 @@
+export let defaultAttributesClient = { path: "/" };

package/createPalette.d.ts

@@ -7,4 +7,4 @@ type PaletteMap<T extends PaletteShades> = {
     [PS in T[number] as keyof PaletteMapPair<PS>]: PaletteMapPair<PS>[keyof PaletteMapPair<PS>];
 };
 export declare let createPalette: <TName extends string, TShades extends PaletteShades, TColor = TShades[number][1], TMap = PaletteMap<TShades>>(name: TName, shades: TShades) => readonly [TMap, Record<`${TName}-${TShades[number][0]}`, string>, TColor[]];
-export {};
+export default createPalette;

package/createPalette.js

@@ -0,0 +1,12 @@
+export let createPalette = (name, shades) => {
+    const map = shades.reduce((map, def) => {
+        map[def[0]] = def[1];
+        return map;
+    }, {});
+    const tailwindPalette = shades.reduce((map, def) => {
+        map[`${name}-${def[0]}`] = def[1];
+        return map;
+    }, {});
+    return [map, tailwindPalette, Object.values(map)];
+};
+export default createPalette;

package/debounce.d.ts

@@ -1 +1,2 @@
 export declare let debounce: <T extends (...args: any[]) => any>(fn: T, wait?: number, immediate?: boolean) => (this: unknown, ...args: Parameters<T>) => void;
+export default debounce;

package/debounce.js

@@ -0,0 +1,18 @@
+export let debounce = (fn, wait, immediate) => {
+    let timeout;
+    return function (...args) {
+        const context = this;
+        const later = function () {
+            timeout = null;
+            if (!immediate)
+                fn.apply(context, args);
+        };
+        const callNow = immediate && !timeout;
+        if (timeout)
+            clearTimeout(timeout);
+        timeout = setTimeout(later, wait);
+        if (callNow)
+            fn.apply(context, args);
+    };
+};
+export default debounce;

package/debouncePromise.d.ts

@@ -8,3 +8,4 @@ export interface DebouncedFunction<Args extends any[], F extends (...args: Args)
     cancel: (reason?: any) => void;
 }
 export declare let debouncePromise: <Args extends any[], F extends (...args: Args) => any>(func: F, waitMilliseconds?: number, options?: DebounceOptions<ReturnType<F>>) => DebouncedFunction<Args, F>;
+export default debouncePromise;

package/debouncePromise.js

@@ -0,0 +1,52 @@
+export let debouncePromise = (func, waitMilliseconds = 50, options = {}) => {
+    let timeoutId;
+    const isImmediate = options.isImmediate ?? false;
+    const callback = options.callback ?? false;
+    const maxWait = options.maxWait;
+    let lastInvokeTime = Date.now();
+    let promises = [];
+    function nextInvokeTimeout() {
+        if (maxWait !== undefined) {
+            const timeSinceLastInvocation = Date.now() - lastInvokeTime;
+            if (timeSinceLastInvocation + waitMilliseconds >= maxWait) {
+                return maxWait - timeSinceLastInvocation;
+            }
+        }
+        return waitMilliseconds;
+    }
+    const debouncedFunction = function (...args) {
+        const context = this;
+        return new Promise((resolve, reject) => {
+            const invokeFunction = function () {
+                timeoutId = undefined;
+                lastInvokeTime = Date.now();
+                if (!isImmediate) {
+                    const result = func.apply(context, args);
+                    callback && callback(result);
+                    promises.forEach(({ resolve }) => resolve(result));
+                    promises = [];
+                }
+            };
+            const shouldCallNow = isImmediate && timeoutId === undefined;
+            if (timeoutId !== undefined) {
+                clearTimeout(timeoutId);
+            }
+            timeoutId = setTimeout(invokeFunction, nextInvokeTimeout());
+            if (shouldCallNow) {
+                const result = func.apply(context, args);
+                callback && callback(result);
+                return resolve(result);
+            }
+            promises.push({ resolve, reject });
+        });
+    };
+    debouncedFunction.cancel = function (reason) {
+        if (timeoutId !== undefined) {
+            clearTimeout(timeoutId);
+        }
+        promises.forEach(({ reject }) => reject(reason));
+        promises = [];
+    };
+    return debouncedFunction;
+};
+export default debouncePromise;

package/debounceRaf.d.ts

@@ -1 +1,2 @@
 export declare function debounceRaf<T extends (...args: any[]) => any>(this: unknown, fn: T): (this: unknown, ...args: Parameters<T>) => void;
+export default debounceRaf;

package/debounceRaf.js

@@ -0,0 +1,13 @@
+export function debounceRaf(fn) {
+    let timeout;
+    return function (...args) {
+        const context = this;
+        if (timeout) {
+            window.cancelAnimationFrame(timeout);
+        }
+        timeout = window.requestAnimationFrame(function () {
+            fn.apply(context, args);
+        });
+    };
+}
+export default debounceRaf;

package/decode.d.ts

@@ -1 +1,2 @@
 export declare let decode: <TReturn extends string>(str: string) => TReturn;
+export default decode;

package/decode.js

@@ -0,0 +1,2 @@
+export let decode = (str) => str.replace(/.{3}/g, (c) => String.fromCharCode(parseInt(c, 10)));
+export default decode;

package/encode.d.ts

@@ -1 +1,2 @@
 export declare let encode: <TReturn extends string>(str: string) => TReturn;
+export default encode;

package/encode.js

@@ -0,0 +1,2 @@
+export let encode = (str) => str.replace(/./g, (c) => ("00" + c.charCodeAt(0)).slice(-3));
+export default encode;

package/ensureInt.d.ts

@@ -1 +1,2 @@
 export declare let ensureInt: (input: string | number) => number;
+export default ensureInt;

package/ensureInt.js

@@ -0,0 +1,2 @@
+export let ensureInt = (input) => typeof input === "string" ? parseInt(input, 10) : Math.round(input);
+export default ensureInt;

package/env.js

@@ -0,0 +1 @@
+"use strict";

package/errorToString.d.ts

@@ -1 +1,2 @@
 export declare let errorToString: (e: unknown) => string;
+export default errorToString;

package/errorToString.js

@@ -0,0 +1,3 @@
+import { isString } from "./isString";
+export let errorToString = (e) => e instanceof Error ? e.message : isString(e) ? e : "";
+export default errorToString;

package/escapeRegExp.d.ts

@@ -1 +1,2 @@
 export declare let escapeRegExp: (text: string) => string;
+export default escapeRegExp;

package/escapeRegExp.js

@@ -0,0 +1,2 @@
+export let escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+export default escapeRegExp;

package/findDuplicatedIndexes.d.ts

@@ -1 +1,2 @@
 export declare let findDuplicatedIndexes: (arr: any[]) => Record<number, true>;
+export default findDuplicatedIndexes;

package/findDuplicatedIndexes.js

@@ -0,0 +1,11 @@
+export let findDuplicatedIndexes = (arr) => {
+    const indexes = {};
+    for (let i = 0; i < arr.length; i++) {
+        const idxInArray = arr.indexOf(arr[i]);
+        if (idxInArray !== i && idxInArray !== -1) {
+            indexes[i] = true;
+        }
+    }
+    return indexes;
+};
+export default findDuplicatedIndexes;

package/forin.d.ts

@@ -1 +1,2 @@
 export declare let forin: <T>(object: T, cb: <K extends keyof T>(key: K, value: T[K]) => void) => void;
+export default forin;

package/forin.js

@@ -0,0 +1,6 @@
+export let forin = (object, cb) => {
+    for (const key in object) {
+        cb(key, object[key]);
+    }
+};
+export default forin;

package/gbToBytes.d.ts

@@ -1 +1,2 @@
 export declare let gbToBytes: (bytes: number) => number;
+export default gbToBytes;

package/gbToBytes.js

@@ -0,0 +1,2 @@
+export let gbToBytes = (bytes) => bytes * 1000 * 1000 * 1000;
+export default gbToBytes;

package/getEmptyArray.d.ts

@@ -1 +1,2 @@
 export declare let getEmptyArray: (length: number | string) => undefined[];
+export default getEmptyArray;

package/getEmptyArray.js

@@ -0,0 +1,5 @@
+import { isNumber } from "./isNumber";
+export let getEmptyArray = (length) => Array.from({
+    length: !isNumber(length) ? parseInt(length, 10) : length,
+});
+export default getEmptyArray;

package/getKeys.d.ts

@@ -1 +1,2 @@
 export declare let getKeys: <T extends object>(obj: T) => (keyof T)[];
+export default getKeys;

package/getKeys.js

@@ -0,0 +1,2 @@
+export let getKeys = Object.keys;
+export default getKeys;

package/getMediaQueryWidthResolvers.d.ts

@@ -7,3 +7,4 @@ export declare let getMediaQueryWidthResolvers: <TBreakpointsConfig extends GetM
     between: (br1: Extract<keyof TBreakpointsConfig, string>, br2?: Extract<keyof TBreakpointsConfig, string> | undefined) => string;
     only: (br: Extract<keyof TBreakpointsConfig, string>) => string;
 };
+export default getMediaQueryWidthResolvers;

package/getMediaQueryWidthResolvers.js

@@ -0,0 +1,42 @@
+export let getMediaQueryWidthResolvers = (customBreakpoints) => {
+    const breakpoints = {
+        xs: 0,
+        ...customBreakpoints,
+    };
+    const sortedBreakpointsNames = Object.keys(breakpoints).map((key) => {
+        const br = key;
+        return [br, breakpoints[br]];
+    })
+        .sort((a, b) => a[1] - b[1])
+        .map((item) => item[0]);
+    const getNextBreakpoint = (breakpoint) => {
+        const index = sortedBreakpointsNames.indexOf(breakpoint);
+        return sortedBreakpointsNames[index + 1];
+    };
+    const min = (br) => `(min-width: ${breakpoints[br]}px)`;
+    const max = (br) => `(max-width: ${breakpoints[br] - 0.02}px)`;
+    const up = min;
+    const down = (br) => {
+        const brNext = getNextBreakpoint(br);
+        return brNext && `(max-width: ${breakpoints[brNext] - 0.02}px)`;
+    };
+    const between = (br1, br2) => {
+        br2 = br2 || getNextBreakpoint(br1);
+        return br2
+            ? `(min-width: ${breakpoints[br1]}px) and (max-width: ${breakpoints[br2] - 0.02}px)`
+            : min(br1);
+    };
+    const only = (br) => {
+        const brNext = getNextBreakpoint(br);
+        return brNext ? between(br, brNext) : min(br);
+    };
+    return {
+        max,
+        min,
+        down,
+        up,
+        between,
+        only,
+    };
+};
+export default getMediaQueryWidthResolvers;

package/getMediaQueryWidthTailwindScreens.d.ts

@@ -2,3 +2,4 @@ import { type GetMediaQueryWidthResolversBreakpoints } from "./getMediaQueryWidt
 export declare let getMediaQueryWidthTailwindScreens: (breakpoints: GetMediaQueryWidthResolversBreakpoints) => Record<string, {
     raw: string;
 }>;
+export default getMediaQueryWidthTailwindScreens;

package/getMediaQueryWidthTailwindScreens.js

@@ -0,0 +1,27 @@
+import { getMediaQueryWidthResolvers, } from "./getMediaQueryWidthResolvers";
+export let getMediaQueryWidthTailwindScreens = (breakpoints) => {
+    const mqWidthResolvers = getMediaQueryWidthResolvers(breakpoints);
+    const screens = Object.keys(breakpoints).reduce((output, br, idx) => {
+        const brNext = Object.keys(breakpoints)[idx + 1];
+        for (const resolverName in mqWidthResolvers) {
+            const resolver = resolverName;
+            const resolverFn = mqWidthResolvers[resolver];
+            const raw = resolverFn(br);
+            if (raw) {
+                if (resolverName === "min") {
+                    output[`@${br}`] = { raw };
+                }
+                if (resolverName === "between") {
+                    if (brNext)
+                        output[`@${resolverName}-${br}_${brNext}`] = { raw };
+                }
+                else {
+                    output[`@${resolverName}-${br}`] = { raw };
+                }
+            }
+        }
+        return output;
+    }, {});
+    return screens;
+};
+export default getMediaQueryWidthTailwindScreens;

package/getNonce.d.ts

@@ -1 +1,2 @@
 export declare let getNonce: () => string | null;
+export default getNonce;

package/getNonce.js

@@ -0,0 +1,3 @@
+import { isUndefined } from "./isUndefined";
+export let getNonce = () => isUndefined(__webpack_nonce__) ? null : __webpack_nonce__;
+export default getNonce;

package/getParamAmong.d.ts

@@ -1 +1,2 @@
 export declare let getParamAmong: <T extends string[]>(raw?: string | string[], allowedValues?: T) => T[number] | null;
+export default getParamAmong;

package/getParamAmong.js

@@ -0,0 +1,6 @@
+import { getParamAsString } from "./getParamAsString";
+export let getParamAmong = (raw, allowedValues = []) => {
+    const string = getParamAsString(raw);
+    return allowedValues.includes(string) ? string : null;
+};
+export default getParamAmong;

package/getParamAsInt.d.ts

@@ -1 +1,2 @@
 export declare let getParamAsInt: <TFallback extends number | null | undefined>(raw?: string | string[], fallback?: TFallback) => number | TFallback;
+export default getParamAsInt;

package/getParamAsInt.js

@@ -0,0 +1,9 @@
+import { getParamAsString } from "./getParamAsString";
+export let getParamAsInt = (raw, fallback = null) => {
+    const string = getParamAsString(raw);
+    if (string) {
+        return parseInt(string, 10);
+    }
+    return fallback;
+};
+export default getParamAsInt;

package/getParamAsString.d.ts

@@ -1 +1,2 @@
 export declare let getParamAsString: (raw?: string | string[]) => string;
+export default getParamAsString;

package/getParamAsString.js

@@ -0,0 +1,3 @@
+import { isArray } from "./isArray";
+export let getParamAsString = (raw) => (isArray(raw) ? raw[0] : raw) || "";
+export default getParamAsString;

package/getType.d.ts

@@ -7,3 +7,4 @@ export type PlainObjectStringKeyed = {
 };
 export type TypeGuard<A, B extends A> = (payload: A) => payload is B;
 export declare let getType: (payload: any) => string;
+export default getType;

package/getType.js

@@ -0,0 +1,2 @@
+export let getType = (payload) => Object.prototype.toString.call(payload).slice(8, -1);
+export default getType;

package/getUrlHashParams.d.ts

@@ -1 +1,2 @@
 export declare let getUrlHashParams: <T extends Record<string | number, unknown>>(hash?: string) => T;
+export default getUrlHashParams;

package/getUrlHashParams.js

@@ -0,0 +1,9 @@
+export let getUrlHashParams = (hash = "") => {
+    hash = hash || location.hash;
+    const hashParts = hash.split("?");
+    if (hashParts.length >= 1) {
+        return Object.fromEntries(new URLSearchParams(hashParts[1]));
+    }
+    return {};
+};
+export default getUrlHashParams;

package/getUrlHashPathname.d.ts

@@ -1 +1,2 @@
 export declare let getUrlHashPathname: (hash?: string) => string;
+export default getUrlHashPathname;

package/getUrlHashPathname.js

@@ -0,0 +1,2 @@
+export let getUrlHashPathname = (hash = "") => (hash || location.hash).split("?")[0].replace(/^#\//, "");
+export default getUrlHashPathname;

package/getUrlPathnameParts.d.ts

@@ -1 +1,2 @@
 export declare let getUrlPathnameParts: (pathname?: string) => string[];
+export default getUrlPathnameParts;

package/getUrlPathnameParts.js

@@ -0,0 +1,6 @@
+import { isBrowser } from "./isBrowser";
+export let getUrlPathnameParts = (pathname = "") => (pathname || (isBrowser ? location.pathname : ""))
+    .replace(/^\//, "")
+    .split("/")
+    .filter(Boolean);
+export default getUrlPathnameParts;

package/getUrlQueryParams.d.ts

@@ -1 +1,2 @@
 export declare let getUrlQueryParams: <T extends Record<string | number, unknown>>(url?: string) => T;
+export default getUrlQueryParams;

package/getUrlQueryParams.js

@@ -0,0 +1,22 @@
+import { isBrowser } from "./isBrowser";
+export let getUrlQueryParams = (url) => {
+    let params = {};
+    const search = url
+        ? url.split("?")?.[1]
+        : isBrowser
+            ? location.search.substring(1)
+            : "";
+    if (!search) {
+        return {};
+    }
+    try {
+        const paramsAsObj = `{"${search
+            .replace(/&/g, '","')
+            .replace(/=/g, '":"')}"}`;
+        params = JSON.parse(paramsAsObj, (key, value) => key === "" ? value : decodeURIComponent(value));
+    }
+    catch (e) {
+    }
+    return params;
+};
+export default getUrlQueryParams;

package/imgEmptyPixel.d.ts

@@ -1 +1,2 @@
 export declare let imgEmptyPixel: string;
+export default imgEmptyPixel;

package/imgEmptyPixel.js

@@ -0,0 +1,2 @@
+export let imgEmptyPixel = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=";
+export default imgEmptyPixel;