solid-tiny-utils 0.4.2 → 0.6.0

package/dist/{chunk-ZGYORUAX.js → chunk-6G7GFZV2.js}

@@ -1,4 +1,4 @@
-// src/lodash/is.ts
+// src/utils/is.ts
 import { isServer } from "solid-js/web";
 var isSymbol = (value) => {
   return !!value && value.constructor === Symbol;

package/dist/{chunk-ILGNNUQK.js → chunk-6OVLJ45M.js}

@@ -1,21 +1,21 @@
 import {
   makeEventListener
-} from "./chunk-OUAI75QC.js";
+} from "./chunk-TGWWPUWD.js";
 import {
   noop
-} from "./chunk-BGLY6NJK.js";
+} from "./chunk-QPEF6LHH.js";
 import {
   access
-} from "./chunk-M5A3VVYI.js";
+} from "./chunk-YK5QQQ43.js";
 import {
   createWatch
 } from "./chunk-4L6FK7MF.js";
 import {
   clearArray
-} from "./chunk-CSAKXWF3.js";
+} from "./chunk-BT47ISVC.js";
 import {
   isArray
-} from "./chunk-ZGYORUAX.js";
+} from "./chunk-6G7GFZV2.js";
 
 // src/event/create-event-listener.ts
 function createEventListener(...args) {

package/dist/chunk-ACZGS7DG.js

@@ -0,0 +1,72 @@
+import {
+  clamp,
+  max
+} from "./chunk-PD6VHMH6.js";
+
+// src/color/oklch-rgb.ts
+var PI_180 = Math.PI / 180;
+var INV_PI_180 = 180 / Math.PI;
+var linearToSRGB = (x) => x <= 31308e-7 ? 12.92 * x : 1.055 * x ** (1 / 2.4) - 0.055;
+var sRGBToLinear = (x) => x <= 0.04045 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4;
+function normalizeHue(hue) {
+  return (hue % 360 + 360) % 360;
+}
+function oklchToRgb(oklch) {
+  const { l, c, h } = oklch;
+  const clampedL = clamp(l, 0, 1);
+  const clampedC = max(0, c);
+  const normalizedH = normalizeHue(h);
+  const a_ = clampedC * Math.cos(normalizedH * PI_180);
+  const b_ = clampedC * Math.sin(normalizedH * PI_180);
+  const L = clampedL;
+  const A = a_;
+  const B = b_;
+  const l_ = L + 0.3963377774 * A + 0.2158037573 * B;
+  const m_ = L - 0.1055613458 * A - 0.0638541728 * B;
+  const s_ = L - 0.0894841775 * A - 1.291485548 * B;
+  const l3 = l_ ** 3;
+  const m3 = m_ ** 3;
+  const s3 = s_ ** 3;
+  let r = 4.0767416621 * l3 - 3.3077115913 * m3 + 0.2309699292 * s3;
+  let g = -1.2684380046 * l3 + 2.6097574011 * m3 - 0.3413193965 * s3;
+  let b = -0.0041960863 * l3 - 0.7034186147 * m3 + 1.707614701 * s3;
+  r = linearToSRGB(r);
+  g = linearToSRGB(g);
+  b = linearToSRGB(b);
+  return {
+    r: Math.round(clamp(r) * 255),
+    g: Math.round(clamp(g) * 255),
+    b: Math.round(clamp(b) * 255)
+  };
+}
+function rgbToOklch(rgb) {
+  const r = clamp(rgb.r, 0, 255);
+  const g = clamp(rgb.g, 0, 255);
+  const b = clamp(rgb.b, 0, 255);
+  const rLinear = sRGBToLinear(r / 255);
+  const gLinear = sRGBToLinear(g / 255);
+  const bLinear = sRGBToLinear(b / 255);
+  const l_ = Math.cbrt(
+    0.4122214708 * rLinear + 0.5363325363 * gLinear + 0.0514459929 * bLinear
+  );
+  const m_ = Math.cbrt(
+    0.2119034982 * rLinear + 0.6806995451 * gLinear + 0.1073969566 * bLinear
+  );
+  const s_ = Math.cbrt(
+    0.0883024619 * rLinear + 0.2817188376 * gLinear + 0.6299787005 * bLinear
+  );
+  const L = 0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_;
+  const A = 1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_;
+  const B = 0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_;
+  const c = Math.sqrt(A * A + B * B);
+  let h = Math.atan2(B, A) * INV_PI_180;
+  if (h < 0) {
+    h += 360;
+  }
+  return { l: L, c, h };
+}
+
+export {
+  oklchToRgb,
+  rgbToOklch
+};

package/dist/{chunk-CSAKXWF3.js → chunk-BT47ISVC.js}

@@ -1,8 +1,8 @@
 import {
   isFn
-} from "./chunk-ZGYORUAX.js";
+} from "./chunk-6G7GFZV2.js";
 
