@design-edito/tools 0.4.4 → 0.4.6

package/agnostic/css/scale/index.js

@@ -1,42 +1,42 @@
-import {
-  getGeometricStep
-} from "../../../chunks/chunk-ASXK7XCC.js";
-import {
-  round
-} from "../../../chunks/chunk-QHEWBOQI.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
-
-// src/agnostic/css/scale/index.ts
-function createScale(descriptor) {
-  const {
-    screenBounds: [loBound, hiBound],
-    lowLevel: [loLevelMin, loLevelMax],
-    highLevel: [hiLevelMin, hiLevelMax],
-    steps,
-    clamp
-  } = descriptor;
-  return function scale(level) {
-    if (steps < 2) return;
-    const loBoundVal = getGeometricStep(loLevelMin, hiLevelMin, level - 1, steps - 1);
-    const hiBoundVal = getGeometricStep(loLevelMax, hiLevelMax, level - 1, steps - 1);
-    if (loBoundVal === void 0) return;
-    if (hiBoundVal === void 0) return;
-    const affine = getAffineFunction(loBound, loBoundVal, hiBound, hiBoundVal);
-    const cssFormula = getCssValueFromAffine(affine);
-    return clamp === true ? `clamp(${round(loBoundVal, 2)}px, ${cssFormula}, ${round(hiBoundVal, 2)}px)` : cssFormula;
-  };
+import { round } from '../../numbers/round/index.js';
+import { getGeometricStep } from '../../numbers/geometric-progressions/index.js';
+/**
+ * Creates a scale function that maps a level to a CSS size value using harmonic interpolation.
+ *
+ * @param {ScaleDescriptor} descriptor - The scale configuration.
+ * @param {[number, number]} descriptor.screenBounds - The lower and upper bounds for screen width in pixels.
+ * @param {[number, number]} descriptor.lowLevel - Minimum and maximum values for the low level range.
+ * @param {[number, number]} descriptor.highLevel - Minimum and maximum values for the high level range.
+ * @param {number} descriptor.steps - Number of discrete steps in the scale.
+ * @param {boolean} [descriptor.clamp] - Whether to wrap the resulting CSS value in a `clamp()` function.
+ * @returns {(level: number) => string | undefined} A function mapping a level to a CSS value string.
+ */
+export function createScale(descriptor) {
+    const { screenBounds: [loBound, hiBound], lowLevel: [loLevelMin, loLevelMax], highLevel: [hiLevelMin, hiLevelMax], steps, clamp } = descriptor;
+    return function scale(level) {
+        if (steps < 2)
+            return;
+        const loBoundVal = getGeometricStep(loLevelMin, hiLevelMin, level - 1, steps - 1);
+        const hiBoundVal = getGeometricStep(loLevelMax, hiLevelMax, level - 1, steps - 1);
+        if (loBoundVal === undefined)
+            return;
+        if (hiBoundVal === undefined)
+            return;
+        const affine = getAffineFunction(loBound, loBoundVal, hiBound, hiBoundVal);
+        const cssFormula = getCssValueFromAffine(affine);
+        return clamp === true
+            ? `clamp(${round(loBoundVal, 2)}px, ${cssFormula}, ${round(hiBoundVal, 2)}px)`
+            : cssFormula;
+    };
 }
 function getAffineFunction(x1, y1, x2, y2) {
-  const slope = (y2 - y1) / (x2 - x1);
-  const yIntercept = y1 - x1 * slope;
-  return { slope, yIntercept };
+    const slope = (y2 - y1) / (x2 - x1);
+    const yIntercept = y1 - (x1 * slope);
+    return { slope, yIntercept };
 }
 function getCssValueFromAffine(affine) {
-  const { slope, yIntercept } = affine;
-  const roundedSlope = round(100 * slope, 3);
-  const roundedIntercept = round(yIntercept, 2);
-  return `calc(${roundedSlope}vw + ${roundedIntercept}px)`;
+    const { slope, yIntercept } = affine;
+    const roundedSlope = round(100 * slope, 3);
+    const roundedIntercept = round(yIntercept, 2);
+    return `calc(${roundedSlope}vw + ${roundedIntercept}px)`;
 }
-export {
-  createScale
-};

package/agnostic/css/scale/index.test.js

@@ -0,0 +1,71 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createScale } from './index.js';
+import * as geo from '../../numbers/geometric-progressions/index.js';
+describe('createScale', () => {
+    it('returns a function', () => {
+        const descriptor = {
+            screenBounds: [320, 1280],
+            lowLevel: [10, 20],
+            highLevel: [30, 60],
+            steps: 5
+        };
+        const scaleFn = createScale(descriptor);
+        expect(typeof scaleFn).toBe('function');
+    });
+    it('produces CSS calc() formula for intermediate levels', () => {
+        const descriptor = {
+            screenBounds: [320, 1280],
+            lowLevel: [10, 20],
+            highLevel: [30, 60],
+            steps: 5
+        };
+        const scaleFn = createScale(descriptor);
+        const cssValue = scaleFn(3);
+        expect(cssValue).toMatch(/^calc\([\d.]+vw \+ [\d.]+px\)$/);
+    });
+    it('wraps result in clamp() when clamp is true', () => {
+        const descriptor = {
+            screenBounds: [320, 1280],
+            lowLevel: [10, 20],
+            highLevel: [30, 60],
+            steps: 5,
+            clamp: true
+        };
+        const scaleFn = createScale(descriptor);
+        const cssValue = scaleFn(3);
+        expect(cssValue).toMatch(/^clamp\([\d.]+px, calc\([\d.]+vw \+ [\d.]+px\), [\d.]+px\)$/);
+    });
+    it('returns undefined if steps < 2', () => {
+        const descriptor = {
+            screenBounds: [320, 1280],
+            lowLevel: [10, 20],
+            highLevel: [30, 60],
+            steps: 1
+        };
+        const scaleFn = createScale(descriptor);
+        expect(scaleFn(1)).toBeUndefined();
+    });
+    it('handles descending low/high levels', () => {
+        const descriptor = {
+            screenBounds: [320, 1280],
+            lowLevel: [20, 10],
+            highLevel: [60, 30],
+            steps: 5
+        };
+        const scaleFn = createScale(descriptor);
+        const cssValue = scaleFn(3);
+        expect(cssValue).toMatch(/^calc\(-?[\d.]+vw \+ -?[\d.]+px\)$/);
+    });
+    it('propagates NaN from getGeometricStep', () => {
+        vi.spyOn(geo, 'getGeometricStep').mockReturnValueOnce(NaN);
+        const descriptor = {
+            screenBounds: [320, 1280],
+            lowLevel: [10, 20],
+            highLevel: [30, 60],
+            steps: 5
+        };
+        const scaleFn = createScale(descriptor);
+        const result = scaleFn(2);
+        expect(result).toBe('calc(NaNvw + NaNpx)');
+    });
+});

