@design-edito/tools 0.1.27 → 0.1.29

package/chunks/chunk-BEJSITDG.js

@@ -0,0 +1,31 @@
+import {
+  Cast,
+  Transformers,
+  Tree,
+  Utils
+} from "./chunk-B2O7PFSF.js";
+import {
+  Types
+} from "./chunk-5GI5G45R.js";
+import {
+  Serialize
+} from "./chunk-DRNK3RLE.js";
+import {
+  Crossenv
+} from "./chunk-3LVR6KZH.js";
+
+// src/agnostic/html/hyper-json/index.ts
+var HyperJson;
+((HyperJson2) => {
+  HyperJson2.Cast = Cast;
+  HyperJson2.Crossenv = Crossenv;
+  HyperJson2.Serialize = Serialize;
+  HyperJson2.Transformers = Transformers;
+  HyperJson2.Tree = Tree;
+  HyperJson2.Types = Types;
+  HyperJson2.Utils = Utils;
+})(HyperJson || (HyperJson = {}));
+
+export {
+  HyperJson
+};

package/chunks/chunk-D3ERTRDW.js

@@ -0,0 +1,17 @@
+// src/agnostic/random/random/index.ts
+function random(bound1 = 1, bound2) {
+  const min = bound2 === void 0 ? 0 : bound1;
+  const max = bound2 === void 0 ? bound1 : bound2;
+  if (min === max || min > max) return void 0;
+  const range = max - min;
+  return Math.random() * range + min;
+}
+function randomInt(...args) {
+  const rand = random(...args);
+  return rand !== void 0 ? Math.floor(rand) : void 0;
+}
+
+export {
+  random,
+  randomInt
+};

package/chunks/chunk-H4PP6AHP.js

@@ -0,0 +1,15 @@
+// src/agnostic/misc/logs/make-text-block/index.ts
+function makeTextBlock(text, vPadding = 1, hPadding = vPadding) {
+  const lines = text.split("\n");
+  const longestLine = Math.max(...lines.map((line) => line.length));
+  const textBlockArr = new Array(lines.length + 2 * vPadding).fill(null).map(() => new Array(longestLine + hPadding * 2).fill(" "));
+  lines.forEach((line, linePos) => {
+    const chars = line.split("");
+    textBlockArr[linePos + vPadding]?.splice(hPadding, chars.length, ...chars);
+  });
+  return textBlockArr.map((lineArr) => lineArr.join("")).join("\n");
+}
+
+export {
+  makeTextBlock
+};

package/chunks/chunk-JWKI6G6E.js

@@ -0,0 +1,102 @@
+// 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.log = this.log.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: string = '', ...args: ConsoleMethodsParams['group'])          { this.setLog(thread, 'group', args) }
+  // groupCollapsed (thread: string = '', ...args: ConsoleMethodsParams['groupCollapsed']) { this.setLog(thread, 'groupCollapsed', args) }
+  // groupEnd       (thread: string = '', ...args: ConsoleMethodsParams['groupEnd'])       { 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: string = '', ...args: ConsoleMethodsParams['table'])          { 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/chunks/chunk-L3OCRR3V.js

@@ -0,0 +1,25 @@
+import {
+  makeTextBlock
+} from "./chunk-H4PP6AHP.js";
+
+// src/agnostic/misc/logs/styles/index.ts
+import chalk from "chalk";
+var styles = {
+  regular: (text) => text,
+  light: (text) => chalk.grey(text),
+  danger: (text) => chalk.bold.bgRed.whiteBright(makeTextBlock(`/!\\
+
+${text}
+`, 2, 6)),
+  important: (text) => chalk.bold(text),
+  title: (text) => `# ${chalk.bold.underline(`${text}
+`)}`,
+  info: (text) => chalk.blueBright(text),
+  success: (text) => chalk.greenBright(text),
+  error: (text) => chalk.red(text),
+  warning: (text) => chalk.yellow(text)
+};
+
+export {
+  styles
+};