@design-edito/tools 0.2.39 → 0.2.41

package/agnostic/misc/logs/logger/index.js

@@ -1,7 +1,112 @@
-import {
-  Logger
-} from "../../../../chunks/chunk-RASMASS4.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/misc/logs/logger/index.ts
+var logsTimeOrigin = /* @__PURE__ */ new Date();
+var Log = class {
+  type;
+  data;
+  time;
+  stack;
+  constructor(type, data) {
+    this.type = type;
+    this.data = data;
+    this.time = /* @__PURE__ */ new Date();
+    this.stack = new Error().stack ?? "";
+  }
+  get displayTime() {
+    return this.time.toLocaleDateString("en-US", {
+      year: "numeric",
+      month: "short",
+      day: "numeric",
+      weekday: "short",
+      hour: "numeric",
+      minute: "numeric",
+      second: "numeric"
+    }) + `:${this.time.getMilliseconds()}`;
+  }
+  get elapsedTimeMs() {
+    return (this.time.getTime() - logsTimeOrigin.getTime()) / 1e3;
+  }
+  get displayStack() {
+    return this.stack.split("\n").map((line) => line.trim()).slice(4).join("\n");
+  }
+};
+var Logger = class {
+  _private_threads = /* @__PURE__ */ new Map();
+  constructor() {
+    this.dir = this.dir.bind(this);
+    this.error = this.error.bind(this);
+    this.group = this.group.bind(this);
+    this.groupEnd = this.groupEnd.bind(this);
+    this.log = this.log.bind(this);
+    this.table = this.table.bind(this);
+    this.warn = this.warn.bind(this);
+    this.setLog = this.setLog.bind(this);
+    this.print = this.print.bind(this);
+    this.printThreads = this.printThreads.bind(this);
+  }
+  // assert         (thread: string = '', ...args: ConsoleMethodsParams['assert'])         { this.setLog(thread, 'assert', args) }
+  // count          (thread: string = '', ...args: ConsoleMethodsParams['count'])          { this.setLog(thread, 'count', args) }
+  // countReset     (thread: string = '', ...args: ConsoleMethodsParams['countReset'])     { this.setLog(thread, 'countReset', args) }
+  // debug          (thread: string = '', ...args: ConsoleMethodsParams['debug'])          { this.setLog(thread, 'debug', args) }
+  dir(thread = "", ...args) {
+    this.setLog(thread, "dir", args);
+  }
+  // dirxml         (thread: string = '', ...args: ConsoleMethodsParams['dirxml'])         { this.setLog(thread, 'dirxml', args) }
+  error(thread = "", ...args) {
+    this.setLog(thread, "error", args);
+  }
+  group(thread = "", ...args) {
+    this.setLog(thread, "group", args);
+  }
+  // groupCollapsed (thread: string = '', ...args: ConsoleMethodsParams['groupCollapsed']) { this.setLog(thread, 'groupCollapsed', args) }
+  groupEnd(thread = "", ...args) {
+    this.setLog(thread, "groupEnd", args);
+  }
+  // info           (thread: string = '', ...args: ConsoleMethodsParams['info'])           { this.setLog(thread, 'info', args) }
+  log(thread = "", ...args) {
+    this.setLog(thread, "log", args);
+  }
+  table(thread = "", ...args) {
+    this.setLog(thread, "table", args);
+  }
+  // time           (thread: string = '', ...args: ConsoleMethodsParams['time'])           { this.setLog(thread, 'time', args) }
+  // timeEnd        (thread: string = '', ...args: ConsoleMethodsParams['timeEnd'])        { this.setLog(thread, 'timeEnd', args) }
+  // trace          (thread: string = '', ...args: ConsoleMethodsParams['trace'])          { this.setLog(thread, 'trace', args) }
+  warn(thread = "", ...args) {
+    this.setLog(thread, "warn", args);
+  }
+  setLog(threadName, type, data) {
+    const log = new Log(type, data);
+    const thread = this._private_threads.get(threadName) ?? [];
+    this._private_threads.set(threadName, [...thread, log]);
+    return this;
+  }
+  print(threadFilter, withStack) {
+    const allLogs = Array.from(this._private_threads.entries()).map(([threadName, logs]) => logs.map((log) => ({ threadName, log }))).flat().sort((eltA, eltB) => eltA.log.time.getTime() - eltB.log.time.getTime()).filter(({ threadName }) => {
+      if (threadFilter === void 0) return true;
+      return threadName === threadFilter;
+    });
+    allLogs.forEach(({ threadName, log }) => {
+      console.log(`%c${threadName}`, "font-weight: 800; color: white; background: black; padding: 4px;", `+${log.elapsedTimeMs}s \u2013`, log.displayTime);
+      if (withStack === true) console.log(`%c${log.displayStack}`, "color: grey; font-size: inherit;");
+      console[log.type](...log.data);
+      console.log("");
+    });
+  }
+  printThreads(withStack) {
+    Array.from(this._private_threads.entries()).forEach(([threadName, logs]) => {
+      console.group(`%c${threadName}`, "font-weight: 800; color: white; background: black; padding: 4px;");
+      logs.forEach((log) => {
+        console.log(`+${log.elapsedTimeMs}s \u2013`, log.displayTime);
+        if (withStack === true) console.log(`%c${log.displayStack}`, "color: grey; font-size: inherit;");
+        console[log.type](...log.data);
+        console.log("");
+      });
+      console.groupEnd();
+    });
+  }
+};
 export {
   Logger
 };

