solid-tiny-utils 0.7.1 → 0.9.0

package/dist/utils/number.mjs

@@ -0,0 +1,127 @@
+//#region src/utils/number.ts
+/**
+* Returns the smallest of the given numbers.
+*
+* This is a convenience wrapper around `Math.min` that provides better type safety
+* and consistency with other utility functions.
+*
+* @param numbers - The numbers to compare
+* @returns The smallest number from the input
+*
+* @example
+* ```typescript
+* min(1, 2, 3) // => 1
+* min(-5, 0, 10) // => -5
+* min(3.14, 2.71, 1.41) // => 1.41
+* ```
+*/
+function min(...numbers) {
+	return Math.min(...numbers);
+}
+/**
+* Returns the largest of the given numbers.
+*
+* This is a convenience wrapper around `Math.max` that provides better type safety
+* and consistency with other utility functions.
+*
+* @param numbers - The numbers to compare
+* @returns The largest number from the input
+*
+* @example
+* ```typescript
+* max(1, 2, 3) // => 3
+* max(-5, 0, 10) // => 10
+* max(3.14, 2.71, 1.41) // => 3.14
+* ```
+*/
+function max(...numbers) {
+	return Math.max(...numbers);
+}
+/**
+* Clamps a number to within the specified bounds.
+*
+* If the number is less than the minimum, returns the minimum.
+* If the number is greater than the maximum, returns the maximum.
+* Otherwise, returns the number unchanged.
+*
+* @param x - The number to clamp
+* @param minimum - The lower bound (inclusive)
+* @param maximum - The upper bound (inclusive)
+* @returns The clamped number
+*
+* @example
+* ```typescript
+* clamp(0.5) // => 0.5 (within default 0-1 range)
+* clamp(-0.1) // => 0 (clamped to minimum)
+* clamp(1.5) // => 1 (clamped to maximum)
+* clamp(15, 10, 20) // => 15 (within range)
+* clamp(5, 10, 20) // => 10 (clamped to minimum)
+* clamp(25, 10, 20) // => 20 (clamped to maximum)
+* ```
+*/
+function clamp(x, minimum = 0, maximum = 1) {
+	return min(maximum, max(minimum, x));
+}
+/**
+* Checks if a number is within a specified range.
+*
+* Supports different inclusivity modes:
+* - `'[]'` - Both bounds inclusive (default): `minimum ≤ x ≤ maximum`
+* - `'()'` - Both bounds exclusive: `minimum < x < maximum`
+* - `'[)'` - Lower inclusive, upper exclusive: `minimum ≤ x < maximum`
+* - `'(]'` - Lower exclusive, upper inclusive: `minimum < x ≤ maximum`
+*
+* @param x - The number to check
+* @param minimum - The lower bound of the range
+* @param maximum - The upper bound of the range
+* @param inclusivity - Specifies whether the bounds are inclusive or exclusive
+* @returns `true` if the number is within the range, `false` otherwise
+*
+* @example
+* ```typescript
+* // Default inclusive range [0, 1]
+* inRange(0.5) // => true
+* inRange(0) // => true (inclusive)
+* inRange(1) // => true (inclusive)
+* inRange(-0.1) // => false
+* inRange(1.1) // => false
+*
+* // Custom range [10, 20]
+* inRange(15, 10, 20) // => true
+* inRange(10, 10, 20) // => true (inclusive)
+* inRange(20, 10, 20) // => true (inclusive)
+*
+* // Exclusive bounds (10, 20)
+* inRange(15, 10, 20, '()') // => true
+* inRange(10, 10, 20, '()') // => false (exclusive)
+* inRange(20, 10, 20, '()') // => false (exclusive)
+*
+* // Mixed inclusivity [10, 20)
+* inRange(10, 10, 20, '[)') // => true (lower inclusive)
+* inRange(20, 10, 20, '[)') // => false (upper exclusive)
+* ```
+*/
+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;
+}
+/**
+* Converts a number to a hexadecimal string.
+*
+* @param x - The number to convert
+* @param pad - The number of digits to pad the output with (default: 2)
+* @returns The hexadecimal representation of the number
+*
+* @example
+* ```typescript
+* toHEX(255) // => "ff"
+* toHEX(255, 4) // => "00ff"
+* ```
+*/
+function toHex(x, pad = 2) {
+	return x.toString(16).padStart(pad, "0");
+}
+
+//#endregion
+export { clamp, inRange, max, min, toHex };