-// src/lodash/array.ts
+// src/utils/array.ts
 var iterate = (count, func, initValue) => {
   let value = initValue;
   for (let i = 1; i <= count; i++) {

package/dist/{chunk-KVG6TCSE.js → chunk-DKZ3RJJI.js}

@@ -1,6 +1,6 @@
 import {
   isClient
-} from "./chunk-ZGYORUAX.js";
+} from "./chunk-6G7GFZV2.js";
 
 // src/dom/css.ts
 var alreadyInjected = [];
@@ -22,7 +22,25 @@ function mountStyle(style, id, refresh = false) {
   document.head.appendChild(styleElement);
   alreadyInjected.push(id);
 }
+var extractCSSregex = /((?:--)?(?:\w+-?)+)\s*:\s*([^;]*)/g;
+function stringStyleToObject(style) {
+  const object = {};
+  let match = extractCSSregex.exec(style);
+  while (match) {
+    if (match[1] && match[2]) {
+      object[match[1]] = match[2];
+    }
+    match = extractCSSregex.exec(style);
+  }
+  return object;
+}
+function combineStyle(a, b) {
+  const bb = typeof b === "string" ? stringStyleToObject(b) : b;
+  return { ...a, ...bb };
+}
 
 export {
-  mountStyle
+  mountStyle,
+  stringStyleToObject,
+  combineStyle
 };

package/dist/chunk-KFLH3AZ6.js

@@ -0,0 +1,40 @@
+import {
+  isArray
+} from "./chunk-6G7GFZV2.js";
+import {
+  clamp,
+  toHex
+} from "./chunk-PD6VHMH6.js";
+
+// src/color/hex-rgb.ts
+var HEX_PREFIX_REGEX = /^#/;
+var HEX_VALIDATION_REGEX = /^[0-9a-fA-F]{6}$/;
+function hexToRgb(hex) {
+  if (!hex || typeof hex !== "string") {
+    return null;
+  }
+  let value = hex.trim().replace(HEX_PREFIX_REGEX, "");
+  if (value.length === 3) {
+    value = value.split("").map((c) => c + c).join("");
+  }
+  if (!HEX_VALIDATION_REGEX.test(value)) {
+    return null;
+  }
+  const r = Number.parseInt(value.slice(0, 2), 16);
+  const g = Number.parseInt(value.slice(2, 4), 16);
+  const b = Number.parseInt(value.slice(4, 6), 16);
+  return { r, g, b };
+}
+function rgbToHex(rgb) {
+  const c = (v) => Math.round(clamp(v, 0, 255));
+  const rgb_ = isArray(rgb) ? rgb : [rgb.r, rgb.g, rgb.b];
+  const r = c(rgb_[0]);
+  const g = c(rgb_[1]);
+  const b = c(rgb_[2]);
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+
+export {
+  hexToRgb,
+  rgbToHex
+};

package/dist/{chunk-KFWZFQMB.js → chunk-KKFGUHFR.js}

@@ -1,4 +1,4 @@
-// src/lodash/async.ts
+// src/utils/async.ts
 var sleep = (milliseconds) => {
   return new Promise((res) => setTimeout(res, milliseconds));
 };

package/dist/chunk-LEWF7QAQ.js

@@ -0,0 +1,47 @@
+import {
+  noop
+} from "./chunk-QPEF6LHH.js";
+import {
+  access
+} from "./chunk-YK5QQQ43.js";
+import {
+  createWatch
+} from "./chunk-4L6FK7MF.js";
+import {
+  clearArray
+} from "./chunk-BT47ISVC.js";
+
+// src/event/create-intersection-observer.ts
+import { onCleanup } from "solid-js";
+import { isServer } from "solid-js/web";
+function createIntersectionObserver(targets, callback, options = {}) {
+  if (isServer) {
+    return noop;
+  }
+  const io = new IntersectionObserver(callback, options);
+  onCleanup(() => io.disconnect());
+  const cleanups = [];
+  const cleanup = () => {
+    for (const c of cleanups) {
+      c();
+    }
+    clearArray(cleanups);
+  };
+  createWatch(
+    () => targets.map(access),
+    (elements) => {
+      cleanup();
+      for (const element of elements) {
+        if (element) {
+          io.observe(element);
+          cleanups.push(() => io.unobserve(element));
+        }
+      }
+    }
+  );
+  return () => io.disconnect();
+}
+
+export {
+  createIntersectionObserver
+};

package/dist/chunk-PD6VHMH6.js

@@ -0,0 +1,26 @@
+// src/utils/number.ts
+function min(...numbers) {
+  return Math.min(...numbers);
+}
+function max(...numbers) {
+  return Math.max(...numbers);
+}
+function clamp(x, minimum = 0, maximum = 1) {
+  return min(maximum, max(minimum, x));
+}
+function inRange(x, minimum = 0, maximum = 1, inclusivity = "[]") {
+  const minCheck = inclusivity[0] === "[" ? x >= minimum : x > minimum;
+  const maxCheck = inclusivity[1] === "]" ? x <= maximum : x < maximum;
+  return minCheck && maxCheck;
+}
+function toHex(x, pad = 2) {
+  return x.toString(16).padStart(pad, "0");
+}
+
+export {
+  min,
+  max,
+  clamp,
+  inRange,
+  toHex
+};

package/dist/{chunk-BGLY6NJK.js → chunk-QPEF6LHH.js}

@@ -1,12 +1,12 @@
 import {
   access
-} from "./chunk-M5A3VVYI.js";
+} from "./chunk-YK5QQQ43.js";
 import {
   createWatch
 } from "./chunk-4L6FK7MF.js";
 import {
   isNumber
-} from "./chunk-ZGYORUAX.js";
+} from "./chunk-6G7GFZV2.js";
 
 // src/fn/create-debounce.ts
 import { onCleanup as onCleanup3 } from "solid-js";