package/agnostic/misc/logs/make-text-block/index.js

@@ -1,7 +1,7 @@
 import {
   makeTextBlock
 } from "../../../../chunks/chunk-H4PP6AHP.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../../chunks/chunk-XCBH6NLF.js";
 export {
   makeTextBlock
 };

package/agnostic/misc/logs/styles/index.js

@@ -2,7 +2,7 @@ import {
   styles
 } from "../../../../chunks/chunk-L3OCRR3V.js";
 import "../../../../chunks/chunk-H4PP6AHP.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../../chunks/chunk-XCBH6NLF.js";
 export {
   styles
 };

package/agnostic/misc/lorem-ipsum/index.d.ts

@@ -1,5 +1,3 @@
-export declare namespace LoremIpsum {
-    const words: string[];
-    const generateSentence: (wordCount: number) => string;
-    const generateSentences: (sentencesCount: number, maxSentenceLength?: number, minSentenceLength?: number) => string[];
-}
+export declare const words: string[];
+export declare const generateSentence: (wordCount: number) => string;
+export declare const generateSentences: (sentencesCount: number, maxSentenceLength?: number, minSentenceLength?: number) => string[];

package/agnostic/misc/lorem-ipsum/index.js

@@ -1,26 +1,190 @@
 import {
-  LoremIpsum
-} from "../../../chunks/chunk-VLC7LRED.js";
-import "../../../chunks/chunk-S32K7POB.js";
-import "../../../chunks/chunk-D3ERTRDW.js";
-import "../../../chunks/chunk-75BICI4L.js";
-import "../../../chunks/chunk-OGBUSUE6.js";
-import "../../../chunks/chunk-Y5GGIBPI.js";
-import "../../../chunks/chunk-AQBJ6HNB.js";
-import "../../../chunks/chunk-TIER4TF4.js";
-import "../../../chunks/chunk-FR5H2OCV.js";
-import "../../../chunks/chunk-S2NMAH7K.js";
-import "../../../chunks/chunk-LV2VMOWR.js";
-import "../../../chunks/chunk-RLJOYG64.js";
-import "../../../chunks/chunk-WH6BPDAC.js";
-import "../../../chunks/chunk-QHLQVR3E.js";
-import "../../../chunks/chunk-FENXVJYO.js";
-import "../../../chunks/chunk-RLAZR3NL.js";
-import "../../../chunks/chunk-VJJIYJMY.js";
-import "../../../chunks/chunk-6RGDWX4A.js";
-import "../../../chunks/chunk-RCO57B6F.js";
-import "../../../chunks/chunk-YS6WMSWC.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+  randomInt
+} from "../../../chunks/chunk-D3ERTRDW.js";
+import {
+  randomPick
+} from "../../../chunks/chunk-K5UF634H.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/misc/lorem-ipsum/index.ts
+var words = [
+  "a",
+  "ac",
+  "accumsan",
+  "adipiscing",
+  "aenean",
+  "aliquam",
+  "aliquet",
+  "amet",
+  "ante",
+  "arcu",
+  "at",
+  "auctor",
+  "augue",
+  "bibendum",
+  "blandit",
+  "condimentum",
+  "consectetur",
+  "consequat",
+  "convallis",
+  "cras",
+  "curabitur",
+  "cursus",
+  "dapibus",
+  "diam",
+  "dictum",
+  "dictumst",
+  "dignissim",
+  "dolor",
+  "donec",
+  "dui",
+  "duis",
+  "efficitur",
+  "egestas",
+  "eget",
+  "eleifend",
+  "elementum",
+  "elit",
+  "enim",
+  "erat",
+  "eros",
+  "est",
+  "et",
+  "eu",
+  "euismod",
+  "ex",
+  "facilisis",
+  "faucibus",
+  "felis",
+  "feugiat",
+  "finibus",
+  "fringilla",
+  "fusce",
+  "gravida",
+  "habitasse",
+  "hac",
+  "hendrerit",
+  "iaculis",
+  "id",
+  "imperdiet",
+  "in",
+  "integer",
+  "interdum",
+  "ipsum",
+  "justo",
+  "lacinia",
+  "lacus",
+  "laoreet",
+  "lectus",
+  "leo",
+  "libero",
+  "ligula",
+  "lobortis",
+  "lorem",
+  "luctus",
+  "maecenas",
+  "magna",
+  "malesuada",
+  "massa",
+  "mattis",
+  "mauris",
+  "maximus",
+  "metus",
+  "mi",
+  "molestie",
+  "mollis",
+  "morbi",
+  "nam",
+  "nec",
+  "neque",
+  "nibh",
+  "nisi",
+  "nisl",
+  "non",
+  "nulla",
+  "nullam",
+  "nunc",
+  "odio",
+  "orci",
+  "ornare",
+  "pellentesque",
+  "pharetra",
+  "phasellus",
+  "placerat",
+  "platea",
+  "porta",
+  "porttitor",
+  "posuere",
+  "praesent",
+  "pulvinar",
+  "purus",
+  "quam",
+  "quis",
+  "quisque",
+  "risus",
+  "rutrum",
+  "sagittis",
+  "sapien",
+  "sed",
+  "sem",
+  "semper",
+  "sit",
+  "sodales",
+  "sollicitudin",
+  "suscipit",
+  "suspendisse",
+  "tellus",
+  "tempor",
+  "tempus",
+  "tincidunt",
+  "tortor",
+  "tristique",
+  "turpis",
+  "ultrices",
+  "ultricies",
+  "urna",
+  "ut",
+  "vehicula",
+  "vel",
+  "velit",
+  "venenatis",
+  "vestibulum",
+  "vitae",
+  "vivamus",
+  "viverra",
+  "volutpat",
+  "vulputate"
+];
+var generateSentence = (wordCount) => {
+  const resultArr = [];
+  let currentWordCound = wordCount;
+  for (let i = 0; i < currentWordCound; i++) {
+    const picked = randomPick(words);
+    if (typeof picked === "string") resultArr.push(picked);
+    else {
+      currentWordCound += 1;
+    }
+  }
+  const [firstWord, ...otherWords] = resultArr;
+  if (firstWord === void 0) return "";
+  const capFirstLetter = firstWord?.charAt(0).toUpperCase();
+  const restOfFirstWord = firstWord?.slice(1);
+  const sentence = [
+    `${capFirstLetter}${restOfFirstWord}`,
+    ...otherWords
+  ].join(" ");
+  return `${sentence}.`;
+};
+var generateSentences = (sentencesCount, maxSentenceLength = 12, minSentenceLength = 4) => {
+  const sentences = [];
+  for (let i = 0; i < sentencesCount; i++) {
+    const length = randomInt(maxSentenceLength, minSentenceLength) ?? 8;
+    sentences.push(generateSentence(length));
+  }
+  return sentences;
+};
 export {
-  LoremIpsum
+  generateSentence,
+  generateSentences,
+  words
 };

