@mxfb/tools 0.2.3 → 0.3.0

package/agnostic/html/sanitize/index.d.ts

@@ -0,0 +1,24 @@
+export declare namespace Sanitize {
+    type AttributeNameValPair = {
+        attributeName: string | RegExp;
+        attributeValues?: Array<string | RegExp>;
+    };
+    type Options = {
+        inputFreeTransform?: (input: string) => string;
+        keepComments?: boolean;
+        allowedTags?: string[];
+        forbiddenTags?: string[];
+        allowedAttributes?: {
+            [tagName: string]: AttributeNameValPair[];
+        };
+        forbiddenAttributes?: {
+            [tagName: string]: AttributeNameValPair[];
+        };
+        depth?: number;
+        verbose?: boolean;
+        documentObj?: Document;
+    };
+    const defaultOptions: Options;
+    function sanitize(inputStr: string, options?: Options): string;
+    function sanitizeElement(element: Element, options?: Options): Element | null;
+}

package/agnostic/html/sanitize/index.js

@@ -0,0 +1,9 @@
+import {
+  Sanitize
+} from "../../../chunks/chunk-IFD7GSGK.js";
+import "../../../chunks/chunk-KQT5CTGF.js";
+import "../../../chunks/chunk-GJOU3UAL.js";
+import "../../../chunks/chunk-MT74WIQR.js";
+export {
+  Sanitize
+};

package/agnostic/html/selector-to-element/index.d.ts

@@ -0,0 +1 @@
+export declare function selectorToElement(selector: string, documentObj?: Document): HTMLElement;

package/agnostic/html/selector-to-element/index.js

@@ -0,0 +1,9 @@
+import {
+  selectorToElement
+} from "../../../chunks/chunk-XN3PZIVL.js";
+import "../../../chunks/chunk-KQT5CTGF.js";
+import "../../../chunks/chunk-GJOU3UAL.js";
+import "../../../chunks/chunk-MT74WIQR.js";
+export {
+  selectorToElement
+};

package/agnostic/html/string-to-nodes/index.d.ts

@@ -0,0 +1,7 @@
+import { Sanitize } from '~/agnostic/html/sanitize';
+type Options = {
+    sanitize?: Sanitize.Options;
+    documentObj?: Document;
+};
+export declare function stringToNodes(dirtyStr: string, options?: Options): Node[];
+export {};

package/agnostic/html/string-to-nodes/index.js

@@ -0,0 +1,10 @@
+import {
+  stringToNodes
+} from "../../../chunks/chunk-NRJQKVQV.js";
+import "../../../chunks/chunk-IFD7GSGK.js";
+import "../../../chunks/chunk-KQT5CTGF.js";
+import "../../../chunks/chunk-GJOU3UAL.js";
+import "../../../chunks/chunk-MT74WIQR.js";
+export {
+  stringToNodes
+};

package/agnostic/misc/assert/index.d.ts

@@ -0,0 +1,5 @@
+export declare namespace Assert {
+    type Assertion = (() => boolean) | boolean;
+    export function assert(label: string, assertion: Assertion | Array<Assertion>): void;
+    export {};
+}

package/agnostic/misc/assert/index.js

@@ -0,0 +1,6 @@
+import {
+  Assert
+} from "../../../chunks/chunk-W7YBGJ4H.js";
+export {
+  Assert
+};

package/agnostic/misc/cast/index.d.ts

@@ -0,0 +1,9 @@
+export declare namespace Cast {
+    function toBoolean(value: unknown): boolean;
+    function toNumber(value: unknown): number;
+    function toString(value: unknown): string;
+    function toNull(_value: unknown): null;
+    function toArray(value: unknown): any[];
+    function toNumberArr(value: unknown): number[];
+    function toRecord(value: unknown): Record<string, unknown>;
+}

package/agnostic/misc/cast/index.js

@@ -0,0 +1,8 @@
+import {
+  Cast
+} from "../../../chunks/chunk-4QQBKBYH.js";
+import "../../../chunks/chunk-QXAJXTXV.js";
+import "../../../chunks/chunk-HC6ZOHCS.js";
+export {
+  Cast
+};

package/agnostic/misc/crossenv/index.d.ts

