@luxass/utils 1.2.1 → 1.4.0

package/dist/number.d.cts

@@ -1,22 +1,2 @@
-/**
- * Clamp a value between a min and max value.
- * @param {number} value
- * @param {number} min
- * @param {number} max
- * @returns {number} the clamped value
- *
- * @example
- * ```ts
- * clamp(5, 0, 10)
- * // 5
- *
- * clamp(5, 10, 20)
- * // 10
- *
- * clamp(5, 0, 4)
- * // 4
- * ```
- */
-declare function clamp(value: number, min: number, max: number): number;
-
-export { clamp };
+import { clamp } from "./number.d-C1FAMQlq.cjs";
+export { clamp };

package/dist/number.d.ts

@@ -1,22 +1,2 @@
-/**
- * Clamp a value between a min and max value.
- * @param {number} value
- * @param {number} min
- * @param {number} max
- * @returns {number} the clamped value
- *
- * @example
- * ```ts
- * clamp(5, 0, 10)
- * // 5
- *
- * clamp(5, 10, 20)
- * // 10
- *
- * clamp(5, 0, 4)
- * // 4
- * ```
- */
-declare function clamp(value: number, min: number, max: number): number;
-
-export { clamp };
+import { clamp$1 as clamp } from "./number.d-C2Xuq3Is.js";
+export { clamp };

package/dist/number.js

@@ -0,0 +1,3 @@
+import { clamp } from "./number-Bfr1z0Nr.js";
+
+export { clamp };

package/dist/string-C8IOUSBw.js

