@design-edito/tools 0.4.4 → 0.4.6

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

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { isConstructorFunction } from './index.js';
+describe('isConstructorFunction', () => {
+    it('returns true for class declarations', () => {
+        // eslint-disable-next-line @typescript-eslint/no-extraneous-class
+        class MyClass {
+        }
+        expect(isConstructorFunction(MyClass)).toBe(true);
+    });
+    it('returns true for class expressions', () => {
+        // eslint-disable-next-line @typescript-eslint/no-extraneous-class
+        const MyClass = class {
+        };
+        expect(isConstructorFunction(MyClass)).toBe(true);
+    });
+    it('returns true for regular functions', () => {
+        function regularFunction() { }
+        expect(isConstructorFunction(regularFunction)).toBe(true);
+    });
+    it('returns false for arrow functions', () => {
+        const arrowFunction = () => { };
+        expect(isConstructorFunction(arrowFunction)).toBe(false);
+    });
+    it('returns false for non-functions', () => {
+        expect(isConstructorFunction({})).toBe(false);
+        expect(isConstructorFunction(null)).toBe(false);
+        expect(isConstructorFunction(42)).toBe(false);
+        expect(isConstructorFunction('string')).toBe(false);
+        expect(isConstructorFunction(new Date())).toBe(false);
+    });
+    it('returns true for built-in constructors', () => {
+        expect(isConstructorFunction(Array)).toBe(true);
+        expect(isConstructorFunction(Object)).toBe(true);
+        expect(isConstructorFunction(Date)).toBe(true);
+    });
+});

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

@@ -1,11 +1,26 @@
-import {
-  isNotNullish,
-  isNullish,
-  nullishValues
-} from "../../../chunks/chunk-HC6ZOHCS.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  isNotNullish,
-  isNullish,
-  nullishValues
-};
+/**
+ * Array of values considered "nullish".
+ *
+ * Contains `null` and `undefined`.
+ */
+export const nullishValues = [null, undefined];
+/**
+ * Checks whether a value is nullish (`null` or `undefined`).
+ *
+ * @template T
+ * @param {T | Nullish} val - The value to check.
+ * @returns {val is Nullish} `true` if the value is nullish, otherwise `false`.
+ */
+export function isNullish(val) {
+    return nullishValues.includes(val);
+}
+/**
+ * Checks whether a value is not nullish (`null` or `undefined`).
+ *
+ * @template T
+ * @param {T} val - The value to check.
+ * @returns {val is Exclude<T, Nullish>} `true` if the value is not nullish, otherwise `false`.
+ */
+export function isNotNullish(val) {
+    return !isNullish(val);
+}

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

@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'vitest';
+import { isNullish, isNotNullish } from './index.js';
+describe('isNullish', () => {
+    it('returns true for null', () => {
+        expect(isNullish(null)).toBe(true);
+    });
+    it('returns true for undefined', () => {
+        expect(isNullish(undefined)).toBe(true);
+    });
+    it('returns false for other falsy values', () => {
+        expect(isNullish(false)).toBe(false);
+        expect(isNullish(0)).toBe(false);
+        expect(isNullish('')).toBe(false);
+        expect(isNullish(NaN)).toBe(false);
+    });
+    it('returns false for truthy values', () => {
+        expect(isNullish(true)).toBe(false);
+        expect(isNullish(1)).toBe(false);
+        expect(isNullish('test')).toBe(false);
+        expect(isNullish({})).toBe(false);
+        expect(isNullish([])).toBe(false);
+    });
+});
+describe('isNotNullish', () => {
+    it('returns false for null', () => {
+        expect(isNotNullish(null)).toBe(false);
+    });
+    it('returns false for undefined', () => {
+        expect(isNotNullish(undefined)).toBe(false);
+    });
+    it('returns true for other falsy values', () => {
+        expect(isNotNullish(false)).toBe(true);
+        expect(isNotNullish(0)).toBe(true);
+        expect(isNotNullish('')).toBe(true);
+        expect(isNotNullish(NaN)).toBe(true);
+    });
+    it('returns true for truthy values', () => {
+        expect(isNotNullish(true)).toBe(true);
+        expect(isNotNullish(1)).toBe(true);
+        expect(isNotNullish('test')).toBe(true);
+        expect(isNotNullish({})).toBe(true);
+        expect(isNotNullish([])).toBe(true);
+    });
+});

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

@@ -1,142 +1,115 @@
-import "../../../../chunks/chunk-WSFCRVEQ.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.assert = this.assert.bind(this);
-    this.count = this.count.bind(this);
-    this.countReset = this.countReset.bind(this);
-    this.debug = this.debug.bind(this);
-    this.dir = this.dir.bind(this);
-    this.dirxml = this.dirxml.bind(this);
-    this.error = this.error.bind(this);
-    this.group = this.group.bind(this);
-    this.groupCollapsed = this.groupCollapsed.bind(this);
-    this.groupEnd = this.groupEnd.bind(this);
-    this.info = this.info.bind(this);
-    this.log = this.log.bind(this);
-    this.table = this.table.bind(this);
-    this.time = this.time.bind(this);
-    this.timeEnd = this.timeEnd.bind(this);
-    this.trace = this.trace.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 = "", ...args) {
-    this.setLog(thread, "assert", args);
-  }
-  count(thread = "", ...args) {
-    this.setLog(thread, "count", args);
-  }
-  countReset(thread = "", ...args) {
-    this.setLog(thread, "countReset", args);
-  }
-  debug(thread = "", ...args) {
-    this.setLog(thread, "debug", args);
-  }
-  dir(thread = "", ...args) {
-    this.setLog(thread, "dir", args);
-  }
-  dirxml(thread = "", ...args) {
-    this.setLog(thread, "dirxml", args);
-  }
-  error(thread = "", ...args) {
-    this.setLog(thread, "error", args);
-  }
-  group(thread = "", ...args) {
-    this.setLog(thread, "group", args);
-  }
-  groupCollapsed(thread = "", ...args) {
-    this.setLog(thread, "groupCollapsed", args);
-  }
-  groupEnd(thread = "", ...args) {
-    this.setLog(thread, "groupEnd", args);
-  }
-  info(thread = "", ...args) {
-    this.setLog(thread, "info", args);
-  }
-  log(thread = "", ...args) {
-    this.setLog(thread, "log", args);
-  }
-  table(thread = "", ...args) {
-    this.setLog(thread, "table", args);
-  }
-  time(thread = "", ...args) {
-    this.setLog(thread, "time", args);
-  }
-  timeEnd(thread = "", ...args) {
-    this.setLog(thread, "timeEnd", args);
-  }
-  trace(thread = "", ...args) {
-    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
-};
+// [WIP] not sure about this
+const logsTimeOrigin = new Date();
+class Log {
+    type;
+    data;
+    time;
+    stack;
+    constructor(type, data) {
+        this.type = type;
+        this.data = data;
+        this.time = 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()) / 1000;
+    }
+    get displayStack() {
+        return this.stack
+            .split('\n')
+            .map(line => line.trim())
+            .slice(4)
+            .join('\n');
+    }
+}
+export class Logger {
+    _private_threads = new Map();
+    constructor() {
+        this.assert = this.assert.bind(this);
+        this.count = this.count.bind(this);
+        this.countReset = this.countReset.bind(this);
+        this.debug = this.debug.bind(this);
+        this.dir = this.dir.bind(this);
+        this.dirxml = this.dirxml.bind(this);
+        this.error = this.error.bind(this);
+        this.group = this.group.bind(this);
+        this.groupCollapsed = this.groupCollapsed.bind(this);
+        this.groupEnd = this.groupEnd.bind(this);
+        this.info = this.info.bind(this);
+        this.log = this.log.bind(this);
+        this.table = this.table.bind(this);
+        this.time = this.time.bind(this);
+        this.timeEnd = this.timeEnd.bind(this);
+        this.trace = this.trace.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 = '', ...args) { this.setLog(thread, 'assert', args); }
+    count(thread = '', ...args) { this.setLog(thread, 'count', args); }
+    countReset(thread = '', ...args) { this.setLog(thread, 'countReset', args); }
+    debug(thread = '', ...args) { this.setLog(thread, 'debug', args); }
+    dir(thread = '', ...args) { this.setLog(thread, 'dir', args); }
+    dirxml(thread = '', ...args) { this.setLog(thread, 'dirxml', args); }
+    error(thread = '', ...args) { this.setLog(thread, 'error', args); }
+    group(thread = '', ...args) { this.setLog(thread, 'group', args); }
+    groupCollapsed(thread = '', ...args) { this.setLog(thread, 'groupCollapsed', args); }
+    groupEnd(thread = '', ...args) { this.setLog(thread, 'groupEnd', args); }
+    info(thread = '', ...args) { this.setLog(thread, 'info', args); }
+    log(thread = '', ...args) { this.setLog(thread, 'log', args); }
+    table(thread = '', ...args) { this.setLog(thread, 'table', args); }
+    time(thread = '', ...args) { this.setLog(thread, 'time', args); }
+    timeEnd(thread = '', ...args) { this.setLog(thread, 'timeEnd', args); }
+    trace(thread = '', ...args) { 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 === undefined)
+                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 –`, 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 –`, log.displayTime);
+                if (withStack === true)
+                    console.log(`%c${log.displayStack}`, 'color: grey; font-size: inherit;');
+                console[log.type](...log.data);
+                console.log('');
+            });
+            console.groupEnd();
+        });
+    }
+}

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

@@ -1,7 +1,14 @@
-import {
-  makeTextBlock
-} from "../../../../chunks/chunk-H4PP6AHP.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  makeTextBlock
-};
+export 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');
+}

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

@@ -1,8 +1,31 @@
-import {
-  styles
-} from "../../../../chunks/chunk-JZ6GM444.js";
-import "../../../../chunks/chunk-H4PP6AHP.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  styles
+import { makeTextBlock } from '../make-text-block/index.js';
+const ansi = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    italic: '\x1b[3m',
+    underline: '\x1b[4m',
+    fg: {
+        red: '\x1b[31m',
+        green: '\x1b[32m',
+        yellow: '\x1b[33m',
+        blue: '\x1b[34m',
+        gray: '\x1b[90m',
+        whiteBright: '\x1b[97m'
+    },
+    bg: {
+        red: '\x1b[41m'
+    }
+};
+const wrap = (...ansiCodes) => (text) => `${ansiCodes.join('')}${text}${ansi.reset}`;
+export const styles = {
+    regular: (text) => text,
+    light: wrap(ansi.fg.gray),
+    danger: (text) => wrap(ansi.bold, ansi.bg.red, ansi.fg.whiteBright)(makeTextBlock(`/!\\\n\n${text}\n`, 2, 6)),
+    important: wrap(ansi.bold),
+    title: (text) => `# ${wrap(ansi.bold, ansi.underline)(`${text}\n`)}`,
+    info: wrap(ansi.fg.blue),
+    success: wrap(ansi.fg.green),
+    error: wrap(ansi.fg.red),
+    warning: wrap(ansi.fg.yellow),
+    italic: wrap(ansi.italic)
 };