@@ -0,0 +1,13 @@
+export declare namespace Crossenv {
+    enum RuntimeName {
+        NODE = "Node.js",
+        BROWSER = "Browser",
+        DENO = "Deno",
+        REACT_NATIVE = "React Native",
+        ELECTRON = "Electron",
+        CLOUDFLARE = "Cloudflare Workers",
+        AWS_LAMBDA = "AWS Lambda"
+    }
+    function detectRuntime(): RuntimeName | null;
+    function getDocument(): Document | null;
+}

package/agnostic/misc/crossenv/index.js

@@ -0,0 +1,6 @@
+import {
+  Crossenv
+} from "../../../chunks/chunk-GJOU3UAL.js";
+export {
+  Crossenv
+};

package/agnostic/misc/get-current-downlink/index.d.ts

@@ -0,0 +1 @@
+export declare function getCurrentDownlink(): number | undefined;

package/agnostic/misc/get-current-downlink/index.js

@@ -0,0 +1,6 @@
+import {
+  getCurrentDownlink
+} from "../../../chunks/chunk-7AWTHZLY.js";
+export {
+  getCurrentDownlink
+};

package/agnostic/misc/is-constructor-function/index.d.ts

@@ -0,0 +1,2 @@
+export type ConstructorFunction = new (...args: any[]) => any;
+export declare function isConstructorFunction(input: unknown): input is ConstructorFunction;

package/agnostic/misc/is-constructor-function/index.js

@@ -0,0 +1,6 @@
+import {
+  isConstructorFunction
+} from "../../../chunks/chunk-RCO57B6F.js";
+export {
+  isConstructorFunction
+};

package/agnostic/misc/is-nullish/index.d.ts

@@ -0,0 +1,4 @@
+export declare const nullishValues: (null | undefined)[];
+export type Nullish = null | undefined;
+export declare function isNullish<T>(val: T | Nullish): val is Nullish;
+export declare function isNotNullish<T>(val: T): val is Exclude<T, Nullish>;

package/agnostic/misc/is-nullish/index.js

@@ -0,0 +1,10 @@
+import {
+  isNotNullish,
+  isNullish,
+  nullishValues
+} from "../../../chunks/chunk-HC6ZOHCS.js";
+export {
+  isNotNullish,
+  isNullish,
+  nullishValues
+};

package/agnostic/misc/logs/index.d.ts

@@ -0,0 +1,55 @@
+export declare namespace Logs {
+    export function makeTextBlock(text: string, vPadding?: number, hPadding?: number): string;
+    export const styles: {
+        regular: (text: string) => string;
+        light: (text: string) => string;
+        danger: (text: string) => string;
+        important: (text: string) => string;
+        title: (text: string) => string;
+        info: (text: string) => string;
+        error: (text: string) => string;
+        warning: (text: string) => string;
+    };
+    type ConsoleMethod = 'assert' | 'count' | 'countReset' | 'debug' | 'dir' | 'dirxml' | 'error' | 'group' | 'groupCollapsed' | 'groupEnd' | 'info' | 'log' | 'table' | 'time' | 'timeEnd' | 'trace' | 'warn';
+    type ConsoleMethodsParams = {
+        assert: Parameters<typeof console.assert>;
+        count: Parameters<typeof console.count>;
+        countReset: Parameters<typeof console.countReset>;
+        debug: Parameters<typeof console.debug>;
+        dir: Parameters<typeof console.dir>;
+        dirxml: Parameters<typeof console.dirxml>;
+        error: Parameters<typeof console.error>;
+        group: Parameters<typeof console.group>;
+        groupCollapsed: Parameters<typeof console.groupCollapsed>;
+        groupEnd: Parameters<typeof console.groupEnd>;
+        info: Parameters<typeof console.info>;
+        log: Parameters<typeof console.log>;
+        table: Parameters<typeof console.table>;
+        time: Parameters<typeof console.time>;
+        timeEnd: Parameters<typeof console.timeEnd>;
+        trace: Parameters<typeof console.trace>;
+        warn: Parameters<typeof console.warn>;
+    };
+    class Log<T extends ConsoleMethod = ConsoleMethod> {
+        type: T;
+        data: ConsoleMethodsParams[T];
+        time: Date;
+        stack: string;
+        constructor(type: T, data: ConsoleMethodsParams[T]);
+        get displayTime(): string;
+        get elapsedTimeMs(): number;
+        get displayStack(): string;
+    }
+    export class Logger {
+        _private_threads: Map<string, Log[]>;
+        constructor();
+        dir(thread: string | undefined, ...args: ConsoleMethodsParams['dir']): void;
+        error(thread?: string, ...args: ConsoleMethodsParams['error']): void;
+        log(thread?: string, ...args: ConsoleMethodsParams['log']): void;
+        warn(thread?: string, ...args: ConsoleMethodsParams['warn']): void;
+        setLog<T extends ConsoleMethod>(threadName: string, type: T, data: ConsoleMethodsParams[T]): this;
+        print(this: Logger, threadFilter?: string, withStack?: boolean): void;
+        printThreads(this: Logger, withStack?: boolean): void;
+    }
+    export {};
+}