@@ -0,0 +1,117 @@
+//#region src/string.ts
+const FULL_WHITESPACE_RE = /^\s*$/;
+/**
+* Capitalizes the first character of a string and converts the rest to lowercase
+* @param {string} str - The string to capitalize
+* @returns {string} The capitalized string
+* @example
+* ```ts
+* capitalize("hello") // "Hello"
+* capitalize("hELLO") // "Hello"
+* capitalize("") // ""
+* ```
+*/
+function capitalize(str) {
+	if (!str) return "";
+	return str[0].toUpperCase() + str.slice(1).toLowerCase();
+}
+/**
+* Converts a string to camelCase format
+* @param {string} str - The string to convert to camelCase
+* @returns {string} The string in camelCase format
+* @example
+* ```ts
+* toCamelCase("hello world") // "helloWorld"
+* toCamelCase("hello-world") // "helloWorld"
+* toCamelCase("hello_world") // "helloWorld"
+* toCamelCase("HelloWorld") // "helloWorld"
+* toCamelCase("") // ""
+* ```
+*/
+function toCamelCase(str) {
+	if (!str) return "";
+	str = str.trim().replace(/\s+/g, " ");
+	const words = str.split(/[\s\-_]+/);
+	if (words.length === 1 && words[0]?.length === 1) return words[0].toLowerCase();
+	let result = words[0]?.toLowerCase() || "";
+	for (let i = 1; i < words.length; i++) {
+		const word = words[i];
+		if (!word) continue;
+		const hasCamelCase = word.match(/[a-z][A-Z]/g);
+		result += hasCamelCase ? word.charAt(0).toUpperCase() + word.slice(1) : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+	}
+	return result;
+}
+/**
+* Converts a string to kebab-case format
+* @param {string} str - The string to convert to kebab-case
+* @returns {string} The string in kebab-case format
+* @example
+* ```ts
+* toKebabCase("hello world") // "hello-world"
+* toKebabCase("helloWorld") // "hello-world"
+* toKebabCase("hello_world") // "hello-world"
+* toKebabCase("HelloWorld") // "hello-world"
+* toKebabCase("") // ""
+* ```
+*/
+function toKebabCase(str) {
+	if (!str) return "";
+	return str.trim().replace(/_/g, "-").replace(/\s+/g, " ").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/\s+/g, "-").replace(/-+/g, "-").toLowerCase();
+}
+/**
+* Converts a string to PascalCase format
+* @param {string} str - The string to convert to PascalCase
+* @returns {string} The string in PascalCase format
+* @example
+* ```ts
+* toPascalCase("hello world") // "HelloWorld"
+* toPascalCase("hello-world") // "HelloWorld"
+* toPascalCase("hello_world") // "HelloWorld"
+* toPascalCase("helloWorld") // "HelloWorld"
+* toPascalCase("") // ""
+* ```
+*/
+function toPascalCase(str) {
+	if (!str) return "";
+	return str.trim().replace(/[_-]+/g, " ").replace(/\s+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z])([A-Z][a-z])/g, "$1 $2").replace(/(\d+)([a-z])/gi, "$1 $2").split(" ").filter((word) => word.length > 0).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+/**
+* Converts a string to snake_case format
+* @param {string} str - The string to convert to snake_case
+* @returns {string} The string in snake_case format
+* @example
+* ```ts
+* toSnakeCase("hello world") // "hello_world"
+* toSnakeCase("helloWorld") // "hello_world"
+* toSnakeCase("hello-world") // "hello_world"
+* toSnakeCase("HelloWorld") // "hello_world"
+* toSnakeCase("") // ""
+* ```
+*/
+function toSnakeCase(str) {
+	if (!str) return "";
+	return str.trim().replace(/-/g, "_").replace(/\s+/g, " ").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/\s+/g, "_").replace(/_+/g, "_").toLowerCase();
+}
+function dedent(strings, ...values) {
+	const raw = typeof strings === "string" ? [strings] : strings.raw;
+	let result = "";
+	for (let i = 0; i < raw.length; i++) {
+		const next = raw[i];
+		result += next;
+		if (i < values.length) result += values[i];
+	}
+	const lines = result.split("\n");
+	const whitespaceLines = lines.map((line) => FULL_WHITESPACE_RE.test(line));
+	const commonIndent = lines.reduce((min, line, idx) => {
+		if (whitespaceLines[idx]) return min;
+		const indent = line.match(/^\s*/)?.[0].length;
+		return indent === void 0 ? min : Math.min(min, indent);
+	}, Number.POSITIVE_INFINITY);
+	const firstNonWhitespaceLine = whitespaceLines.findIndex((isWhitespace) => !isWhitespace);
+	const lastNonWhitespaceLine = whitespaceLines.lastIndexOf(false);
+	return lines.slice(firstNonWhitespaceLine >= 0 ? firstNonWhitespaceLine : 0, lastNonWhitespaceLine >= 0 ? lastNonWhitespaceLine + 1 : lines.length).map((line) => line.slice(commonIndent)).join("\n");
+}
+
+//#endregion
+export { capitalize, dedent, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/string-CkqQ4Tys.cjs

@@ -0,0 +1,154 @@
+"use strict";
+
+//#region src/string.ts
+const FULL_WHITESPACE_RE = /^\s*$/;
+/**
+* Capitalizes the first character of a string and converts the rest to lowercase
+* @param {string} str - The string to capitalize
+* @returns {string} The capitalized string
+* @example
+* ```ts
+* capitalize("hello") // "Hello"
+* capitalize("hELLO") // "Hello"
+* capitalize("") // ""
+* ```
+*/
+function capitalize(str) {
+	if (!str) return "";
+	return str[0].toUpperCase() + str.slice(1).toLowerCase();
+}
+/**
+* Converts a string to camelCase format
+* @param {string} str - The string to convert to camelCase
+* @returns {string} The string in camelCase format
+* @example
+* ```ts
+* toCamelCase("hello world") // "helloWorld"
+* toCamelCase("hello-world") // "helloWorld"
+* toCamelCase("hello_world") // "helloWorld"
+* toCamelCase("HelloWorld") // "helloWorld"
+* toCamelCase("") // ""
+* ```
+*/
+function toCamelCase(str) {
+	if (!str) return "";
+	str = str.trim().replace(/\s+/g, " ");
+	const words = str.split(/[\s\-_]+/);
+	if (words.length === 1 && words[0]?.length === 1) return words[0].toLowerCase();
+	let result = words[0]?.toLowerCase() || "";
+	for (let i = 1; i < words.length; i++) {
+		const word = words[i];
+		if (!word) continue;
+		const hasCamelCase = word.match(/[a-z][A-Z]/g);
+		result += hasCamelCase ? word.charAt(0).toUpperCase() + word.slice(1) : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+	}
+	return result;
+}
+/**
+* Converts a string to kebab-case format
+* @param {string} str - The string to convert to kebab-case
+* @returns {string} The string in kebab-case format
+* @example
+* ```ts
+* toKebabCase("hello world") // "hello-world"
+* toKebabCase("helloWorld") // "hello-world"
+* toKebabCase("hello_world") // "hello-world"
+* toKebabCase("HelloWorld") // "hello-world"
+* toKebabCase("") // ""
+* ```
+*/
+function toKebabCase(str) {
+	if (!str) return "";
+	return str.trim().replace(/_/g, "-").replace(/\s+/g, " ").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/\s+/g, "-").replace(/-+/g, "-").toLowerCase();
+}
+/**
+* Converts a string to PascalCase format
+* @param {string} str - The string to convert to PascalCase
+* @returns {string} The string in PascalCase format
+* @example
+* ```ts
+* toPascalCase("hello world") // "HelloWorld"
+* toPascalCase("hello-world") // "HelloWorld"
+* toPascalCase("hello_world") // "HelloWorld"
+* toPascalCase("helloWorld") // "HelloWorld"
+* toPascalCase("") // ""
+* ```
+*/
+function toPascalCase(str) {
+	if (!str) return "";
+	return str.trim().replace(/[_-]+/g, " ").replace(/\s+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z])([A-Z][a-z])/g, "$1 $2").replace(/(\d+)([a-z])/gi, "$1 $2").split(" ").filter((word) => word.length > 0).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+/**
+* Converts a string to snake_case format
+* @param {string} str - The string to convert to snake_case
+* @returns {string} The string in snake_case format
+* @example
+* ```ts
+* toSnakeCase("hello world") // "hello_world"
+* toSnakeCase("helloWorld") // "hello_world"
+* toSnakeCase("hello-world") // "hello_world"
+* toSnakeCase("HelloWorld") // "hello_world"
+* toSnakeCase("") // ""
+* ```
+*/
+function toSnakeCase(str) {
+	if (!str) return "";
+	return str.trim().replace(/-/g, "_").replace(/\s+/g, " ").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/\s+/g, "_").replace(/_+/g, "_").toLowerCase();
+}
+function dedent(strings, ...values) {
+	const raw = typeof strings === "string" ? [strings] : strings.raw;
+	let result = "";
+	for (let i = 0; i < raw.length; i++) {
+		const next = raw[i];
+		result += next;
+		if (i < values.length) result += values[i];
+	}
+	const lines = result.split("\n");
+	const whitespaceLines = lines.map((line) => FULL_WHITESPACE_RE.test(line));
+	const commonIndent = lines.reduce((min, line, idx) => {
+		if (whitespaceLines[idx]) return min;
+		const indent = line.match(/^\s*/)?.[0].length;
+		return indent === void 0 ? min : Math.min(min, indent);
+	}, Number.POSITIVE_INFINITY);
+	const firstNonWhitespaceLine = whitespaceLines.findIndex((isWhitespace) => !isWhitespace);
+	const lastNonWhitespaceLine = whitespaceLines.lastIndexOf(false);
+	return lines.slice(firstNonWhitespaceLine >= 0 ? firstNonWhitespaceLine : 0, lastNonWhitespaceLine >= 0 ? lastNonWhitespaceLine + 1 : lines.length).map((line) => line.slice(commonIndent)).join("\n");
+}
+
+//#endregion
+Object.defineProperty(exports, 'capitalize', {
+  enumerable: true,
+  get: function () {
+    return capitalize;
+  }
+});
+Object.defineProperty(exports, 'dedent', {
+  enumerable: true,
+  get: function () {
+    return dedent;
+  }
+});
+Object.defineProperty(exports, 'toCamelCase', {
+  enumerable: true,
+  get: function () {
+    return toCamelCase;
+  }
+});
+Object.defineProperty(exports, 'toKebabCase', {
+  enumerable: true,
+  get: function () {
+    return toKebabCase;
+  }
+});
+Object.defineProperty(exports, 'toPascalCase', {
+  enumerable: true,
+  get: function () {
+    return toPascalCase;
+  }
+});
+Object.defineProperty(exports, 'toSnakeCase', {
+  enumerable: true,
+  get: function () {
+    return toSnakeCase;
+  }
+});