package/dist/utils/{random.d.ts → random.d.mts}

@@ -1,3 +1,4 @@
+//#region src/utils/random.d.ts
 /**
  * Generates a random number between min and max
  */
@@ -9,5 +10,5 @@ declare const random: (min: number, max: number) => number;
 declare const draw: <T>(array: readonly T[]) => T | null;
 declare const shuffle: <T>(array: readonly T[]) => T[];
 declare const uid: (length: number, specials?: string) => string;
-
-export { draw, random, shuffle, uid };
+//#endregion
+export { draw, random, shuffle, uid };

package/dist/utils/random.mjs

@@ -0,0 +1,33 @@
+import { iterate } from "./array.mjs";
+
+//#region src/utils/random.ts
+/**
+* Generates a random number between min and max
+*/
+const random = (min, max) => {
+	return Math.floor(Math.random() * (max - min + 1) + min);
+};
+/**
+* Draw a random item from a list. Returns
+* null if the list is empty
+*/
+const draw = (array) => {
+	const max = array.length;
+	if (max === 0) return null;
+	return array[random(0, max - 1)];
+};
+const shuffle = (array) => {
+	return array.map((a) => ({
+		rand: Math.random(),
+		value: a
+	})).sort((a, b) => a.rand - b.rand).map((a) => a.value);
+};
+const uid = (length, specials = "") => {
+	const characters = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789${specials}`;
+	return iterate(length, (acc) => {
+		return acc + characters.charAt(random(0, characters.length - 1));
+	}, "");
+};
+
+//#endregion
+export { draw, random, shuffle, uid };

package/dist/utils/{str.d.ts → str.d.mts}

@@ -1,3 +1,4 @@
+//#region src/utils/str.d.ts
 /**
  * Capitalize the first word of the string
  *
@@ -23,7 +24,7 @@ declare const camel: (str: string) => string;
  * snake('helloWord') -> 'hello_world'
  */
 declare const snake: (str: string, options?: {
-    splitOnNumber?: boolean;
+  splitOnNumber?: boolean;
 }) => string;
 /**
  * Formats the given string in dash case fashion
@@ -71,5 +72,5 @@ declare const template: (str: string, data: Record<string, any>, regex?: RegExp)
  * ```
  */
 declare const trim: (str: string | null | undefined, charsToTrim?: string) => string;
-
-export { camel, capitalize, dash, pascal, snake, template, title, trim };
+//#endregion
+export { camel, capitalize, dash, pascal, snake, template, title, trim };

package/dist/utils/str.mjs

@@ -0,0 +1,120 @@
+//#region src/utils/str.ts
+/**
+* Capitalize the first word of the string
+*
+* capitalize('hello')   -> 'Hello'
+* capitalize('va va voom') -> 'Va va voom'
+*/
+const capitalize = (str) => {
+	if (!str || str.length === 0) return "";
+	const lower = str.toLowerCase();
+	return lower.substring(0, 1).toUpperCase() + lower.substring(1, lower.length);
+};
+const splitRegexp = /(?=[A-Z])|[.\-\s_]/;
+/**
+* Formats the given string in camel case fashion
+*
+* camel('hello world')   -> 'helloWorld'
+* camel('va va-VOOM') -> 'vaVaVoom'
+* camel('helloWorld') -> 'helloWorld'
+*/
+const camel = (str) => {
+	const parts = str?.replace(/([A-Z])+/g, capitalize)?.split(splitRegexp).map((x) => x.toLowerCase()) ?? [];
+	if (parts.length === 0) return "";
+	if (parts.length === 1) return parts[0];
+	return parts.reduce((acc, part) => {
+		return `${acc}${part.charAt(0).toUpperCase()}${part.slice(1)}`;
+	});
+};
+const splitOnNumberRegexp = /([A-Za-z]{1}[0-9]{1})/;
+/**
+* Formats the given string in snake case fashion
+*
+* splitOnNumber? Treat number as capital, default is true
+*
+* snake('hello world')   -> 'hello_world'
+* snake('va va-VOOM') -> 'va_va_voom'
+* snake('helloWord') -> 'hello_world'
+*/
+const snake = (str, options) => {
+	const parts = str?.replace(/([A-Z])+/g, capitalize).split(splitRegexp).map((x) => x.toLowerCase()) ?? [];
+	if (parts.length === 0) return "";
+	if (parts.length === 1) return parts[0];
+	const result = parts.reduce((acc, part) => {
+		return `${acc}_${part.toLowerCase()}`;
+	});
+	return options?.splitOnNumber === false ? result : result.replace(splitOnNumberRegexp, (val) => `${val[0]}_${val[1]}`);
+};
+/**
+* Formats the given string in dash case fashion
+*
+* dash('hello world')   -> 'hello-world'
+* dash('va va_VOOM') -> 'va-va-voom'
+* dash('helloWord') -> 'hello-word'
+*/
+const dash = (str) => {
+	const parts = str?.replace(/([A-Z])+/g, capitalize)?.split(splitRegexp).map((x) => x.toLowerCase()) ?? [];
+	if (parts.length === 0) return "";
+	if (parts.length === 1) return parts[0];
+	return parts.reduce((acc, part) => {
+		return `${acc}-${part.toLowerCase()}`;
+	});
+};
+const pascalSplitRegexp = /[.\-\s_]/;
+/**
+* Formats the given string in pascal case fashion
+*
+* pascal('hello world') -> 'HelloWorld'
+* pascal('va va boom') -> 'VaVaBoom'
+*/
+const pascal = (str) => {
+	const parts = str?.split(pascalSplitRegexp).map((x) => x.toLowerCase()) ?? [];
+	if (parts.length === 0) return "";
+	return parts.map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+};
+/**
+* Formats the given string in title case fashion
+*
+* title('hello world') -> 'Hello World'
+* title('va_va_boom') -> 'Va Va Boom'
+* title('root-hook') -> 'Root Hook'
+* title('queryItems') -> 'Query Items'
+*/
+const title = (str) => {
+	if (!str) return "";
+	return str.split(splitRegexp).map((s) => s.trim()).filter((s) => !!s).map((s) => capitalize(s.toLowerCase())).join(" ");
+};
+/**
+* template is used to replace data by name in template strings.
+* The default expression looks for {{name}} to identify names.
+*
+* Ex. template('Hello, {{name}}', { name: 'ray' })
+* Ex. template('Hello, <name>', { name: 'ray' }, /<(.+?)>/g)
+*/
+const template = (str, data, regex = /\{\{(.+?)\}\}/g) => {
+	return Array.from(str.matchAll(regex)).reduce((acc, match) => {
+		return acc.replace(match[0], data[match[1]]);
+	}, str);
+};
+/**
+* Trims all prefix and suffix characters from the given
+* string. Like the builtin trim function but accepts
+* other characters you would like to trim and trims
+* multiple characters.
+*
+* ```typescript
+* trim('  hello ') // => 'hello'
+* trim('__hello__', '_') // => 'hello'
+* trim('/repos/:owner/:repo/', '/') // => 'repos/:owner/:repo'
+* trim('222222__hello__1111111', '12_') // => 'hello'
+* ```
+*/
+const trim = (str, charsToTrim = " ") => {
+	if (!str) return "";
+	const toTrim = charsToTrim.replace(/[\W]{1}/g, "\\$&");
+	const regex = new RegExp(`^[${toTrim}]+|[${toTrim}]+$`, "g");
+	return str.replace(regex, "");
+};
+
+//#endregion
+export { camel, capitalize, dash, pascal, snake, template, title, trim };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "solid-tiny-utils",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "description": "A collection of tiny utilities for SolidJS applications",
-  "main": "./dist/index.js",
+  "main": "./dist/index.mjs",
   "type": "module",
   "files": [
     "dist"
@@ -12,49 +12,52 @@
     "solid-js": "^1.9.7"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.2.2",
-    "@solidjs/router": "^0.15.3",
+    "@biomejs/biome": "2.3.10",
+    "@solidjs/router": "^0.15.4",
     "@solidjs/testing-library": "^0.8.10",
-    "@testing-library/jest-dom": "^6.6.4",
+    "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/user-event": "^14.6.1",
     "@types/culori": "^4.0.0",
-    "@types/node": "^24.2.1",
-    "@vitest/ui": "^3.2.4",
+    "@types/node": "^25.0.3",
+    "@typescript/native-preview": "7.0.0-dev.20251226.1",
+    "@vitest/ui": "^4.0.16",
     "bumpp": "^10.2.3",
     "culori": "^4.0.2",
-    "husky": "^9.1.7",
-    "jsdom": "^26.1.0",
-    "tsup": "^8.5.0",
-    "typescript": "^5.8.3",
-    "ultracite": "5.3.3",
+    "jsdom": "^27.3.0",
+    "solid-tiny-context": "0.2.3",
+    "tsdown": "^0.18.3",
+    "ultracite": "6.5.0",
     "unocss": "^66.3.3",
-    "vite": "^6.2.1",
+    "vite": "^7.3.0",
     "vite-plugin-solid": "^2.11.0",
-    "vite-plugin-solid-pages": "^0.3.4",
-    "vitest": "^3.2.4"
+    "vite-plugin-solid-pages": "^0.3.5",
+    "vitest": "^4.0.16"
   },
   "keywords": [
     "solidjs",
     "solid",
-    "utilities",
     "reactive",
     "typescript",
     "utils"
   ],
   "author": "",
   "license": "MIT",
-  "dependencies": {
-    "solid-tiny-context": "0.2.3"
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsdown",
     "dev": "vite -c ./playground/vite.config.ts",
     "test": "vitest --run",
     "clean": "rimraf dist node_modules pnpm-lock.yaml",
     "test:ui": "vitest --ui",
-    "lint": "pnpm dlx ultracite check",
-    "lint:fix": "pnpm dlx ultracite fix",
-    "type-check": "tsc --noEmit --skipLibCheck",
+    "lint": "pnpm dlx ultracite@latest check",
+    "lint:error": "pnpm dlx ultracite@latest check --diagnostic-level error",
+    "lint:fix": "pnpm dlx ultracite@latest fix",
+    "type-check": "tsgo --noEmit --skipLibCheck",
     "bump": "pnpm type-check && pnpm lint:fix && pnpm test && pnpm bumpp --no-push",
     "prepublish": "pnpm build"
   }

package/dist/chunk-4L6FK7MF.js

@@ -1,9 +0,0 @@
-// src/reactive/create-watch.ts
-import { createEffect, on } from "solid-js";
-function createWatch(targets, fn, opt) {
-  createEffect(on(targets, fn, opt));
-}
-
-export {
-  createWatch
-};

package/dist/chunk-6G7GFZV2.js

@@ -1,93 +0,0 @@
-// src/utils/is.ts
-import { isServer } from "solid-js/web";
-var isSymbol = (value) => {
-  return !!value && value.constructor === Symbol;
-};
-var isArray = Array.isArray;
-var isObject = (value) => {
-  return !!value && value.constructor === Object;
-};
-var isPrimitive = (value) => {
-  return value === void 0 || value === null || typeof value !== "object" && typeof value !== "function";
-};
-var isFn = (value) => {
-  return !!(value && value.constructor && value.call && value.apply);
-};
-var isString = (value) => {
-  return typeof value === "string" || value instanceof String;
-};
-var isInt = (value) => {
-  return isNumber(value) && value % 1 === 0;
-};
-var isFloat = (value) => {
-  return isNumber(value) && value % 1 !== 0;
-};
-var isNumber = (value) => {
-  try {
-    return Number(value) === value;
-  } catch {
-    return false;
-  }
-};
-var isDate = (value) => {
-  return Object.prototype.toString.call(value) === "[object Date]";
-};
-var isPromise = (value) => {
-  if (!value) {
-    return false;
-  }
-  if (!value.then) {
-    return false;
-  }
-  if (!isFn(value.then)) {
-    return false;
-  }
-  return true;
-};
-var isEmpty = (value) => {
-  if (value === true || value === false) {
-    return true;
-  }
-  if (value === null || value === void 0) {
-    return true;
-  }
-  if (isNumber(value)) {
-    return value === 0;
-  }
-  if (isDate(value)) {
-    return isNaN(value.getTime());
-  }
-  if (isFn(value)) {
-    return false;
-  }
-  if (isSymbol(value)) {
-    return false;
-  }
-  const length = value.length;
-  if (isNumber(length)) {
-    return length === 0;
-  }
-  const size = value.size;
-  if (isNumber(size)) {
-    return size === 0;
-  }
-  const keys = Object.keys(value).length;
-  return keys === 0;
-};
-var isClient = !isServer;
-
-export {
-  isSymbol,
-  isArray,
-  isObject,
-  isPrimitive,
-  isFn,
-  isString,
-  isInt,
-  isFloat,
-  isNumber,
-  isDate,
-  isPromise,
-  isEmpty,
-  isClient
-};

package/dist/chunk-6OVLJ45M.js

@@ -1,51 +0,0 @@
-import {
-  makeEventListener
-} from "./chunk-TGWWPUWD.js";
-import {
-  noop
-} from "./chunk-QPEF6LHH.js";
-import {
-  access
-} from "./chunk-YK5QQQ43.js";
-import {
-  createWatch
-} from "./chunk-4L6FK7MF.js";
-import {
-  clearArray
-} from "./chunk-BT47ISVC.js";
-import {
-  isArray
-} from "./chunk-6G7GFZV2.js";
-
-// src/event/create-event-listener.ts
-function createEventListener(...args) {
-  const target = args[0];
-  const events = args[1];
-  let listeners = args[2];
-  const options = args[3] ?? noop;
-  if (!isArray(listeners)) {
-    listeners = [listeners];
-  }
-  const cleanups = [];
-  const cleanup = () => {
-    for (const c of cleanups) {
-      c();
-    }
-    clearArray(cleanups);
-  };
-  createWatch(
-    () => [access(target), access(events), access(options)],
-    ([tars, evs, opts]) => {
-      cleanup();
-      if (!(tars && evs)) {
-        return;
-      }
-      cleanups.push(makeEventListener(tars, evs, listeners, opts));
-    }
-  );
-  return cleanup;
-}
-
-export {
-  createEventListener
-};

package/dist/chunk-ACZGS7DG.js

@@ -1,72 +0,0 @@
-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-BT47ISVC.js

@@ -1,36 +0,0 @@
-import {
-  isFn
-} from "./chunk-6G7GFZV2.js";
-
-// src/utils/array.ts
-var iterate = (count, func, initValue) => {
-  let value = initValue;
-  for (let i = 1; i <= count; i++) {
-    value = func(value, i);
-  }
-  return value;
-};
-function* range(startOrLength, end, valueOrMapper = (i) => i, step = 1) {
-  const mapper = isFn(valueOrMapper) ? valueOrMapper : () => valueOrMapper;
-  const start = end ? startOrLength : 0;
-  const final = end ?? startOrLength;
-  for (let i = start; i <= final; i += step) {
-    yield mapper(i);
-    if (i + step > final) {
-      break;
-    }
-  }
-}
-var list = (startOrLength, end, valueOrMapper, step) => {
-  return Array.from(range(startOrLength, end, valueOrMapper, step));
-};
-function clearArray(arr) {
-  arr.length = 0;
-}
-
-export {
-  iterate,
-  range,
-  list,
-  clearArray
-};

package/dist/chunk-II6INKPZ.js

@@ -1,8 +0,0 @@
-// src/jsx/attrs.ts
-function dataIf(show) {
-  return show ? "" : void 0;
-}
-
-export {
-  dataIf
-};