package/dist/{chunk-PBALVUKK.js → chunk-QQVSG76Z.js}

@@ -1,8 +1,8 @@
 import {
   iterate
-} from "./chunk-CSAKXWF3.js";
+} from "./chunk-BT47ISVC.js";
 
-// src/lodash/random.ts
+// src/utils/random.ts
 var random = (min, max) => {
   return Math.floor(Math.random() * (max - min + 1) + min);
 };

package/dist/chunk-S7U3LZNS.js

@@ -0,0 +1,23 @@
+import {
+  hexToRgb
+} from "./chunk-KFLH3AZ6.js";
+import {
+  inRange
+} from "./chunk-PD6VHMH6.js";
+
+// src/color/validation.ts
+function isValidRGB(rgb) {
+  return Object.values(rgb).every((x) => inRange(x, 0, 255));
+}
+function isValidOKLCH(oklch) {
+  return inRange(oklch.l) && oklch.c >= 0 && inRange(oklch.h, 0, 360);
+}
+function isValidHex(hex) {
+  return hexToRgb(hex) !== null;
+}
+
+export {
+  isValidRGB,
+  isValidOKLCH,
+  isValidHex
+};

package/dist/chunk-TDJLPDJF.js

@@ -0,0 +1,66 @@
+import {
+  access
+} from "./chunk-YK5QQQ43.js";
+import {
+  createWatch
+} from "./chunk-4L6FK7MF.js";
+import {
+  isObject
+} from "./chunk-6G7GFZV2.js";
+
+// src/event/create-visibility-observer.ts
+import { createSignal, onCleanup } from "solid-js";
+function createVisibilityObserver(arg1, arg2) {
+  let target;
+  let options;
+  if (arg1 && !isObject(arg1)) {
+    target = arg1;
+    options = arg2 ?? {};
+  } else {
+    options = arg1 ?? {};
+  }
+  const callbacks = /* @__PURE__ */ new WeakMap();
+  const io = new IntersectionObserver((entries, instance) => {
+    for (const entry of entries) {
+      callbacks.get(entry.target)?.(entry, instance);
+    }
+  }, options);
+  onCleanup(() => io.disconnect());
+  const addEntry = (el, callback) => {
+    io.observe(el);
+    callbacks.set(el, callback);
+  };
+  const removeEntry = (el) => {
+    io.unobserve(el);
+    callbacks.delete(el);
+  };
+  const useVisibilityObserverFn = (element) => {
+    const [isVisible, setVisible] = createSignal(
+      options?.initialValue ?? false
+    );
+    let prevEl;
+    createWatch(
+      () => access(element),
+      (el) => {
+        if (prevEl) {
+          removeEntry(prevEl);
+        }
+        if (el) {
+          addEntry(el, (entry) => {
+            setVisible(entry.isIntersecting);
+          });
+          prevEl = el;
+        }
+      }
+    );
+    return isVisible;
+  };
+  if (target) {
+    return useVisibilityObserverFn(target);
+  }
+  return useVisibilityObserverFn;
+}
+
+export {
+  createVisibilityObserver
+};

