solid-tiny-utils 0.7.0 → 0.8.0

package/dist/utils/is.mjs

@@ -0,0 +1,72 @@
+import { isServer } from "solid-js/web";
+
+//#region src/utils/is.ts
+/** biome-ignore-all lint/suspicious/noExplicitAny: need any */
+const isSymbol = (value) => {
+	return !!value && value.constructor === Symbol;
+};
+const isArray = Array.isArray;
+const isObject = (value) => {
+	return !!value && value.constructor === Object;
+};
+/**
+* Checks if the given value is primitive.
+*
+* Primitive Types: number , string , boolean , symbol, bigint, undefined, null
+*
+* @param {*} value value to check
+* @returns {boolean} result
+*/
+const isPrimitive = (value) => {
+	return value === void 0 || value === null || typeof value !== "object" && typeof value !== "function";
+};
+const isFn = (value) => {
+	return !!(value && value.constructor && value.call && value.apply);
+};
+const isString = (value) => {
+	return typeof value === "string" || value instanceof String;
+};
+const isInt = (value) => {
+	return isNumber(value) && value % 1 === 0;
+};
+const isFloat = (value) => {
+	return isNumber(value) && value % 1 !== 0;
+};
+const isNumber = (value) => {
+	try {
+		return Number(value) === value;
+	} catch {
+		return false;
+	}
+};
+const isDate = (value) => {
+	return Object.prototype.toString.call(value) === "[object Date]";
+};
+/**
+* This is really a _best guess_ promise checking. You
+* should probably use Promise.resolve(value) to be 100%
+* sure you're handling it correctly.
+*/
+const isPromise = (value) => {
+	if (!value) return false;
+	if (!value.then) return false;
+	if (!isFn(value.then)) return false;
+	return true;
+};
+const 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;
+	return Object.keys(value).length === 0;
+};
+const isClient = !isServer;
+
+//#endregion
+export { isArray, isClient, isDate, isEmpty, isFloat, isFn, isInt, isNumber, isObject, isPrimitive, isPromise, isString, isSymbol };

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

@@ -1,3 +1,4 @@
+//#region src/utils/number.d.ts
 /**
  * Returns the smallest of the given numbers.
  *
@@ -109,5 +110,5 @@ declare function inRange(x: number, minimum?: number, maximum?: number, inclusiv
  * ```
  */
 declare function toHex(x: number, pad?: number): string;
-
-export { clamp, inRange, max, min, toHex };
+//#endregion
+export { clamp, inRange, max, min, toHex };

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.0",
+  "version": "0.8.0",
   "description": "A collection of tiny utilities for SolidJS applications",
-  "main": "./dist/index.js",
+  "main": "./dist/index.mjs",
   "type": "module",
   "files": [
     "dist"
@@ -12,48 +12,51 @@
     "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",
+    "@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",
+    "jsdom": "^27.3.0",
+    "tsdown": "^0.18.3",
     "typescript": "^5.8.3",
-    "ultracite": "5.3.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"
+    "vitest": "^4.0.16",
+    "solid-tiny-context": "0.2.3"
   },
   "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",
+    "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": "tsc --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
-};