package/agnostic/misc/logs/index.js

@@ -0,0 +1,6 @@
+import {
+  Logs
+} from "../../../chunks/chunk-5LNUCDQ6.js";
+export {
+  Logs
+};

package/agnostic/misc/random/index.d.ts

@@ -0,0 +1,10 @@
+export declare namespace Random {
+    function random(bound1?: number): number | undefined;
+    function random(bound1?: number, bound2?: number | undefined): number | undefined;
+    function randomInt(...args: Parameters<typeof random>): number | undefined;
+    const hexChars: string[];
+    function randomHexChar(): string;
+    function randomHash(length?: number): string;
+    function randomHashPattern(pattern: number[], joiner?: string): string;
+    function randomUUID(): string;
+}

package/agnostic/misc/random/index.js

@@ -0,0 +1,6 @@
+import {
+  Random
+} from "../../../chunks/chunk-WLL3FNVL.js";
+export {
+  Random
+};

package/agnostic/numbers/absolute-modulo/index.d.ts

@@ -0,0 +1 @@
+export declare function absoluteModulo(nbr: number, modulo: number): number;

package/agnostic/numbers/absolute-modulo/index.js

@@ -0,0 +1,6 @@
+import {
+  absoluteModulo
+} from "../../../chunks/chunk-DNIOWD7K.js";
+export {
+  absoluteModulo
+};

package/agnostic/numbers/clamp/index.d.ts

@@ -0,0 +1 @@
+export declare function clamp(num: number, bound1: number, bound2: number): number;

package/agnostic/numbers/clamp/index.js

@@ -0,0 +1,6 @@
+import {
+  clamp
+} from "../../../chunks/chunk-OSAXBA7G.js";
+export {
+  clamp
+};

package/agnostic/numbers/index.d.ts

@@ -0,0 +1,13 @@
+import { absoluteModulo as absoluteModuloFunc } from './absolute-modulo';
+import { clamp as clampFunc } from './clamp';
+import { interpolate as interpolateFunc } from './interpolate';
+import { getHarmonic as getHarmonicFunc, createScale as createScaleFunc } from './responsive-harmonics';
+import { round as roundFunc } from './round';
+export declare namespace Numbers {
+    const absoluteModulo: typeof absoluteModuloFunc;
+    const clamp: typeof clampFunc;
+    const interpolate: typeof interpolateFunc;
+    const getHarmonic: typeof getHarmonicFunc;
+    const createScale: typeof createScaleFunc;
+    const round: typeof roundFunc;
+}

package/agnostic/numbers/index.js

@@ -0,0 +1,30 @@
+import {
+  absoluteModulo
+} from "../../chunks/chunk-DNIOWD7K.js";
+import {
+  interpolate
+} from "../../chunks/chunk-EW46EXFB.js";
+import {
+  createScale,
+  getHarmonic
+} from "../../chunks/chunk-UYTXXUU7.js";
+import {
+  round
+} from "../../chunks/chunk-32IRF4OP.js";
+import {
+  clamp
+} from "../../chunks/chunk-OSAXBA7G.js";
+
+// src/agnostic/numbers/index.ts
+var Numbers;
+((Numbers2) => {
+  Numbers2.absoluteModulo = absoluteModulo;
+  Numbers2.clamp = clamp;
+  Numbers2.interpolate = interpolate;
+  Numbers2.getHarmonic = getHarmonic;
+  Numbers2.createScale = createScale;
+  Numbers2.round = round;
+})(Numbers || (Numbers = {}));
+export {
+  Numbers
+};