package/agnostic/css/styles-set/index.js

@@ -1,173 +1,155 @@
-import {
-  randomHash
-} from "../../../chunks/chunk-75BICI4L.js";
-import "../../../chunks/chunk-OGBUSUE6.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
-
-// src/agnostic/css/styles-set/index.tsx
-import { Component } from "react";
-import {
-  createRoot as reactCreateRoot
-} from "react-dom/client";
-import { Fragment, jsx } from "react/jsx-runtime";
-var StylesSet = class _StylesSet {
-  static defaultPrivateIDAttribute = "data-styleset-private-id";
-  static defaultPublicIDAttribute = "data-styleset-public-id";
-  tagsPrivateIDAttribute = _StylesSet.defaultPrivateIDAttribute;
-  tagsPublicIDAttribute = _StylesSet.defaultPublicIDAttribute;
-  _items = /* @__PURE__ */ new Map();
-  get items() {
-    const sortedItemsArray = Array.from(this._items).map(([privateId, item]) => {
-      const targetPosition = this.getTargetPosition(privateId) ?? 0;
-      return { targetPosition, privateId, item };
-    }).sort((a, b) => a.targetPosition - b.targetPosition).map(({ item, privateId }) => [privateId, item]);
-    const sortedItemsMap = new Map(sortedItemsArray);
-    return sortedItemsMap;
-  }
-  getTargetPosition(privateId) {
-    const orderedStyles = Array.from(this._items).map(([privateId2, data]) => ({ privateId: privateId2, data })).sort((a, b) => {
-      const aPos = a.data.position ?? 0;
-      const bPos = b.data.position ?? 0;
-      return aPos - bPos;
-    });
-    const foundIndex = orderedStyles.findIndex((item) => item.privateId === privateId);
-    return foundIndex === -1 ? null : foundIndex;
-  }
-  setTagsPrivateIDAttribute(str) {
-    this.tagsPrivateIDAttribute = str;
-    return this;
-  }
-  setTagsPublicIDAttribute(str) {
-    this.tagsPublicIDAttribute = str;
-    return this;
-  }
-  getById(id) {
-    const found = Array.from(this._items.values()).find((entry) => entry.id === id);
-    if (found === void 0) return void 0;
-    return found;
-  }
-  generateUniquePrivateId() {
-    const existingIds = Array.from(this._items.keys());
-    const generated = randomHash(12);
-    if (existingIds.includes(generated)) return this.generateUniquePrivateId();
-    return generated;
-  }
-  _rendered = /* @__PURE__ */ new Map();
-  render(element) {
-    const root = reactCreateRoot(element);
-    const items = this.items;
-    root.render(/* @__PURE__ */ jsx(
-      StylesSetComp,
-      {
-        items,
-        privateIDAttribute: this.tagsPrivateIDAttribute,
-        publicIDAttribute: this.tagsPublicIDAttribute
-      }
-    ));
-    this._rendered.set(element, root);
-    return this;
-  }
-  unmount(element) {
-    if (!this._rendered.has(element)) return this;
-    const root = this._rendered.get(element);
-    if (root === void 0) return this;
-    root.unmount();
-    this._rendered.delete(element);
-    return this;
-  }
-  updateRendered() {
-    const { items } = this;
-    this._rendered.forEach((root) => root.render(/* @__PURE__ */ jsx(
-      StylesSetComp,
-      {
-        items,
-        privateIDAttribute: this.tagsPrivateIDAttribute,
-        publicIDAttribute: this.tagsPublicIDAttribute
-      }
-    )));
-    return this;
-  }
-  addItem(item, abortIfIdExists = true) {
-    const existing = Array.from(this._items.entries()).map(([privateId2, entry]) => ({ privateId: privateId2, entry })).find(({ entry }) => entry.id !== void 0 && entry.id === item.id);
-    if (existing !== void 0) {
-      if (abortIfIdExists) return this;
-      this._items.delete(existing.privateId);
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Component } from 'react';
+import { createRoot as reactCreateRoot } from 'react-dom/client';
+import { randomHash } from '../../random/uuid/index.js';
+export class StylesSet {
+    static defaultPrivateIDAttribute = 'data-styleset-private-id';
+    static defaultPublicIDAttribute = 'data-styleset-public-id';
+    tagsPrivateIDAttribute = StylesSet.defaultPrivateIDAttribute;
+    tagsPublicIDAttribute = StylesSet.defaultPublicIDAttribute;
+    _items = new Map();
+    get items() {
+        const sortedItemsArray = Array.from(this._items).map(([privateId, item]) => {
+            const targetPosition = this.getTargetPosition(privateId) ?? 0;
+            return { targetPosition, privateId, item };
+        }).sort((a, b) => a.targetPosition - b.targetPosition)
+            .map(({ item, privateId }) => [privateId, item]);
+        const sortedItemsMap = new Map(sortedItemsArray);
+        return sortedItemsMap;
     }
-    const privateId = this.generateUniquePrivateId();
-    this._items.set(privateId, item);
-    this.updateRendered();
-    return this;
-  }
-  removeItem(idOrPosition) {
-    if (typeof idOrPosition === "string") {
-      const existing = Array.from(this._items.entries()).map(([privateId, entry]) => ({ privateId, entry })).find(({ entry }) => entry.id !== void 0 && entry.id === idOrPosition);
-      if (existing === void 0) return this;
-      this._items.delete(existing.privateId);
-      this.updateRendered();
-      return this;
+    getTargetPosition(privateId) {
+        const orderedStyles = Array.from(this._items)
+            .map(([privateId, data]) => ({ privateId, data }))
+            .sort((a, b) => {
+            const aPos = a.data.position ?? 0;
+            const bPos = b.data.position ?? 0;
+            return aPos - bPos;
+        });
+        const foundIndex = orderedStyles.findIndex(item => item.privateId === privateId);
+        return foundIndex === -1 ? null : foundIndex;
     }
-    const toRemove = Array.from(this._items).map(([privateId, entry]) => ({ privateId, entry })).at(idOrPosition);
-    if (toRemove === void 0) return this;
-    this._items.delete(toRemove.privateId);
-    this.updateRendered();
-    return this;
-  }
-  async getDomString(documentObj) {
-    const actualDocumentObj = documentObj ?? window.document;
-    if (actualDocumentObj === null) throw new Error("Window.document is not available");
-    return await new Promise((resolve) => {
-      const tempElt = actualDocumentObj.createElement("div");
-      const tempRoot = reactCreateRoot(tempElt);
-      const { items } = this;
-      const onRendered = () => {
-        resolve(tempElt.innerHTML);
-        tempRoot.unmount();
-        tempElt.remove();
-      };
-      tempRoot.render(/* @__PURE__ */ jsx(
-        StylesSetComp,
-        {
-          items,
-          privateIDAttribute: this.tagsPrivateIDAttribute,
-          publicIDAttribute: this.tagsPublicIDAttribute,
-          onRendered
+    setTagsPrivateIDAttribute(str) {
+        this.tagsPrivateIDAttribute = str;
+        return this;
+    }
+    setTagsPublicIDAttribute(str) {
+        this.tagsPublicIDAttribute = str;
+        return this;
+    }
+    getById(id) {
+        const found = Array.from(this._items.values())
+            .find(entry => entry.id === id);
+        if (found === undefined)
+            return undefined;
+        return found;
+    }
+    generateUniquePrivateId() {
+        const existingIds = Array.from(this._items.keys());
+        const generated = randomHash(12);
+        if (existingIds.includes(generated))
+            return this.generateUniquePrivateId();
+        return generated;
+    }
+    _rendered = new Map();
+    render(element) {
+        const root = reactCreateRoot(element);
+        const items = this.items;
+        root.render(_jsx(StylesSetComp, { items: items, privateIDAttribute: this.tagsPrivateIDAttribute, publicIDAttribute: this.tagsPublicIDAttribute }));
+        this._rendered.set(element, root);
+        return this;
+    }
+    unmount(element) {
+        if (!this._rendered.has(element))
+            return this;
+        const root = this._rendered.get(element);
+        if (root === undefined)
+            return this;
+        root.unmount();
+        this._rendered.delete(element);
+        return this;
+    }
+    updateRendered() {
+        const { items } = this;
+        this._rendered.forEach((root) => root.render(_jsx(StylesSetComp, { items: items, privateIDAttribute: this.tagsPrivateIDAttribute, publicIDAttribute: this.tagsPublicIDAttribute })));
+        return this;
+    }
+    addItem(item, abortIfIdExists = true) {
+        const existing = Array
+            .from(this._items.entries())
+            .map(([privateId, entry]) => ({ privateId, entry }))
+            .find(({ entry }) => (entry.id !== undefined && entry.id === item.id));
+        if (existing !== undefined) {
+            if (abortIfIdExists)
+                return this;
+            this._items.delete(existing.privateId);
         }
-      ));
-    });
-  }
-};
-var StylesSetComp = class extends Component {
-  componentDidMount() {
-    const { props } = this;
-    const { onRendered } = props;
-    if (onRendered !== void 0) onRendered();
-  }
-  componentDidUpdate() {
-    const { props } = this;
-    const { onRendered } = props;
-    if (onRendered !== void 0) onRendered();
-  }
-  render() {
-    const { props } = this;
-    const items = props.items ?? /* @__PURE__ */ new Map();
-    const pidAttr = props.privateIDAttribute ?? StylesSet.defaultPrivateIDAttribute;
-    const idAttr = props.publicIDAttribute ?? StylesSet.defaultPublicIDAttribute;
-    return /* @__PURE__ */ jsx(Fragment, { children: Array.from(items).map(([privateId, itemData]) => {
-      const customAttributes = { [pidAttr]: privateId, [idAttr]: itemData.id };
-      if (itemData.type === "url") return /* @__PURE__ */ jsx(
-        "link",
-        {
-          onLoad: itemData.onLoad,
-          rel: "stylesheet",
-          href: itemData.content,
-          ...customAttributes
+        const privateId = this.generateUniquePrivateId();
+        this._items.set(privateId, item);
+        this.updateRendered();
+        return this;
+    }
+    removeItem(idOrPosition) {
+        if (typeof idOrPosition === 'string') {
+            const existing = Array
+                .from(this._items.entries())
+                .map(([privateId, entry]) => ({ privateId, entry }))
+                .find(({ entry }) => (entry.id !== undefined && entry.id === idOrPosition));
+            if (existing === undefined)
+                return this;
+            this._items.delete(existing.privateId);
+            this.updateRendered();
+            return this;
         }
-      );
-      return /* @__PURE__ */ jsx("style", { ...customAttributes, children: itemData.content });
-    }) });
-  }
-};
-export {
-  StylesSet,
-  StylesSetComp
-};
+        const toRemove = Array
+            .from(this._items)
+            .map(([privateId, entry]) => ({ privateId, entry }))
+            .at(idOrPosition);
+        if (toRemove === undefined)
+            return this;
+        this._items.delete(toRemove.privateId);
+        this.updateRendered();
+        return this;
+    }
+    async getDomString(documentObj) {
+        const actualDocumentObj = documentObj ?? window.document;
+        if (actualDocumentObj === null)
+            throw new Error('Window.document is not available');
+        return await new Promise(resolve => {
+            const tempElt = actualDocumentObj.createElement('div');
+            const tempRoot = reactCreateRoot(tempElt);
+            const { items } = this;
+            const onRendered = () => {
+                resolve(tempElt.innerHTML);
+                tempRoot.unmount();
+                tempElt.remove();
+            };
+            tempRoot.render(_jsx(StylesSetComp, { items: items, privateIDAttribute: this.tagsPrivateIDAttribute, publicIDAttribute: this.tagsPublicIDAttribute, onRendered: onRendered }));
+        });
+    }
+}
+export class StylesSetComp extends Component {
+    componentDidMount() {
+        const { props } = this;
+        const { onRendered } = props;
+        if (onRendered !== undefined)
+            onRendered();
+    }
+    componentDidUpdate() {
+        const { props } = this;
+        const { onRendered } = props;
+        if (onRendered !== undefined)
+            onRendered();
+    }
+    render() {
+        const { props } = this;
+        const items = props.items ?? new Map();
+        const pidAttr = props.privateIDAttribute ?? StylesSet.defaultPrivateIDAttribute;
+        const idAttr = props.publicIDAttribute ?? StylesSet.defaultPublicIDAttribute;
+        return _jsx(_Fragment, { children: Array.from(items).map(([privateId, itemData]) => {
+                const customAttributes = { [pidAttr]: privateId, [idAttr]: itemData.id };
+                if (itemData.type === 'url')
+                    return _jsx("link", { onLoad: itemData.onLoad, rel: 'stylesheet', href: itemData.content, ...customAttributes });
+                return _jsx("style", { ...customAttributes, children: itemData.content });
+            }) });
+    }
+}

package/agnostic/errors/register/index.js

@@ -1,53 +1,47 @@
-import "../../../chunks/chunk-WSFCRVEQ.js";
-
-// 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,7 +1,18 @@
-import {
-  unknownToString
-} from "../../../chunks/chunk-PUQUSA6S.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  unknownToString
-};
+/**
+ * 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}`;
+}

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');
+    });
+});