package/agnostic/misc/lorem-ipsum/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/agnostic/misc/normalize-extension/index.d.ts

@@ -1 +1,11 @@
+/**
+ * Normalizes a file extension to its canonical form, using an optional alias map.
+ *
+ * Converts the extension to lowercase, removes a leading dot if present,
+ * and applies alias mapping if defined.
+ *
+ * @param {string} extWithoutDot - File extension to normalize (may include or omit leading dot).
+ * @param {Record<string, string>} [aliasesWithoutDot=defaultAliases] - Optional mapping of aliases to canonical extensions.
+ * @returns {string} The normalized file extension, without leading dot.
+ */
 export declare function normalizeExtension(extWithoutDot: string, aliasesWithoutDot?: Record<string, string>): string;

package/agnostic/misc/normalize-extension/index.js

@@ -1,4 +1,4 @@
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 
 // src/agnostic/misc/normalize-extension/index.ts
 var defaultAliases = {

package/agnostic/misc/normalize-extension/index.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -1,15 +1,56 @@
-export declare namespace Outcome {
-    type Success<Payload extends any = any> = {
-        success: true;
-        payload: Payload;
-    };
-    type Failure<Error extends any = any> = {
-        success: false;
-        error: Error;
-    };
-    type Either<Payload extends any = any, Error extends any = any> = Success<Payload> | Failure<Error>;
-    function makeSuccess<Payload extends any>(payload: Payload): Success<Payload>;
-    function makeFailure<Error extends any>(error: Error): Failure<Error>;
-    function make<Payload extends any>(success: true, payload: Payload): Success<Payload>;
-    function make<Error extends any>(success: false, error: Error): Failure<Error>;
-}
+/**
+ * Represents a successful outcome.
+ *
+ * @template Payload - The type of the success payload.
+ * @property {true} success - Always `true`.
+ * @property {Payload} payload - The success value.
+ */
+export type Success<Payload extends any = any> = {
+    success: true;
+    payload: Payload;
+};
+/**
+ * Represents a failed outcome.
+ *
+ * @template Error - The type of the error.
+ * @property {false} success - Always `false`.
+ * @property {Error} error - The error value.
+ */
+export type Failure<Error extends any = any> = {
+    success: false;
+    error: Error;
+};
+/**
+ * Represents either a success or a failure outcome.
+ *
+ * @template Payload - Type of success payload.
+ * @template Error - Type of error.
+ */
+export type Either<Payload extends any = any, Error extends any = any> = Success<Payload> | Failure<Error>;
+/**
+ * Creates a success outcome with the given payload.
+ *
+ * @template Payload
+ * @param {Payload} payload - The success value.
+ * @returns {Success<Payload>} A success outcome object.
+ */
+export declare function makeSuccess<Payload extends any>(payload: Payload): Success<Payload>;
+/**
+ * Creates a failure outcome with the given error.
+ *
+ * @template Error
+ * @param {Error} error - The error value.
+ * @returns {Failure<Error>} A failure outcome object.
+ */
+export declare function makeFailure<Error extends any>(error: Error): Failure<Error>;
+/**
+ * Creates either a success or failure outcome based on a boolean flag.
+ *
+ * @template Payload
+ * @template Error
+ * @param {boolean} success - `true` to create a success, `false` to create a failure.
+ * @param {Payload | Error} payloadOrError - The payload if success, or the error if failure.
+ * @returns {Either<Payload, Error>} The resulting outcome.
+ */
+export declare function make<Payload extends any>(success: true, payload: Payload): Success<Payload>;
+export declare function make<Error extends any>(success: false, error: Error): Failure<Error>;

package/agnostic/misc/outcome/index.js

@@ -1,7 +1,11 @@
 import {
-  Outcome
-} from "../../../chunks/chunk-JMU5PDBD.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+  make,
+  makeFailure,
+  makeSuccess
+} from "../../../chunks/chunk-QEKI6WGQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
-  Outcome
+  make,
+  makeFailure,
+  makeSuccess
 };

