@luxass/utils 2.5.1 → 2.6.1

package/dist/guards.d.ts

@@ -1,2 +1,2 @@
-import { isNotNull, isNotNullish, isNotUndefined, isTruthy } from "./guards-x9QZDUSt.js";
+import { isNotNull, isNotNullish, isNotUndefined, isTruthy } from "./guards-SWdmRZ5e.js";
 export { isNotNull, isNotNullish, isNotUndefined, isTruthy };

package/dist/index.d.ts

@@ -1,8 +1,9 @@
-import { isNotNull, isNotNullish, isNotUndefined, isTruthy } from "./guards-x9QZDUSt.js";
-import { clamp } from "./number-DzUC7V5F.js";
-import { getChangedKeys, getOwnProperty, hasOwnProperty, omit } from "./object-BT3S70pM.js";
-import { appendTrailingSlash, capitalize, dedent, dedentRaw, formatStr, prependLeadingSlash, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase, trimLeadingSlash, trimTrailingSlash } from "./string-DDSo2EBf.js";
-import { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature } from "./types-DCrM3M9i.js";
+import { isNotNull, isNotNullish, isNotUndefined, isTruthy } from "./guards-SWdmRZ5e.js";
+import { clamp } from "./number-Culbli-Y.js";
+import { getChangedKeys, getOwnProperty, hasOwnProperty, omit } from "./object-BtzfqVfB.js";
+import { appendTrailingSlash, prependLeadingSlash, trimLeadingSlash, trimTrailingSlash } from "./path-CFkUYi0a.js";
+import { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-BgrFQWVx.js";
+import { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature, SafeOmit } from "./types-DwW0ucVr.js";
 import pRetry from "p-retry";
 
 //#region src/common.d.ts
@@ -21,4 +22,4 @@ declare class InvariantError extends Error {
  */
 declare function invariant(predicate: unknown, message: string, ...positionals: unknown[]): asserts predicate;
 //#endregion
-export { ElementOf, InferArguments, InvariantError, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature, appendTrailingSlash, capitalize, clamp, dedent, dedentRaw, formatStr, getChangedKeys, getOwnProperty, hasOwnProperty, invariant, isNotNull, isNotNullish, isNotUndefined, isTruthy, omit, prependLeadingSlash, pRetry as promiseRetry, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase, trimLeadingSlash, trimTrailingSlash };
+export { type ElementOf, type InferArguments, InvariantError, type MaybeArray, type MaybePromise, type Nullable, type Nullish, type Prettify, type RemoveIndexSignature, type SafeOmit, appendTrailingSlash, capitalize, clamp, dedent, dedentRaw, formatStr, getChangedKeys, getOwnProperty, hasOwnProperty, invariant, isNotNull, isNotNullish, isNotUndefined, isTruthy, omit, prependLeadingSlash, pRetry as promiseRetry, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase, trimLeadingSlash, trimTrailingSlash };

package/dist/index.js

@@ -1,7 +1,8 @@
 import { isNotNull, isNotNullish, isNotUndefined, isTruthy } from "./guards-O1HGJraI.js";
-import { appendTrailingSlash, capitalize, dedent, dedentRaw, formatStr, prependLeadingSlash, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase, trimLeadingSlash, trimTrailingSlash } from "./string-DCBui1sH.js";
+import { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-BlwTLoKD.js";
 import { clamp } from "./number-BS9T5WGO.js";
 import { getChangedKeys, getOwnProperty, hasOwnProperty, omit } from "./object-CyGLe77G.js";
+import { appendTrailingSlash, prependLeadingSlash, trimLeadingSlash, trimTrailingSlash } from "./path-a1A1qAWN.js";
 import pRetry from "p-retry";
 
 //#region src/common.ts

package/dist/number.d.ts

@@ -1,2 +1,2 @@
-import { clamp } from "./number-DzUC7V5F.js";
+import { clamp } from "./number-Culbli-Y.js";
 export { clamp };

package/dist/object.d.ts

@@ -1,2 +1,2 @@
-import { getChangedKeys, getOwnProperty, hasOwnProperty, omit } from "./object-BT3S70pM.js";
+import { getChangedKeys, getOwnProperty, hasOwnProperty, omit } from "./object-BtzfqVfB.js";
 export { getChangedKeys, getOwnProperty, hasOwnProperty, omit };

package/dist/path-CFkUYi0a.d.ts

@@ -0,0 +1,100 @@
+//#region src/path.d.ts
+/**
+ * Removes trailing slashes from a string
+ * @param {string} path - The string to remove trailing slashes from
+ * @returns {string} The string with trailing slashes removed
+ *
+ * @example
+ * ```ts
+ * import { trimTrailingSlash } from "@luxass/utils/path";
+ *
+ * trimTrailingSlash("path/to/file/") // "path/to/file"
+ * trimTrailingSlash("path/to/file///") // "path/to/file"
+ * trimTrailingSlash("path/to/file") // "path/to/file"
+ * trimTrailingSlash("") // ""
+ * ```
+ */
+declare function trimTrailingSlash(path: string | undefined): string;
+/**
+ * Removes leading slashes from a string
+ * @param {string} path - The string to remove leading slashes from
+ * @returns {string} The string with leading slashes removed
+ *
+ * @example
+ * ```ts
+ * import { trimLeadingSlash } from "@luxass/utils/path";
+ *
+ * trimLeadingSlash("/path/to/file") // "path/to/file"
+ * trimLeadingSlash("///path/to/file") // "path/to/file"
+ * trimLeadingSlash("path/to/file") // "path/to/file"
+ * trimLeadingSlash("") // ""
+ * ```
+ */
+declare function trimLeadingSlash(path: string | undefined): string;
+/**
+ * Ensures a string ends with a trailing slash
+ * @param {string} path - The string to append a trailing slash to
+ * @returns {string} The string with a trailing slash appended if not already present
+ *
+ * @example
+ * ```ts
+ * import { appendTrailingSlash } from "@luxass/utils/path";
+ *
+ * appendTrailingSlash("path/to/file") // "path/to/file/"
+ * appendTrailingSlash("path/to/file/") // "path/to/file/"
+ * appendTrailingSlash("") // ""
+ * ```
+ */
+declare function appendTrailingSlash(path: string | undefined): string;
+/**
+ * Ensures a string starts with a leading slash
+ * @param {string} path - The string to prepend a leading slash to
+ * @returns {string} The string with a leading slash prepended if not already present
+ *
+ * @example
+ * ```ts
+ * import { prependLeadingSlash } from "@luxass/utils/path";
+ *
+ * prependLeadingSlash("path/to/file") // "/path/to/file"
+ * prependLeadingSlash("/path/to/file") // "/path/to/file"
+ * prependLeadingSlash("") // ""
+ * ```
+ */
+declare function prependLeadingSlash(path: string | undefined): string;
+/**
+ * Joins URL paths together, handling trailing and leading slashes appropriately
+ * @param {string} base - The base URL path
+ * @param {...string} segments - Additional URL segments to join
+ * @returns {string} The joined URL path
+ *
+ * @example
+ * ```ts
+ * import { joinURL } from "@luxass/utils/path";
+ *
+ * // Basic path joining
+ * joinURL("api", "users") // "api/users"
+ * joinURL("api/", "users") // "api/users"
+ * joinURL("api", "/users") // "api/users"
+ * joinURL("api/", "/users") // "api/users"
+ *
+ * // URL joining with protocol
+ * joinURL("https://api.example.com", "v1/users") // "https://api.example.com/v1/users"
+ * joinURL("https://api.example.com/", "/v1/users") // "https://api.example.com/v1/users"
+ *
+ * // Multiple slash normalization
+ * joinURL("api//v1/", "//users///") // "api/v1/users/"
+ * joinURL("base///", "///path") // "base/path"
+ *
+ * // Root path handling
+ * joinURL("/", "users") // "/users"
+ * joinURL("api", "/") // "api/"
+ *
+ * // Empty and undefined handling
+ * joinURL("", "users") // "users"
+ * joinURL("api", "") // "api"
+ * joinURL("", "") // "/"
+ * ```
+ */
+declare function joinURL(base: string, ...segments: string[]): string;
+//#endregion
+export { appendTrailingSlash, joinURL, prependLeadingSlash, trimLeadingSlash, trimTrailingSlash };

package/dist/path-a1A1qAWN.js

@@ -0,0 +1,131 @@
+//#region src/path.ts
+/**
+* Removes trailing slashes from a string
+* @param {string} path - The string to remove trailing slashes from
+* @returns {string} The string with trailing slashes removed
+*
+* @example
+* ```ts
+* import { trimTrailingSlash } from "@luxass/utils/path";
+*
+* trimTrailingSlash("path/to/file/") // "path/to/file"
+* trimTrailingSlash("path/to/file///") // "path/to/file"
+* trimTrailingSlash("path/to/file") // "path/to/file"
+* trimTrailingSlash("") // ""
+* ```
+*/
+function trimTrailingSlash(path) {
+	if (!path || path === "/") return "/";
+	return path.replace(/\/+$/, "");
+}
+/**
+* Removes leading slashes from a string
+* @param {string} path - The string to remove leading slashes from
+* @returns {string} The string with leading slashes removed
+*
+* @example
+* ```ts
+* import { trimLeadingSlash } from "@luxass/utils/path";
+*
+* trimLeadingSlash("/path/to/file") // "path/to/file"
+* trimLeadingSlash("///path/to/file") // "path/to/file"
+* trimLeadingSlash("path/to/file") // "path/to/file"
+* trimLeadingSlash("") // ""
+* ```
+*/
+function trimLeadingSlash(path) {
+	if (!path || path === "/") return "/";
+	return path.replace(/^\/+/, "");
+}
+/**
+* Ensures a string ends with a trailing slash
+* @param {string} path - The string to append a trailing slash to
+* @returns {string} The string with a trailing slash appended if not already present
+*
+* @example
+* ```ts
+* import { appendTrailingSlash } from "@luxass/utils/path";
+*
+* appendTrailingSlash("path/to/file") // "path/to/file/"
+* appendTrailingSlash("path/to/file/") // "path/to/file/"
+* appendTrailingSlash("") // ""
+* ```
+*/
+function appendTrailingSlash(path) {
+	if (!path || path === "/") return "/";
+	return path.endsWith("/") ? path : `${path}/`;
+}
+/**
+* Ensures a string starts with a leading slash
+* @param {string} path - The string to prepend a leading slash to
+* @returns {string} The string with a leading slash prepended if not already present
+*
+* @example
+* ```ts
+* import { prependLeadingSlash } from "@luxass/utils/path";
+*
+* prependLeadingSlash("path/to/file") // "/path/to/file"
+* prependLeadingSlash("/path/to/file") // "/path/to/file"
+* prependLeadingSlash("") // ""
+* ```
+*/
+function prependLeadingSlash(path) {
+	if (!path || path === "/") return "/";
+	return path[0] === "/" ? path : `/${path}`;
+}
+/**
+* Joins URL paths together, handling trailing and leading slashes appropriately
+* @param {string} base - The base URL path
+* @param {...string} segments - Additional URL segments to join
+* @returns {string} The joined URL path
+*
+* @example
+* ```ts
+* import { joinURL } from "@luxass/utils/path";
+*
+* // Basic path joining
+* joinURL("api", "users") // "api/users"
+* joinURL("api/", "users") // "api/users"
+* joinURL("api", "/users") // "api/users"
+* joinURL("api/", "/users") // "api/users"
+*
+* // URL joining with protocol
+* joinURL("https://api.example.com", "v1/users") // "https://api.example.com/v1/users"
+* joinURL("https://api.example.com/", "/v1/users") // "https://api.example.com/v1/users"
+*
+* // Multiple slash normalization
+* joinURL("api//v1/", "//users///") // "api/v1/users/"
+* joinURL("base///", "///path") // "base/path"
+*
+* // Root path handling
+* joinURL("/", "users") // "/users"
+* joinURL("api", "/") // "api/"
+*
+* // Empty and undefined handling
+* joinURL("", "users") // "users"
+* joinURL("api", "") // "api"
+* joinURL("", "") // "/"
+* ```
+*/
+function joinURL(base, ...segments) {
+	if (!base && !segments) return "/";
+	if (!segments || segments.length === 0) return base || "/";
+	const normalize = (s) => {
+		return s.replace(/([^:])\/+/g, "$1/").replace(/^\/+/, "/");
+	};
+	let path = base;
+	for (const seg of segments) {
+		if (!seg) continue;
+		if (path.length > 0) {
+			const pathTrailing = path[path.length - 1] === "/";
+			const segLeading = seg[0] === "/";
+			const both = pathTrailing && segLeading;
+			if (both) path += seg.slice(1);
+			else path += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path += seg;
+	}
+	return normalize(path) || "/";
+}
+
+//#endregion
+export { appendTrailingSlash, joinURL, prependLeadingSlash, trimLeadingSlash, trimTrailingSlash };

package/dist/path.d.ts

@@ -0,0 +1,2 @@
+import { appendTrailingSlash, joinURL, prependLeadingSlash, trimLeadingSlash, trimTrailingSlash } from "./path-CFkUYi0a.js";
+export { appendTrailingSlash, joinURL, prependLeadingSlash, trimLeadingSlash, trimTrailingSlash };

package/dist/path.js

@@ -0,0 +1,3 @@
+import { appendTrailingSlash, joinURL, prependLeadingSlash, trimLeadingSlash, trimTrailingSlash } from "./path-a1A1qAWN.js";
+
+export { appendTrailingSlash, joinURL, prependLeadingSlash, trimLeadingSlash, trimTrailingSlash };

package/dist/{string-DDSo2EBf.d.ts → string-BgrFQWVx.d.ts}

@@ -68,35 +68,71 @@ declare function toPascalCase(str: string): string;
  */
 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
+ * @overload
+ * @param {string} literals - The string to dedent
  * @returns {string} The dedented string
+ *
  * @example ```ts
- * dedent`
- *   This is a test.
+ * import { dedent } from "@luxass/utils/string";
+ * const text = dedent(` *   This is a test.
  *   This is another line.
- * `
+ * `);
  * // "This is a test.\nThis is another line."
  * ```
  */
 declare function dedent(literals: string): string;
+/**
+ * @overload
+ * @param {TemplateStringsArray} strings - The string to dedent
+ * @param {unknown[]} values - The values to insert into the string
+ * @returns {string} The dedented string
+ *
+ * @example
+ * ```ts
+ * import { dedent } from "@luxass/utils/string";
+ * const text = dedent`
+ *  This is a test.
+ *  This is another line.
+ * `;
+ * // "This is a test.\nThis is another line."
+ * ```
+ */
 declare function dedent(strings: TemplateStringsArray, ...values: unknown[]): string;
 declare namespace dedent {
   var raw: typeof dedentRaw;
 }
 /**
- * Removes leading and trailing whitespace from each line of a string
- * @param {TemplateStringsArray | string} literals - The string to dedent
+ * @overload
+ * @param {string} literals - The string to dedent
  * @returns {string} The dedented string
- * @example ```ts
- * dedent`
- *   This is a test.
- *   This is another line.
- * `
+ *
+ *  @example
+ * ```ts
+ * import { dedentRaw } from "@luxass/utils/string";
+ * const text = dedentRaw(`
+ *    This is a test.
+ *    This is another line.
+ * `);
  * // "This is a test.\nThis is another line."
  * ```
  */
 declare function dedentRaw(literals: string): string;
+/**
+ * @overload
+ * @param {TemplateStringsArray} strings - The string to dedent
+ * @param {unknown[]} values - The values to insert into the string
+ * @return {string} The dedented string
+ *
+ *  @example
+ * ```ts
+ * import { dedentRaw } from "@luxass/utils/string";
+ * const text = dedentRaw`
+ *    This is a test.
+ *    This is another line.
+ * `
+ * // "This is a test.\nThis is another line."
+ * ```
+ */
 declare function dedentRaw(strings: TemplateStringsArray, ...values: unknown[]): string;
 /**
  * Ensures a string is a valid JavaScript identifier by prefixing with an underscore if necessary
@@ -128,67 +164,5 @@ declare function sanitizeIdentifier(str: string): string;
  * ```
  */
 declare function formatStr(message: string, ...positionals: unknown[]): string;
-/**
- * Removes trailing slashes from a string
- * @param {string} str - The string to remove trailing slashes from
- * @returns {string} The string with trailing slashes removed
- *
- * @example
- * ```ts
- * import { trimTrailingSlash } from "@luxass/utils/string";
- *
- * trimTrailingSlash("path/to/file/") // "path/to/file"
- * trimTrailingSlash("path/to/file///") // "path/to/file"
- * trimTrailingSlash("path/to/file") // "path/to/file"
- * trimTrailingSlash("") // ""
- * ```
- */
-declare function trimTrailingSlash(str: string): string;
-/**
- * Removes leading slashes from a string
- * @param {string} str - The string to remove leading slashes from
- * @returns {string} The string with leading slashes removed
- *
- * @example
- * ```ts
- * import { trimLeadingSlash } from "@luxass/utils/string";
- *
- * trimLeadingSlash("/path/to/file") // "path/to/file"
- * trimLeadingSlash("///path/to/file") // "path/to/file"
- * trimLeadingSlash("path/to/file") // "path/to/file"
- * trimLeadingSlash("") // ""
- * ```
- */
-declare function trimLeadingSlash(str: string): string;
-/**
- * Ensures a string ends with a trailing slash
- * @param {string} str - The string to append a trailing slash to
- * @returns {string} The string with a trailing slash appended if not already present
- *
- * @example
- * ```ts
- * import { appendTrailingSlash } from "@luxass/utils/string";
- *
- * appendTrailingSlash("path/to/file") // "path/to/file/"
- * appendTrailingSlash("path/to/file/") // "path/to/file/"
- * appendTrailingSlash("") // ""
- * ```
- */
-declare function appendTrailingSlash(str: string): string;
-/**
- * Ensures a string starts with a leading slash
- * @param {string} str - The string to prepend a leading slash to
- * @returns {string} The string with a leading slash prepended if not already present
- *
- * @example
- * ```ts
- * import { prependLeadingSlash } from "@luxass/utils/string";
- *
- * prependLeadingSlash("path/to/file") // "/path/to/file"
- * prependLeadingSlash("/path/to/file") // "/path/to/file"
- * prependLeadingSlash("") // ""
- * ```
- */
-declare function prependLeadingSlash(str: string): string;
 //#endregion
-export { appendTrailingSlash, capitalize, dedent, dedentRaw, formatStr, prependLeadingSlash, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase, trimLeadingSlash, trimTrailingSlash };
+export { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/{string-DCBui1sH.js → string-BlwTLoKD.js}

@@ -93,10 +93,52 @@ 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();
 }
+/**
+* Removes leading and trailing whitespace from each line of a string
+* @param {TemplateStringsArray | string} strings - The string to dedent
+* @param {unknown[]} values - The values to insert into the string
+* @returns {string} The dedented string
+*
+* @example
+* ```ts
+* import { dedent } from "@luxass/utils/string";
+* const text = dedent` *    This is a test.
+*    This is another line.
+* `;
+* // "This is a test.\nThis is another line."
+*
+* const text = dedent(` *    This is a test.
+*    This is another line.
+* `);
+* // "This is a test.\nThis is another line."
+* ```
+*/
 function dedent(strings, ...values) {
 	return internal_dedent(strings, values, false);
 }
 dedent.raw = dedentRaw;
+/**
+* Removes leading and trailing whitespace from each line of a string
+* @param {TemplateStringsArray | string} strings - The string to dedent
+* @param {unknown[]} values - The values to insert into the string
+* @returns {string} The dedented string
+*
+* @example
+* ```ts
+* import { dedentRaw } from "@luxass/utils/string";
+* const text = dedentRaw(`
+*    This is a test.
+*    This is another line.
+* `);
+* // "This is a test.\nThis is another line."
+*
+* const text = dedentRaw`
+*    This is a test.
+*    This is another line.
+* `
+* // "This is a test.\nThis is another line."
+* ```
+*/
 function dedentRaw(strings, ...values) {
 	return internal_dedent(strings, values, true);
 }
@@ -181,80 +223,6 @@ function formatStr(message, ...positionals) {
 	formattedMessage = formattedMessage.replace(/%{2}/g, "%");
 	return formattedMessage;
 }
-/**
-* Removes trailing slashes from a string
-* @param {string} str - The string to remove trailing slashes from
-* @returns {string} The string with trailing slashes removed
-*
-* @example
-* ```ts
-* import { trimTrailingSlash } from "@luxass/utils/string";
-*
-* trimTrailingSlash("path/to/file/") // "path/to/file"
-* trimTrailingSlash("path/to/file///") // "path/to/file"
-* trimTrailingSlash("path/to/file") // "path/to/file"
-* trimTrailingSlash("") // ""
-* ```
-*/
-function trimTrailingSlash(str) {
-	if (!str) return str;
-	return str.replace(/\/+$/, "");
-}
-/**
-* Removes leading slashes from a string
-* @param {string} str - The string to remove leading slashes from
-* @returns {string} The string with leading slashes removed
-*
-* @example
-* ```ts
-* import { trimLeadingSlash } from "@luxass/utils/string";
-*
-* trimLeadingSlash("/path/to/file") // "path/to/file"
-* trimLeadingSlash("///path/to/file") // "path/to/file"
-* trimLeadingSlash("path/to/file") // "path/to/file"
-* trimLeadingSlash("") // ""
-* ```
-*/
-function trimLeadingSlash(str) {
-	if (!str) return str;
-	return str.replace(/^\/+/, "");
-}
-/**
-* Ensures a string ends with a trailing slash
-* @param {string} str - The string to append a trailing slash to
-* @returns {string} The string with a trailing slash appended if not already present
-*
-* @example
-* ```ts
-* import { appendTrailingSlash } from "@luxass/utils/string";
-*
-* appendTrailingSlash("path/to/file") // "path/to/file/"
-* appendTrailingSlash("path/to/file/") // "path/to/file/"
-* appendTrailingSlash("") // ""
-* ```
-*/
-function appendTrailingSlash(str) {
-	if (!str) return str;
-	return str.endsWith("/") ? str : `${str}/`;
-}
-/**
-* Ensures a string starts with a leading slash
-* @param {string} str - The string to prepend a leading slash to
-* @returns {string} The string with a leading slash prepended if not already present
-*
-* @example
-* ```ts
-* import { prependLeadingSlash } from "@luxass/utils/string";
-*
-* prependLeadingSlash("path/to/file") // "/path/to/file"
-* prependLeadingSlash("/path/to/file") // "/path/to/file"
-* prependLeadingSlash("") // ""
-* ```
-*/
-function prependLeadingSlash(str) {
-	if (!str) return str;
-	return str.startsWith("/") ? str : `/${str}`;
-}
 
 //#endregion
-export { appendTrailingSlash, capitalize, dedent, dedentRaw, formatStr, prependLeadingSlash, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase, trimLeadingSlash, trimTrailingSlash };
+export { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/string.d.ts

@@ -1,2 +1,2 @@
-import { appendTrailingSlash, capitalize, dedent, dedentRaw, formatStr, prependLeadingSlash, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase, trimLeadingSlash, trimTrailingSlash } from "./string-DDSo2EBf.js";
-export { appendTrailingSlash, capitalize, dedent, dedentRaw, formatStr, prependLeadingSlash, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase, trimLeadingSlash, trimTrailingSlash };
+import { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-BgrFQWVx.js";
+export { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/string.js

@@ -1,3 +1,3 @@
-import { appendTrailingSlash, capitalize, dedent, dedentRaw, formatStr, prependLeadingSlash, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase, trimLeadingSlash, trimTrailingSlash } from "./string-DCBui1sH.js";
+import { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-BlwTLoKD.js";
 
-export { appendTrailingSlash, capitalize, dedent, dedentRaw, formatStr, prependLeadingSlash, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase, trimLeadingSlash, trimTrailingSlash };
+export { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/types-DwW0ucVr.d.ts

@@ -0,0 +1,143 @@
+//#region src/types.d.ts
+/**
+ * Whatever type, or null
+ * @template T
+ * @returns {T | null} T or null
+ *
+ * @example
+ * ```ts
+ * import { Nullable } from "@luxass/utils/types";
+ *
+ * type A = Nullable<string>
+ * // string | null
+ * ```
+ */
+type Nullable<T> = T | null;
+/**
+ * Whatever type, null or undefined
+ * @template T
+ * @returns {T | null | undefined} T, undefined or null
+ *
+ * @example
+ * ```ts
+ * import { Nullish } from "@luxass/utils/types";
+ *
+ * type A = Nullish<string>
+ * // string | null | undefined
+ * ```
+ */
+type Nullish<T> = T | null | undefined;
+/**
+ * A type that can be an array or a single value.
+ * @template T
+ * @returns {T | T[]} T or T[]
+ *
+ * @example
+ * ```ts
+ * import { MaybeArray } from "@luxass/utils/types";
+ *
+ * type A = MaybeArray<string>
+ * // string | string[]
+ * ```
+ */
+type MaybeArray<T> = T | T[];
+/**
+ * A type that can be a value or a promise.
+ * @template T
+ * @returns {T | Promise<T>} T or Promise<T>
+ *
+ * @example
+ * ```ts
+ * import { MaybePromise } from "@luxass/utils/types";
+ *
+ * type A = MaybePromise<string>
+ * // string | Promise<string>
+ * ```
+ */
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Infers the element type of an array
+ * @template T
+ * @returns {T extends (infer E)[] ? E : never} The inferred element type
+ *
+ * @example
+ * ```ts
+ * import { ElementOf } from "@luxass/utils/types";
+ *
+ * type A = ElementOf<string[]>
+ * // string
+ * ```
+ */
+type ElementOf<T> = T extends (infer E)[] ? E : never;
+/**
+ * Infers the arguments type of a function
+ * @template T
+ * @returns {T extends ((...args: infer A) => any) ? A : never} The inferred arguments type
+ *
+ * @example
+ * ```ts
+ * import { InferArguments } from "@luxass/utils/types";
+ *
+ * type A = InferArguments<(a: string, b: number) => void>
+ * // [string, number]
+ * ```
+ */
+type InferArguments<T> = T extends ((...args: infer A) => any) ? A : never;
+/**
+ * Makes complex nested types more readable in editor tooltips by flattening
+ * the type to a simple object type with all properties
+ * @template T
+ * @returns {{ [K in keyof T]: T[K] } & {}} A simplified representation of the same type
+ *
+ * @example
+ * ```ts
+ * import { Prettify } from "@luxass/utils/types";
+ *
+ * type Messy = { a: string } & { b: number } & { c: boolean }
+ * type Clean = Prettify<Messy>
+ * // { a: string; b: number; c: boolean }
+ * ```
+ */
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+/**
+ * Removes index signatures from a type while preserving specific properties
+ * @template T
+ * @returns {{ [K in keyof T as {} extends Record<K, 1> ? never : K]: T[K] }} A new type without index signatures
+ *
+ * @example
+ * ```ts
+ * import { RemoveIndexSignature } from "@luxass/utils/types";
+ *
+ * type WithIndex = { id: number; [key: string]: any }
+ * type Clean = RemoveIndexSignature<WithIndex>
+ * // { id: number }
+ * ```
+ */
+type RemoveIndexSignature<T> = { [K in keyof T as {} extends Record<K, 1> ? never : K]: T[K] };
+/**
+ * A safer version of the built-in Omit utility type that ensures the keys
+ * being omitted actually exist on the source type
+ * @template T
+ * @template {keyof T} K
+ * @returns {Omit<T, K>} A new type with the specified keys omitted
+ *
+ * @example
+ * ```ts
+ * import { SafeOmit } from "@luxass/utils/types";
+ *
+ * interface User {
+ *   id: number;
+ *   name: string;
+ *   email: string;
+ * }
+ *
+ * type UserWithoutEmail = SafeOmit<User, 'email'>
+ * // { id: number; name: string }
+ *
+ * // TypeScript error - 'invalid' is not a key of User
+ * type Invalid = SafeOmit<User, 'invalid'>
+ * ```
+ */
+type SafeOmit<T, K extends keyof T> = Omit<T, K>;
+//#endregion
+export { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature, SafeOmit };

package/dist/types.d.ts

@@ -1,2 +1,2 @@
-import { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature } from "./types-DCrM3M9i.js";
-export { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature };
+import { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature, SafeOmit } from "./types-DwW0ucVr.js";
+export { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature, SafeOmit };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luxass/utils",
-  "version": "2.5.1",
+  "version": "2.6.1",
   "description": "A collection of utilities for JavaScript/TypeScript",
   "type": "module",
   "author": {
@@ -26,6 +26,7 @@
     "./guards": "./dist/guards.js",
     "./number": "./dist/number.js",
     "./object": "./dist/object.js",
+    "./path": "./dist/path.js",
     "./string": "./dist/string.js",
     "./types": "./dist/types.js",
     "./package.json": "./package.json"
@@ -43,13 +44,13 @@
     "p-retry": "^6.2.1"
   },
   "devDependencies": {
-    "@luxass/eslint-config": "^5.1.0",
+    "@luxass/eslint-config": "^5.1.1",
     "@types/node": "^22.15.2",
     "@vitest/coverage-v8": "3.2.4",
-    "eslint": "^9.30.1",
+    "eslint": "^9.32.0",
     "eslint-plugin-format": "^1.0.1",
     "publint": "^0.3.12",
-    "tsdown": "^0.12.9",
+    "tsdown": "^0.13.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "vitest-package-exports": "^0.1.1"

package/dist/types-DCrM3M9i.d.ts

@@ -1,86 +0,0 @@
-//#region src/types.d.ts
-/**
- * Whatever type, or null
- * @param T - Type
- * @returns T or null
- *
- * @example
- * ```ts
- * type A = Nullable<string>
- * // string | null
- * ```
- */
-type Nullable<T> = T | null;
-/**
- * Whatever type, null or undefined
- * @param T - Type
- * @returns T, undefined or null
- *
- * @example
- * ```ts
- * type A = Nullish<string>
- * // string | null | undefined
- * ```
- */
-type Nullish<T> = T | null | undefined;
-/**
- * A type that can be an array or a single value.
- */
-type MaybeArray<T> = T | T[];
-/**
- * A type that can be a value or a promise.
- */
-type MaybePromise<T> = T | Promise<T>;
-/**
- * Infers the element type of an array
- * @param T - Array type
- * @returns The inferred element type
- *
- * @example
- * ```ts
- * type A = ElementOf<string[]>
- * // string
- * ```
- */
-type ElementOf<T> = T extends (infer E)[] ? E : never;
-/**
- * Infers the arguments type of a function
- * @param T - Function type
- * @returns The inferred arguments type
- *
- * @example
- * ```ts
- * type A = InferArguments<(a: string, b: number) => void>
- * // [string, number]
- * ```
- */
-type InferArguments<T> = T extends ((...args: infer A) => any) ? A : never;
-/**
- * Makes complex nested types more readable in editor tooltips by flattening
- * the type to a simple object type with all properties
- * @param T - The type to prettify
- * @returns A simplified representation of the same type
- *
- * @example
- * ```ts
- * type Messy = { a: string } & { b: number } & { c: boolean }
- * type Clean = Prettify<Messy>
- * // { a: string; b: number; c: boolean }
- * ```
- */
-type Prettify<T> = { [K in keyof T]: T[K] } & {};
-/**
- * Removes index signatures from a type while preserving specific properties
- * @param T - The type to remove index signatures from
- * @returns A new type without index signatures
- *
- * @example
- * ```ts
- * type WithIndex = { id: number; [key: string]: any }
- * type Clean = RemoveIndexSignature<WithIndex>
- * // { id: number }
- * ```
- */
-type RemoveIndexSignature<T> = { [K in keyof T as {} extends Record<K, 1> ? never : K]: T[K] };
-//#endregion
-export { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature };