@design-edito/tools 0.4.5 → 0.4.11

package/agnostic/errors/register/index.js

@@ -1,51 +1,47 @@
-// src/agnostic/errors/register/index.ts
-function makeSource(s) {
-  return s;
-}
-function from(source) {
-  function getMessage(code) {
-    const message = source[code]?.message;
-    if (message === void 0) throw new Error("Unknown code");
-    return message;
-  }
-  function getDetailsMaker(code) {
-    const maker = source[code]?.detailsMaker;
-    if (maker === void 0) throw new Error("Unknown code");
-    return maker;
-  }
-  function getDetails(code, ...params) {
-    const maker = getDetailsMaker(code);
-    const details = maker?.(...params);
-    return details;
-  }
-  function getErrorData(code, ...params) {
-    const message = getMessage(code);
-    const details = getDetails(code, ...params);
-    return { code, message, details };
-  }
-  class RegisteredError extends Error {
-    code;
-    details;
-    constructor(code, ...params) {
-      const data = getErrorData(code, ...params);
-      super(data.message);
-      this.code = data.code;
-      this.details = data.details;
+export function makeSource(s) { return s; }
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export function from(source) {
+    function getMessage(code) {
+        const message = source[code]?.message;
+        if (message === undefined)
+            throw new Error('Unknown code');
+        return message;
+    }
+    function getDetailsMaker(code) {
+        const maker = source[code]?.detailsMaker;
+        if (maker === undefined)
+            throw new Error('Unknown code');
+        return maker;
+    }
+    function getDetails(code, ...params) {
+        const maker = getDetailsMaker(code);
+        const details = maker?.(...params);
+        return details;
+    }
+    function getErrorData(code, ...params) {
+        const message = getMessage(code);
+        const details = getDetails(code, ...params);
+        return { code, message, details };
+    }
+    class RegisteredError extends Error {
+        code;
+        details;
+        constructor(code, ...params) {
+            const data = getErrorData(code, ...params);
+            super(data.message);
+            this.code = data.code;
+            this.details = data.details;
+        }
+    }
+    function getError(code, ...params) {
+        return new RegisteredError(code, ...params);
     }
-  }
-  function getError(code, ...params) {
-    return new RegisteredError(code, ...params);
-  }
-  return {
-    getMessage,
-    getDetailsMaker,
-    getDetails,
-    getErrorData,
-    getError,
-    source
-  };
+    return {
+        getMessage,
+        getDetailsMaker,
+        getDetails,
+        getErrorData,
+        getError,
+        source
+    };
 }
-export {
-  from,
-  makeSource
-};

package/agnostic/errors/unknown-to-string/index.js

@@ -1,11 +1,18 @@
-// src/agnostic/errors/unknown-to-string/index.ts
-function unknownToString(unk, encoding) {
-  if (unk instanceof Error) return unk.message;
-  if (unk instanceof Buffer) return unk.toString(encoding ?? "utf-8");
-  if (typeof unk === "string") return unk;
-  if (typeof unk === "object" && unk !== null) return JSON.stringify(unk);
-  return `${unk}`;
+/**
+ * Converts an unknown object into a string
+ *
+ * @param {unknown} unk - the unknown object to stringify
+ * @returns {string} The stringified object
+ */
+export function unknownToString(unk, encoding) {
+    if (unk instanceof Error)
+        return unk.message;
+    if (unk instanceof Buffer)
+        return unk.toString(encoding ?? 'utf-8');
+    if (typeof unk === 'string')
+        return unk;
+    if (typeof unk === 'object' && unk !== null)
+        return JSON.stringify(unk);
+    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+    return `${unk}`;
 }
-export {
-  unknownToString
-};

package/agnostic/errors/unknown-to-string/index.test.js

@@ -0,0 +1,35 @@
+import { describe, it, expect } from 'vitest';
+import { unknownToString } from './index.js';
+describe('unknownToString', () => {
+    it('returns error message for Error instances', () => {
+        const error = new Error('test error message');
+        expect(unknownToString(error)).toBe('test error message');
+    });
+    it('returns the string for string inputs', () => {
+        expect(unknownToString('test string')).toBe('test string');
+        expect(unknownToString('')).toBe('');
+    });
+    it('returns JSON stringified object for objects', () => {
+        expect(unknownToString({ a: 1, b: 'test' })).toBe('{"a":1,"b":"test"}');
+        expect(unknownToString({ nested: { value: 42 } })).toBe('{"nested":{"value":42}}');
+    });
+    it('returns JSON stringified array for arrays', () => {
+        expect(unknownToString([1, 2, 3])).toBe('[1,2,3]');
+        expect(unknownToString(['a', 'b', 'c'])).toBe('["a","b","c"]');
+    });
+    it('returns stringified number for numbers', () => {
+        expect(unknownToString(42)).toBe('42');
+        expect(unknownToString(0)).toBe('0');
+        expect(unknownToString(-123)).toBe('-123');
+    });
+    it('returns stringified boolean for booleans', () => {
+        expect(unknownToString(true)).toBe('true');
+        expect(unknownToString(false)).toBe('false');
+    });
+    it('returns stringified null for null', () => {
+        expect(unknownToString(null)).toBe('null');
+    });
+    it('returns stringified undefined for undefined', () => {
+        expect(unknownToString(undefined)).toBe('undefined');
+    });
+});

package/agnostic/html/get-node-ancestors/index.js

@@ -1,31 +1,31 @@
-// src/agnostic/misc/crossenv/window/index.ts
-function exists() {
-  return typeof globalThis !== "undefined" && "window" in globalThis;
-}
-var _window = exists() ? globalThis.window ?? null : null;
-function get() {
-  if (_window !== null) return _window;
-  const message = "window is undefined. Please call Window.setWindow(windowObj) before using Window.get.";
-  throw new Error(message);
-}
-
-// src/agnostic/html/get-node-ancestors/index.ts
-function getNodeAncestors(node, traverseShadowRoots) {
-  const returned = [];
-  let currentNode = node;
-  const { ShadowRoot } = get();
-  while (currentNode !== null) {
-    returned.push(currentNode);
-    const parentNode = currentNode.parentNode;
-    if (parentNode instanceof ShadowRoot) {
-      returned.push(parentNode);
-      currentNode = traverseShadowRoots === true ? parentNode.host : null;
-      continue;
+import * as Window from '../../misc/crossenv/window/index.js';
+/**
+ * Returns the list of ancestor nodes for a given DOM node, including the node
+ * itself, walking up through parent elements.
+ *
+ * By default, traversal stops at shadow root boundaries. When
+ * `traverseShadowRoots` is `true`, the traversal continues from a `ShadowRoot`
+ * to its host element.
+ *
+ * @param {Node} node - The starting DOM node.
+ * @param {boolean} [traverseShadowRoots] - Whether to traverse through shadow roots via their host elements.
+ * @returns {Node[]} An array of ancestor nodes, starting with the provided node.
+ */
+export function getNodeAncestors(node, traverseShadowRoots) {
+    const returned = [];
+    let currentNode = node;
+    const { ShadowRoot } = Window.get();
+    while (currentNode !== null) {
+        returned.push(currentNode);
+        const parentNode = currentNode.parentNode;
+        if (parentNode instanceof ShadowRoot) {
+            returned.push(parentNode);
+            currentNode = traverseShadowRoots === true
+                ? parentNode.host
+                : null;
+            continue;
+        }
+        currentNode = currentNode.parentElement;
     }
-    currentNode = currentNode.parentElement;
-  }
-  return returned;
+    return returned;
 }
-export {
-  getNodeAncestors
-};

package/agnostic/html/get-node-ancestors/index.test.js

@@ -0,0 +1,58 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { JSDOM } from 'jsdom';
+import { getNodeAncestors } from './index.js';
+import * as Window from '../../misc/crossenv/window/index.js';
+describe('getNodeAncestors', () => {
+    beforeEach(() => Window.set(new JSDOM('', { url: 'http://localhost/' }).window));
+    afterEach(() => Window.unset());
+    it('returns the node itself as first element', () => {
+        const { document } = Window.get();
+        const div = document.createElement('div');
+        const result = getNodeAncestors(div);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toBe(div);
+    });
+    it('returns all ancestors including the node', () => {
+        const { document } = Window.get();
+        const grandparent = document.createElement('div');
+        const parent = document.createElement('div');
+        const child = document.createElement('div');
+        grandparent.appendChild(parent);
+        parent.appendChild(child);
+        const result = getNodeAncestors(child);
+        expect(result).toHaveLength(3);
+        expect(result[0]).toBe(child);
+        expect(result[1]).toBe(parent);
+        expect(result[2]).toBe(grandparent);
+    });
+    it('stops at document.documentElement', () => {
+        const { document } = Window.get();
+        const div = document.createElement('div');
+        document.body.appendChild(div);
+        const result = getNodeAncestors(div);
+        expect(result.length).toBeGreaterThan(1);
+        expect(result.at(-1)).toBe(document.documentElement);
+    });
+    it('does not traverse shadow roots by default', () => {
+        const { document } = Window.get();
+        const host = document.createElement('div');
+        const shadowRoot = host.attachShadow({ mode: 'open' });
+        const shadowChild = document.createElement('span');
+        shadowRoot.appendChild(shadowChild);
+        const result = getNodeAncestors(shadowChild);
+        expect(result).toContain(shadowChild);
+        expect(result).toContain(shadowRoot);
+        expect(result).not.toContain(host);
+    });
+    it('traverses shadow roots when traverseShadowRoots is true', () => {
+        const { document } = Window.get();
+        const host = document.createElement('div');
+        const shadowRoot = host.attachShadow({ mode: 'open' });
+        const shadowChild = document.createElement('span');
+        shadowRoot.appendChild(shadowChild);
+        const result = getNodeAncestors(shadowChild, true);
+        expect(result).toContain(shadowChild);
+        expect(result).toContain(shadowRoot);
+        expect(result).toContain(host);
+    });
+});

package/agnostic/html/get-position-inside-parent/index.js

@@ -1,9 +1,14 @@
-// src/agnostic/html/get-position-inside-parent/index.ts
-function getPositionInsideParent(node) {
-  if (node.parentNode === null) return null;
-  const childNodes = Array.from(node.parentNode.childNodes);
-  return childNodes.indexOf(node);
+/**
+ * Returns the index position of a node within its parent’s `childNodes` list.
+ *
+ * @param {Node} node - The DOM node whose position is to be determined.
+ * @returns {number | null}
+ * - The zero-based index of the node within its parent’s `childNodes`.
+ * - `null` if the node has no parent.
+ */
+export function getPositionInsideParent(node) {
+    if (node.parentNode === null)
+        return null;
+    const childNodes = Array.from(node.parentNode.childNodes);
+    return childNodes.indexOf(node);
 }
-export {
-  getPositionInsideParent
-};

package/agnostic/html/get-position-inside-parent/index.test.js

@@ -0,0 +1,56 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { JSDOM } from 'jsdom';
+import * as Window from '../../misc/crossenv/window/index.js';
+import { getPositionInsideParent } from './index.js';
+describe('getPositionInsideParent', () => {
+    beforeEach(() => Window.set(new JSDOM().window));
+    afterEach(() => Window.unset());
+    it('returns 0 for first child', () => {
+        const { document } = Window.get();
+        const parent = document.createElement('div');
+        const firstChild = document.createElement('span');
+        parent.appendChild(firstChild);
+        expect(getPositionInsideParent(firstChild)).toBe(0);
+    });
+    it('returns correct index for middle child', () => {
+        const { document } = Window.get();
+        const parent = document.createElement('div');
+        const child1 = document.createElement('span');
+        const child2 = document.createElement('span');
+        const child3 = document.createElement('span');
+        parent.appendChild(child1);
+        parent.appendChild(child2);
+        parent.appendChild(child3);
+        expect(getPositionInsideParent(child2)).toBe(1);
+        expect(getPositionInsideParent(child3)).toBe(2);
+    });
+    it('returns null for node without parent', () => {
+        const { document } = Window.get();
+        const orphan = document.createElement('div');
+        expect(getPositionInsideParent(orphan)).toBe(null);
+    });
+    it('counts text nodes in position', () => {
+        const { document } = Window.get();
+        const parent = document.createElement('div');
+        const text1 = document.createTextNode('text1');
+        const element = document.createElement('span');
+        const text2 = document.createTextNode('text2');
+        parent.appendChild(text1);
+        parent.appendChild(element);
+        parent.appendChild(text2);
+        expect(getPositionInsideParent(element)).toBe(1);
+    });
+    it('returns correct position after node removal', () => {
+        const { document } = Window.get();
+        const parent = document.createElement('div');
+        const child1 = document.createElement('span');
+        const child2 = document.createElement('span');
+        const child3 = document.createElement('span');
+        parent.appendChild(child1);
+        parent.appendChild(child2);
+        parent.appendChild(child3);
+        parent.removeChild(child1);
+        expect(getPositionInsideParent(child2)).toBe(0);
+        expect(getPositionInsideParent(child3)).toBe(1);
+    });
+});