package/agnostic/misc/outcome/index.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -1 +1,8 @@
+/**
+ * Computes the modulo of a number, always returning a non-negative result.
+ *
+ * @param {number} nbr - The number to modulo.
+ * @param {number} modulo - The modulus.
+ * @returns {number} The non-negative remainder of `nbr` modulo `modulo`.
+ */
 export declare function absoluteModulo(nbr: number, modulo: number): number;

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

@@ -1,7 +1,7 @@
 import {
   absoluteModulo
 } from "../../../chunks/chunk-DNIOWD7K.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   absoluteModulo
 };

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

@@ -0,0 +1 @@
+export {};

package/agnostic/numbers/approximate-rational/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Approximates a decimal number as a rational number using a simple iterative approach.
+ *
+ * Uses a naive algorithm that increments the numerator or denominator each round
+ * to find the closest approximation. Stops early if an exact match is found.
+ *
+ * @param {number} target - The decimal number to approximate.
+ * @param {number} maxRounds - The maximum number of iterations to perform.
+ * @returns {[number, number]} A tuple `[numerator, denominator]` representing the rational approximation.
+ */
+export declare function approximateRationalDumb(target: number, maxRounds: number): [number, number];
+/**
+ * Approximates a decimal number as a rational number (fraction) using continued fractions.
+ *
+ * Uses the continued fractions algorithm to find the best rational approximation
+ * of a decimal number within the specified maximum denominator limit.
+ *
+ * @param {number} target - The decimal number to approximate.
+ * @param {number} [maxDenominator=1000] - The maximum allowed denominator value.
+ * @returns {[number, number]} A tuple `[numerator, denominator]` representing the rational approximation.
+ */
+export declare function approximateRational(target: number, maxDenominator?: number): [number, number];