package/dist/{chunk-OUAI75QC.js → chunk-TGWWPUWD.js}

@@ -1,12 +1,12 @@
 import {
   noop
-} from "./chunk-BGLY6NJK.js";
+} from "./chunk-QPEF6LHH.js";
 import {
   clearArray
-} from "./chunk-CSAKXWF3.js";
+} from "./chunk-BT47ISVC.js";
 import {
   isArray
-} from "./chunk-ZGYORUAX.js";
+} from "./chunk-6G7GFZV2.js";
 
 // src/event/make-event-listener.ts
 import { onCleanup } from "solid-js";

package/dist/{chunk-NFDGLC4A.js → chunk-WJHRONQU.js}

@@ -1,9 +1,9 @@
 import {
   makeEventListener
-} from "./chunk-OUAI75QC.js";
+} from "./chunk-TGWWPUWD.js";
 import {
   access
-} from "./chunk-M5A3VVYI.js";
+} from "./chunk-YK5QQQ43.js";
 
 // src/event/create-click-outside.ts
 function createClickOutside(target, handler, options) {

package/dist/{chunk-PNR5G432.js → chunk-Y4GYGFIT.js}

@@ -1,4 +1,4 @@
-// src/lodash/str.ts
+// src/utils/str.ts
 var capitalize = (str) => {
   if (!str || str.length === 0) {
     return "";

package/dist/{chunk-M5A3VVYI.js → chunk-YK5QQQ43.js}

@@ -1,6 +1,6 @@
 import {
   isFn
-} from "./chunk-ZGYORUAX.js";
+} from "./chunk-6G7GFZV2.js";
 
 // src/reactive/access.ts
 function access(value) {

package/dist/color/hex-rgb.d.ts

@@ -0,0 +1,36 @@
+import { RGB } from './oklch-rgb.js';
+
+/**
+ * Converts a hex color string to RGB color values.
+ *
+ * Supports both 3-digit (#rgb) and 6-digit (#rrggbb) hex formats.
+ * The hash symbol (#) is optional.
+ *
+ * @param hex - Hex color string (e.g., "#ffcc00", "ffcc00", "#fc0", "fc0")
+ * @returns RGB object with r, g, b values (0-255), or null if invalid
+ *
+ * @example
+ * ```typescript
+ * hexToRgb("#ffcc00") // => { r: 255, g: 204, b: 0 }
+ * hexToRgb("fc0")     // => { r: 255, g: 204, b: 0 }
+ * hexToRgb("#invalid") // => null
+ * ```
+ */
+declare function hexToRgb(hex: string): RGB | null;
+/**
+ * Converts RGB color values to a hex color string.
+ *
+ * RGB values are automatically clamped to the 0-255 range.
+ *
+ * @param rgb - RGB object with r, g, b values
+ * @returns Hex color string with # prefix (e.g., "#ffcc00")
+ *
+ * @example
+ * ```typescript
+ * rgbToHex({ r: 255, g: 204, b: 0 }) // => "#ffcc00"
+ * rgbToHex({ r: 300, g: -10, b: 128 }) // => "#ff0080" (clamped values)
+ * ```
+ */
+declare function rgbToHex(rgb: RGB | [number, number, number]): string;
+
+export { hexToRgb, rgbToHex };

package/dist/color/hex-rgb.js

@@ -0,0 +1,15 @@
+import {
+  hexToRgb,
+  rgbToHex
+} from "../chunk-KFLH3AZ6.js";
+import "../chunk-U5LQ2AS5.js";
+import "../chunk-QQVSG76Z.js";
+import "../chunk-Y4GYGFIT.js";
+import "../chunk-BT47ISVC.js";
+import "../chunk-KKFGUHFR.js";
+import "../chunk-6G7GFZV2.js";
+import "../chunk-PD6VHMH6.js";
+export {
+  hexToRgb,
+  rgbToHex
+};

package/dist/color/index.d.ts

@@ -0,0 +1,3 @@
+export { hexToRgb, rgbToHex } from './hex-rgb.js';
+export { OKLCH, RGB, oklchToRgb, rgbToOklch } from './oklch-rgb.js';
+export { isValidHex, isValidOKLCH, isValidRGB } from './validation.js';

package/dist/color/index.js

@@ -0,0 +1,30 @@
+import "../chunk-BLX3XSA6.js";
+import {
+  oklchToRgb,
+  rgbToOklch
+} from "../chunk-ACZGS7DG.js";
+import {
+  isValidHex,
+  isValidOKLCH,
+  isValidRGB
+} from "../chunk-S7U3LZNS.js";
+import {
+  hexToRgb,
+  rgbToHex
+} from "../chunk-KFLH3AZ6.js";
+import "../chunk-U5LQ2AS5.js";
+import "../chunk-QQVSG76Z.js";
+import "../chunk-Y4GYGFIT.js";
+import "../chunk-BT47ISVC.js";
+import "../chunk-KKFGUHFR.js";
+import "../chunk-6G7GFZV2.js";
+import "../chunk-PD6VHMH6.js";
+export {
+  hexToRgb,
+  isValidHex,
+  isValidOKLCH,
+  isValidRGB,
+  oklchToRgb,
+  rgbToHex,
+  rgbToOklch
+};

package/dist/color/oklch-rgb.d.ts

@@ -0,0 +1,49 @@
+interface RGB {
+    r: number;
+    g: number;
+    b: number;
+}
+interface OKLCH {
+    l: number;
+    c: number;
+    h: number;
+}
+/**
+ * Converts OKLCH color to RGB color space.
+ *
+ * OKLCH is a perceptually uniform color space based on OKLab.
+ * Input values are automatically clamped to valid ranges.
+ *
+ * @param oklch - The OKLCH color to convert
+ * @param oklch.l - Lightness (0-1, will be clamped)
+ * @param oklch.c - Chroma (≥0, will be clamped)
+ * @param oklch.h - Hue in degrees (will be normalized to 0-360)
+ * @returns RGB color with values 0-255
+ *
+ * @example
+ * ```typescript
+ * const rgb = oklchToRgb({ l: 0.7, c: 0.1, h: 200 });
+ * // => { r: 64, g: 177, b: 183 }
+ * ```
+ */
+declare function oklchToRgb(oklch: OKLCH): RGB;
+/**
+ * Converts RGB color to OKLCH color space.
+ *
+ * RGB values are automatically clamped to 0-255 range.
+ *
+ * @param rgb - The RGB color to convert
+ * @param rgb.r - Red component (0-255, will be clamped)
+ * @param rgb.g - Green component (0-255, will be clamped)
+ * @param rgb.b - Blue component (0-255, will be clamped)
+ * @returns OKLCH color with l∈[0,1], c≥0, h∈[0,360)
+ *
+ * @example
+ * ```typescript
+ * const oklch = rgbToOklch({ r: 64, g: 177, b: 183 });
+ * // => { l: 0.7, c: 0.1, h: 200 }
+ * ```
+ */
+declare function rgbToOklch(rgb: RGB): OKLCH;
+
+export { type OKLCH, type RGB, oklchToRgb, rgbToOklch };

package/dist/color/oklch-rgb.js

@@ -0,0 +1,15 @@
+import {
+  oklchToRgb,
+  rgbToOklch
+} from "../chunk-ACZGS7DG.js";
+import "../chunk-U5LQ2AS5.js";
+import "../chunk-QQVSG76Z.js";
+import "../chunk-Y4GYGFIT.js";
+import "../chunk-BT47ISVC.js";
+import "../chunk-KKFGUHFR.js";
+import "../chunk-6G7GFZV2.js";
+import "../chunk-PD6VHMH6.js";
+export {
+  oklchToRgb,
+  rgbToOklch
+};

package/dist/color/validation.d.ts

@@ -0,0 +1,26 @@
+import { RGB, OKLCH } from './oklch-rgb.js';
+
+/**
+ * Checks if RGB values are in valid range (0-255)
+ */
+declare function isValidRGB(rgb: RGB): boolean;
+/**
+ * Checks if OKLCH values are in valid ranges
+ */
+declare function isValidOKLCH(oklch: OKLCH): boolean;
+/**
+ * Checks if a string is a valid hex color format.
+ *
+ * @param hex - String to validate
+ * @returns `true` if the string is a valid hex color, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * isValidHex("#ffcc00") // => true
+ * isValidHex("fc0")     // => true
+ * isValidHex("#invalid") // => false
+ * ```
+ */
+declare function isValidHex(hex: string): boolean;
+
+export { isValidHex, isValidOKLCH, isValidRGB };

package/dist/color/validation.js

@@ -0,0 +1,18 @@
+import {
+  isValidHex,
+  isValidOKLCH,
+  isValidRGB
+} from "../chunk-S7U3LZNS.js";
+import "../chunk-KFLH3AZ6.js";
+import "../chunk-U5LQ2AS5.js";
+import "../chunk-QQVSG76Z.js";
+import "../chunk-Y4GYGFIT.js";
+import "../chunk-BT47ISVC.js";
+import "../chunk-KKFGUHFR.js";
+import "../chunk-6G7GFZV2.js";
+import "../chunk-PD6VHMH6.js";
+export {
+  isValidHex,
+  isValidOKLCH,
+  isValidRGB
+};

package/dist/dom/css.d.ts

@@ -1,3 +1,5 @@
+import { JSX } from 'solid-js/jsx-runtime';
+
 /**
  * Mounts a style element to the document head.
  * If the style element with the given id already exists, it updates its content.
@@ -9,5 +11,7 @@
  * @param refresh - Whether to refresh the style if it already exists. Defaults to **false**.
  */
 declare function mountStyle(style: string, id: string, refresh?: boolean): void;
+declare function stringStyleToObject(style: string): JSX.CSSProperties;
+declare function combineStyle(a: JSX.CSSProperties, b: JSX.CSSProperties | string | undefined): JSX.CSSProperties | string;
 
-export { mountStyle };
+export { combineStyle, mountStyle, stringStyleToObject };