package/dist/string.cjs

@@ -1,34 +1,8 @@
-'use strict';
+const require_string = require('./string-CkqQ4Tys.cjs');
 
-// src/string.ts
-function capitalize(str) {
-  if (typeof str !== "string") throw new TypeError("Expected a string");
-  if (str.trim().length === 0) return "";
-  return str[0].toUpperCase() + str.slice(1).toLowerCase();
-}
-function toCamelCase(str) {
-  if (typeof str !== "string") throw new TypeError("Expected a string");
-  if (str.trim().length === 0) return "";
-  return str.toLowerCase().replace(/[-_](.)/g, (_, c) => c.toUpperCase());
-}
-function toKebabCase(str) {
-  if (typeof str !== "string") throw new TypeError("Expected a string");
-  if (str.trim().length === 0) return "";
-  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
-}
-function toPascalCase(str) {
-  if (typeof str !== "string") throw new TypeError("Expected a string");
-  if (str.trim().length === 0) return "";
-  return str.toLowerCase().replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^[a-z]/, (c) => c.toUpperCase());
-}
-function toSnakeCase(str) {
-  if (typeof str !== "string") throw new TypeError("Expected a string");
-  if (str.trim().length === 0) return "";
-  return str.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
-}
-
-exports.capitalize = capitalize;
-exports.toCamelCase = toCamelCase;
-exports.toKebabCase = toKebabCase;
-exports.toPascalCase = toPascalCase;
-exports.toSnakeCase = toSnakeCase;
+exports.capitalize = require_string.capitalize
+exports.dedent = require_string.dedent
+exports.toCamelCase = require_string.toCamelCase
+exports.toKebabCase = require_string.toKebabCase
+exports.toPascalCase = require_string.toPascalCase
+exports.toSnakeCase = require_string.toSnakeCase