package/agnostic/numbers/approximate-rational/index.js

@@ -0,0 +1,72 @@
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/numbers/approximate-rational/index.ts
+function approximateRationalDumb(target, maxRounds) {
+  let numerator = 0;
+  let denominator = 1;
+  let currentRound = 0;
+  let foundExact = false;
+  const closestFound = {
+    numerator,
+    denominator,
+    found: 0
+  };
+  const positiveTarget = Math.abs(target);
+  while (currentRound < maxRounds && !foundExact) {
+    currentRound++;
+    const roundResult = numerator / denominator;
+    if (roundResult === positiveTarget) {
+      closestFound.numerator = numerator;
+      closestFound.denominator = denominator;
+      closestFound.found = roundResult;
+      foundExact = true;
+    } else {
+      const roundAbsDiff = Math.abs(roundResult - positiveTarget);
+      const closestAbsDiff = Math.abs(closestFound.found - positiveTarget);
+      if (roundAbsDiff < closestAbsDiff) {
+        closestFound.numerator = numerator;
+        closestFound.denominator = denominator;
+        closestFound.found = roundResult;
+      }
+      if (roundResult < positiveTarget) {
+        numerator++;
+      } else {
+        denominator++;
+      }
+    }
+  }
+  if (target < 0) {
+    closestFound.numerator = closestFound.numerator * -1;
+  }
+  return [
+    closestFound.numerator,
+    closestFound.denominator
+  ];
+}
+function approximateRational(target, maxDenominator = 1e3) {
+  const sign = target < 0 ? -1 : 1;
+  const absTarget = Math.abs(target);
+  let h1 = 1, h2 = 0;
+  let k1 = 0, k2 = 1;
+  let b = absTarget;
+  do {
+    const a = Math.floor(b);
+    let temp = h1;
+    h1 = a * h1 + h2;
+    h2 = temp;
+    temp = k1;
+    k1 = a * k1 + k2;
+    k2 = temp;
+    if (k1 > maxDenominator) {
+      k1 = k2;
+      h1 = h2;
+      break;
+    }
+    b = 1 / (b - a);
+  } while (Math.abs(absTarget - h1 / k1) > 1e-10 && Number.isFinite(b));
+  return [sign * h1, k1];
+}
+export {
+  approximateRational,
+  approximateRationalDumb
+};

package/agnostic/numbers/approximate-rational/index.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -1 +1,9 @@
+/**
+ * Restricts a number to lie within a specified range.
+ *
+ * @param {number} num - The number to clamp.
+ * @param {number} bound1 - One end of the range.
+ * @param {number} bound2 - The other end of the range.
+ * @returns {number} The number constrained between the minimum and maximum of the two bounds.
+ */
 export declare function clamp(num: number, bound1: number, bound2: number): number;

package/agnostic/numbers/clamp/index.js

@@ -1,7 +1,7 @@
 import {
   clamp
 } from "../../../chunks/chunk-OSAXBA7G.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   clamp
 };

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

@@ -0,0 +1 @@
+export {};

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

@@ -1,2 +1,21 @@
+/**
+ * Performs linear interpolation between two bounds based on a ratio.
+ *
+ * @param {number} ratio - The interpolation factor, typically between 0 and 1.
+ * @param {number} bound1 - The start value.
+ * @param {number} bound2 - The end value.
+ * @returns {number} The interpolated value between `bound1` and `bound2`.
+ */
 export declare function interpolate(ratio: number, bound1: number, bound2: number): number;
-export declare function exterpolate(value: number, bound1: number, bound2?: number): number;
+/**
+ * Performs inverse linear interpolation (also called "unlerp") of a value relative to one or two bounds.
+ *
+ * If only `bound1` is provided, returns the ratio of `value / bound1`.
+ * If both bounds are provided, returns the normalized position of `value` between `bound1` and `bound2`.
+ *
+ * @param {number} value - The value to normalize.
+ * @param {number} bound1 - The lower bound (or single reference value if `bound2` is omitted).
+ * @param {number} [bound2] - The upper bound (optional).
+ * @returns {number} A ratio representing the relative position of `value`.
+ */
+export declare function unlerp(value: number, bound1: number, bound2?: number): number;