package/agnostic/numbers/interpolate/index.d.ts

@@ -0,0 +1 @@
+export declare function interpolate(ratio: number, bound1: number, bound2: number): number;

package/agnostic/numbers/interpolate/index.js

@@ -0,0 +1,6 @@
+import {
+  interpolate
+} from "../../../chunks/chunk-EW46EXFB.js";
+export {
+  interpolate
+};

package/agnostic/numbers/responsive-harmonics/index.d.ts

@@ -0,0 +1,10 @@
+export declare function getHarmonic(min: number, max: number, level: number, steps: number): number;
+type ScaleDescriptor = {
+    screenBounds: [number, number];
+    lowLevel: [number, number];
+    highLevel: [number, number];
+    steps: number;
+    clamp?: boolean;
+};
+export declare function createScale(descriptor: ScaleDescriptor): (level: number) => string | undefined;
+export {};

package/agnostic/numbers/responsive-harmonics/index.js

@@ -0,0 +1,9 @@
+import {
+  createScale,
+  getHarmonic
+} from "../../../chunks/chunk-UYTXXUU7.js";
+import "../../../chunks/chunk-32IRF4OP.js";
+export {
+  createScale,
+  getHarmonic
+};

package/agnostic/numbers/round/index.d.ts

@@ -0,0 +1 @@
+export declare function round(number: number, nbDecimals: number): number;

package/agnostic/numbers/round/index.js

@@ -0,0 +1,6 @@
+import {
+  round
+} from "../../../chunks/chunk-32IRF4OP.js";
+export {
+  round
+};

package/agnostic/objects/enums/index.d.ts

@@ -0,0 +1,4 @@
+import { isInEnum as isInEnumFunc } from './is-in-enum';
+export declare namespace Enums {
+    const isInEnum: typeof isInEnumFunc;
+}

package/agnostic/objects/enums/index.js

@@ -0,0 +1,7 @@
+import {
+  Enums
+} from "../../../chunks/chunk-WOAYU6LB.js";
+import "../../../chunks/chunk-E6MSDKON.js";
+export {
+  Enums
+};

package/agnostic/objects/enums/is-in-enum/index.d.ts

@@ -0,0 +1 @@
+export declare function isInEnum<E extends Record<string, string | number>>(enumObj: E, value: string | number): value is E[keyof E];

package/agnostic/objects/enums/is-in-enum/index.js

@@ -0,0 +1,6 @@
+import {
+  isInEnum
+} from "../../../../chunks/chunk-E6MSDKON.js";
+export {
+  isInEnum
+};

package/agnostic/objects/flatten-getters/index.d.ts

@@ -0,0 +1 @@
+export declare function flattenGetters(obj: unknown): Record<string, unknown>;

package/agnostic/objects/flatten-getters/index.js

@@ -0,0 +1,9 @@
+import {
+  flattenGetters
+} from "../../../chunks/chunk-PO3V3I57.js";
+import "../../../chunks/chunk-4QQBKBYH.js";
+import "../../../chunks/chunk-QXAJXTXV.js";
+import "../../../chunks/chunk-HC6ZOHCS.js";
+export {
+  flattenGetters
+};

package/agnostic/objects/index.d.ts

@@ -0,0 +1,12 @@
+import { Enums as EnumsNamespace } from './enums';
+import { flattenGetters as flattenGettersFunc } from './flatten-getters';
+import { isObject as isObjectFunc } from './is-object';
+import { isRecord as isRecordFunc } from './is-record';
+import { Validation as ValidationNamespace } from './validation';
+export declare namespace Objects {
+    export import Enums = EnumsNamespace;
+    const flattenGetters: typeof flattenGettersFunc;
+    const isObject: typeof isObjectFunc;
+    const isRecord: typeof isRecordFunc;
+    export import Validation = ValidationNamespace;
+}

package/agnostic/objects/index.js

@@ -0,0 +1,32 @@
+import {
+  flattenGetters
+} from "../../chunks/chunk-PO3V3I57.js";
+import {
+  isRecord
+} from "../../chunks/chunk-YDIBNEGA.js";
+import {
+  isObject
+} from "../../chunks/chunk-K37RALUX.js";
+import {
+  Validation
+} from "../../chunks/chunk-FPEW3A27.js";
+import {
+  Enums
+} from "../../chunks/chunk-WOAYU6LB.js";
+import "../../chunks/chunk-E6MSDKON.js";
+import "../../chunks/chunk-4QQBKBYH.js";
+import "../../chunks/chunk-QXAJXTXV.js";
+import "../../chunks/chunk-HC6ZOHCS.js";
+
+// src/agnostic/objects/index.ts
+var Objects;
+((Objects2) => {
+  Objects2.Enums = Enums;
+  Objects2.flattenGetters = flattenGetters;
+  Objects2.isObject = isObject;
+  Objects2.isRecord = isRecord;
+  Objects2.Validation = Validation;
+})(Objects || (Objects = {}));
+export {
+  Objects
+};

package/agnostic/objects/is-object/index.d.ts

@@ -0,0 +1 @@
+export declare function isObject(unk: unknown): unk is object;

package/agnostic/objects/is-object/index.js

@@ -0,0 +1,6 @@
+import {
+  isObject
+} from "../../../chunks/chunk-K37RALUX.js";
+export {
+  isObject
+};

package/agnostic/objects/is-record/index.d.ts

@@ -0,0 +1 @@
+export declare function isRecord(input: unknown): input is Record<string, unknown>;

package/agnostic/objects/is-record/index.js

@@ -0,0 +1,6 @@
+import {
+  isRecord
+} from "../../../chunks/chunk-YDIBNEGA.js";
+export {
+  isRecord
+};

package/agnostic/objects/record-format/index.d.ts

@@ -0,0 +1,11 @@
+export type FormatKey<Input extends {} = any> = keyof Input | string;
+export type InputValue<Input extends {}, Key extends FormatKey<Input>> = Input extends Record<Key, infer V> ? V : undefined;
+export type FormatterFunc<I, O> = (val: I) => O | Promise<O>;
+export type Format<Input extends {} = any> = {
+    [Key in FormatKey<Input>]: FormatterFunc<InputValue<Input, Key>, any>;
+};
+export type UnwrapPromise<PromiseOrNot> = PromiseOrNot extends Promise<infer Resolved> ? Resolved : PromiseOrNot;
+export type Formatted<F extends Format<{}>> = {
+    [Key in keyof F]: UnwrapPromise<ReturnType<F[Key]>>;
+};
+export default function recordFormat<I extends {}, F extends Format<I>>(input: I, format: F): Promise<Formatted<F>>;

package/agnostic/objects/record-format/index.js

@@ -0,0 +1,16 @@
+// src/agnostic/objects/record-format/index.ts
+async function recordFormat(input, format) {
+  const result = {};
+  for (const key in format) {
+    const formatter = format[key];
+    if (typeof formatter === "function") {
+      result[key] = await formatter(input[key]);
+    } else {
+      result[key] = formatter;
+    }
+  }
+  return result;
+}
+export {
+  recordFormat as default
+};

package/agnostic/objects/validation/index.d.ts

@@ -0,0 +1,3 @@
+export declare namespace Validation {
+    function fromPartial<T extends object>(obj: T, partial: Partial<T>): boolean;
+}

package/agnostic/objects/validation/index.js

@@ -0,0 +1,6 @@
+import {
+  Validation
+} from "../../../chunks/chunk-FPEW3A27.js";
+export {
+  Validation
+};

package/agnostic/optim/index.d.ts

@@ -0,0 +1,7 @@
+import { memoize as memoizeFunc } from './memoize';
+import { throttle as throttleFunc, debounce as debounceFunc } from './throttle-debounce';
+export declare namespace Optim {
+    const memoize: typeof memoizeFunc;
+    const throttle: typeof throttleFunc;
+    const debounce: typeof debounceFunc;
+}

package/agnostic/optim/index.js

@@ -0,0 +1,18 @@
+import {
+  debounce,
+  throttle
+} from "../../chunks/chunk-VZDUZTW6.js";
+import {
+  memoize
+} from "../../chunks/chunk-JWBDZPQG.js";
+
+// src/agnostic/optim/index.ts
+var Optim;
+((Optim2) => {
+  Optim2.memoize = memoize;
+  Optim2.throttle = throttle;
+  Optim2.debounce = debounce;
+})(Optim || (Optim = {}));
+export {
+  Optim
+};

package/agnostic/optim/memoize/index.d.ts

@@ -0,0 +1,3 @@
+type BasicFunc = (...args: any[]) => any;
+export declare function memoize<T extends BasicFunc = BasicFunc>(toMemoizeFunc: T): (...args: Parameters<T>) => any;
+export {};

package/agnostic/optim/memoize/index.js

@@ -0,0 +1,6 @@
+import {
+  memoize
+} from "../../../chunks/chunk-JWBDZPQG.js";
+export {
+  memoize
+};

package/agnostic/optim/throttle-debounce/index.d.ts

@@ -0,0 +1,30 @@
+type BasicFunction = (...args: any[]) => any;
+/**
+ * Returns a throttled version of the function passed as an argument
+ * @param toThrottleFunc - The function that has to be throttled
+ * @param delayMs - The throttle delay in ms
+ */
+export declare function throttle<T extends BasicFunction = BasicFunction>(toThrottleFunc: T, delayMs: number): {
+    throttled: (...args: any[]) => {
+        returnValue: ReturnType<T> | undefined;
+        lastExecutedOn: number;
+        delayMs: number;
+        isCached: boolean;
+    };
+    setDelay: (delayMs: number) => void;
+};
+/**
+ * Returns a debounced version of the function passed as an argument
+ * @param toDebounceFunc - The function that has to be debounced
+ * @param delayMs - The debounce delay in ms
+ */
+export declare function debounce<T extends BasicFunction = BasicFunction>(toDebounceFunc: T, delayMs: number): {
+    debounced: (...args: any[]) => {
+        returnValue: ReturnType<T> | undefined;
+        lastExecutedOn: number;
+        delayMs: number;
+        isCached: boolean;
+    };
+    setDelay: (delayMs: number) => void;
+};
+export {};

package/agnostic/optim/throttle-debounce/index.js

@@ -0,0 +1,8 @@
+import {
+  debounce,
+  throttle
+} from "../../../chunks/chunk-VZDUZTW6.js";
+export {
+  debounce,
+  throttle
+};

package/agnostic/optim/throttle-debounce/types.d.ts

@@ -0,0 +1,2 @@
+import { setTimeout } from 'node:timers';
+export type Timeout = ReturnType<typeof setTimeout>;

package/agnostic/regexps/index.d.ts

@@ -0,0 +1,23 @@
+export declare namespace Regexps {
+    function mergeFlags(...flagStrs: string[]): string;
+    function setFlags(regexp: RegExp, _flags: string): RegExp;
+    function fromStart(regexp: RegExp, _flags?: string): RegExp;
+    function toEnd(regexp: RegExp, _flags?: string): RegExp;
+    function fromStartToEnd(regexp: RegExp, _flags?: string): RegExp;
+    function stringStartsWith(string: string, _regexp: RegExp): boolean;
+    function stringStartsWith(string: string, _regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
+    function stringStartsWith(string: string, _regexp: RegExp, returnMatches: false): boolean;
+    function stringStartsWith(string: string, _regexp: RegExp, returnMatches: false, _flags: string): boolean;
+    function stringStartsWith(string: string, _regexp: RegExp, returnMatches: true, _flags: string): RegExpMatchArray | null;
+    function stringEndsWith(string: string, _regexp: RegExp): boolean;
+    function stringEndsWith(string: string, _regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
+    function stringEndsWith(string: string, _regexp: RegExp, returnMatches: false): boolean;
+    function stringEndsWith(string: string, _regexp: RegExp, returnMatches: false, _flags: string): boolean;
+    function stringEndsWith(string: string, _regexp: RegExp, returnMatches: true, _flags: string): RegExpMatchArray | null;
+    function stringIs(string: string, _regexp: RegExp): boolean;
+    function stringIs(string: string, _regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
+    function stringIs(string: string, _regexp: RegExp, returnMatches: false): boolean;
+    function stringIs(string: string, _regexp: RegExp, returnMatches: false, _flags: string): boolean;
+    function stringIs(string: string, _regexp: RegExp, returnMatches: true, _flags: string): RegExpMatchArray | null;
+    function fromStrings(strings: string[]): RegExp;
+}