package/dist/string.d-DbrXP95T.d.cts

@@ -0,0 +1,90 @@
+//#region src/string.d.ts
+/**
+* Capitalizes the first character of a string and converts the rest to lowercase
+* @param {string} str - The string to capitalize
+* @returns {string} The capitalized string
+* @example
+* ```ts
+* capitalize("hello") // "Hello"
+* capitalize("hELLO") // "Hello"
+* capitalize("") // ""
+* ```
+*/declare function capitalize(str: string): string;
+
+/**
+* Converts a string to camelCase format
+* @param {string} str - The string to convert to camelCase
+* @returns {string} The string in camelCase format
+* @example
+* ```ts
+* toCamelCase("hello world") // "helloWorld"
+* toCamelCase("hello-world") // "helloWorld"
+* toCamelCase("hello_world") // "helloWorld"
+* toCamelCase("HelloWorld") // "helloWorld"
+* toCamelCase("") // ""
+* ```
+*/
+declare function toCamelCase(str: string): string;
+
+/**
+* Converts a string to kebab-case format
+* @param {string} str - The string to convert to kebab-case
+* @returns {string} The string in kebab-case format
+* @example
+* ```ts
+* toKebabCase("hello world") // "hello-world"
+* toKebabCase("helloWorld") // "hello-world"
+* toKebabCase("hello_world") // "hello-world"
+* toKebabCase("HelloWorld") // "hello-world"
+* toKebabCase("") // ""
+* ```
+*/
+declare function toKebabCase(str: string): string;
+
+/**
+* Converts a string to PascalCase format
+* @param {string} str - The string to convert to PascalCase
+* @returns {string} The string in PascalCase format
+* @example
+* ```ts
+* toPascalCase("hello world") // "HelloWorld"
+* toPascalCase("hello-world") // "HelloWorld"
+* toPascalCase("hello_world") // "HelloWorld"
+* toPascalCase("helloWorld") // "HelloWorld"
+* toPascalCase("") // ""
+* ```
+*/
+declare function toPascalCase(str: string): string;
+
+/**
+* Converts a string to snake_case format
+* @param {string} str - The string to convert to snake_case
+* @returns {string} The string in snake_case format
+* @example
+* ```ts
+* toSnakeCase("hello world") // "hello_world"
+* toSnakeCase("helloWorld") // "hello_world"
+* toSnakeCase("hello-world") // "hello_world"
+* toSnakeCase("HelloWorld") // "hello_world"
+* toSnakeCase("") // ""
+* ```
+*/
+declare function toSnakeCase(str: string): string;
+
+/**
+* Removes leading and trailing whitespace from each line of a string
+* @param {TemplateStringsArray | string} literals - The string to dedent
+* @returns {string} The dedented string
+* @example ```ts
+dedent`
+This is a test.
+This is another line.
+`
+// "This is a test.\nThis is another line."
+```
+*/
+declare function dedent(literals: string): string;
+declare function dedent(strings: TemplateStringsArray, ...values: unknown[]): string;
+
+//#endregion
+export { capitalize, dedent, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/string.d-Dv6EVJz4.d.ts

@@ -0,0 +1,90 @@
+//#region src/string.d.ts
+/**
+* Capitalizes the first character of a string and converts the rest to lowercase
+* @param {string} str - The string to capitalize
+* @returns {string} The capitalized string
+* @example
+* ```ts
+* capitalize("hello") // "Hello"
+* capitalize("hELLO") // "Hello"
+* capitalize("") // ""
+* ```
+*/declare function capitalize(str: string): string;
+
+/**
+* Converts a string to camelCase format
+* @param {string} str - The string to convert to camelCase
+* @returns {string} The string in camelCase format
+* @example
+* ```ts
+* toCamelCase("hello world") // "helloWorld"
+* toCamelCase("hello-world") // "helloWorld"
+* toCamelCase("hello_world") // "helloWorld"
+* toCamelCase("HelloWorld") // "helloWorld"
+* toCamelCase("") // ""
+* ```
+*/
+declare function toCamelCase(str: string): string;
+
+/**
+* Converts a string to kebab-case format
+* @param {string} str - The string to convert to kebab-case
+* @returns {string} The string in kebab-case format
+* @example
+* ```ts
+* toKebabCase("hello world") // "hello-world"
+* toKebabCase("helloWorld") // "hello-world"
+* toKebabCase("hello_world") // "hello-world"
+* toKebabCase("HelloWorld") // "hello-world"
+* toKebabCase("") // ""
+* ```
+*/
+declare function toKebabCase(str: string): string;
+
+/**
+* Converts a string to PascalCase format
+* @param {string} str - The string to convert to PascalCase
+* @returns {string} The string in PascalCase format
+* @example
+* ```ts
+* toPascalCase("hello world") // "HelloWorld"
+* toPascalCase("hello-world") // "HelloWorld"
+* toPascalCase("hello_world") // "HelloWorld"
+* toPascalCase("helloWorld") // "HelloWorld"
+* toPascalCase("") // ""
+* ```
+*/
+declare function toPascalCase(str: string): string;
+
+/**
+* Converts a string to snake_case format
+* @param {string} str - The string to convert to snake_case
+* @returns {string} The string in snake_case format
+* @example
+* ```ts
+* toSnakeCase("hello world") // "hello_world"
+* toSnakeCase("helloWorld") // "hello_world"
+* toSnakeCase("hello-world") // "hello_world"
+* toSnakeCase("HelloWorld") // "hello_world"
+* toSnakeCase("") // ""
+* ```
+*/
+declare function toSnakeCase(str: string): string;
+
+/**
+* Removes leading and trailing whitespace from each line of a string
+* @param {TemplateStringsArray | string} literals - The string to dedent
+* @returns {string} The dedented string
+* @example ```ts
+dedent`
+This is a test.
+This is another line.
+`
+// "This is a test.\nThis is another line."
+```
+*/
+declare function dedent(literals: string): string;
+declare function dedent(strings: TemplateStringsArray, ...values: unknown[]): string;
+
+//#endregion
+export { capitalize as capitalize$1, dedent as dedent$1, toCamelCase as toCamelCase$1, toKebabCase as toKebabCase$1, toPascalCase as toPascalCase$1, toSnakeCase as toSnakeCase$1 };

package/dist/string.d.cts

@@ -1,79 +1,2 @@
-/**
- * First letter uppercase, other lowercase
- * @param {string} str - The string to capitalize
- * @returns {string} The capitalized string
- * @throws {TypeError} If `str` is not string
- *
- * @example
- * ```ts
- * capitalize("hello")
- * // "Hello"
- * ```
- */
-declare function capitalize(str: string): string;
-/**
- * Converts a string to camel case.
- * @param {string} str - The input string to be converted.
- * @returns {string} The camel cased string.
- * @throws {TypeError} If the input is not a string.
- *
- * @example
- * ```ts
- * toCamelCase("some_text_here")
- * // "someTextHere"
- *
- * toCamelCase("another-Example")
- * // "anotherExample"
- * ```
- */
-declare function toCamelCase(str: string): string;
-/**
- * Converts a string to kebab case.
- * @param {string} str - The input string to be converted.
- * @returns {string} The kebab cased string.
- * @throws {TypeError} If the input is not a string.
- *
- * @example
- * ```ts
- * toKebabCase("someTextHere")
- * // "some-text-here"
- *
- * toKebabCase("anotherExample")
- * // "another-example"
- * ```
- */
-declare function toKebabCase(str: string): string;
-/**
- * Converts a string to pascal case.
- * @param {string} str - The input string to be converted.
- * @returns {string} The pascal cased string.
- * @throws {TypeError} If the input is not a string.
- *
- * @example
- * ```ts
- * toPascalCase("some_text_here")
- * // "SomeTextHere"
- *
- * toPascalCase("another-Example")
- * // "AnotherExample"
- * ```
- */
-declare function toPascalCase(str: string): string;
-/**
- * Converts a string to snake case.
- * @param {string} str - The input string to be converted.
- * @returns {string} The snake cased string.
- * @throws {TypeError} If the input is not a string.
- *
- * @example
- * ```ts
- * toSnakeCase("someTextHere")
- * // "some_text_here"
- *
- * toSnakeCase("anotherExample")
- * // "another_example"
- * ```
- */
-declare function toSnakeCase(str: string): string;
-
-export { capitalize, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };
+import { capitalize, dedent, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string.d-DbrXP95T.cjs";
+export { capitalize, dedent, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };