@luxass/utils 2.6.0 → 2.6.2

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 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-DqJkV3NT.js";
-import { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-Cwp8CD7H.js";
-import { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature } from "./types-BtiMC8Uf.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
@@ -22,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,8 +1,8 @@
 import { isNotNull, isNotNullish, isNotUndefined, isTruthy } from "./guards-O1HGJraI.js";
-import { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-pQApOGKP.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-BS-_BQ_d.js";
+import { appendTrailingSlash, prependLeadingSlash, trimLeadingSlash, trimTrailingSlash } from "./path-BcSxT2uo.js";
 import pRetry from "p-retry";
 
 //#region src/common.ts

package/dist/{path-BS-_BQ_d.js → path-BcSxT2uo.js}

@@ -74,9 +74,9 @@ function prependLeadingSlash(path) {
 	return path[0] === "/" ? path : `/${path}`;
 }
 /**
-* Joins two URL paths together, handling trailing and leading slashes appropriately
-* @param {string | undefined} base - The base URL path
-* @param {string | undefined} path - The path to append to the base
+* 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
@@ -93,35 +93,38 @@ function prependLeadingSlash(path) {
 * 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 (POSIX-like)
+* // 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(undefined, undefined) // "/"
+* joinURL("", "") // "/"
 * ```
 */
-function joinURL(base, path) {
-	if (!base && !path) return "/";
-	if (!base || base === "/") return path || "/";
-	if (!path || path === "/") return base;
-	const normalize = (s) => s.replace(/\/+/g, "/");
-	const joinPaths = (b, p) => {
-		b = normalize(b);
-		p = normalize(p);
-		if (b.endsWith("/") && b !== "/") b = b.slice(0, -1);
-		if (p.startsWith("/")) p = p.slice(1);
-		return p ? `${b}/${p}` : b;
+function joinURL(base, ...segments) {
+	if (!base && !segments) return "/";
+	if (!segments || segments.length === 0) return base || "/";
+	const normalize = (s) => {
+		return s.replace(/([^:])\/+/g, "$1/").replace(/^\/+/, "/");
 	};
-	try {
-		const url = new URL(base);
-		url.pathname = trimLeadingSlash(joinPaths(url.pathname, path));
-		return url.toString();
-	} catch {
-		return joinPaths(base, path);
+	let path = base;
+	for (const seg of segments) {
+		if (!seg || 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

package/dist/{path-DqJkV3NT.d.ts → path-CFkUYi0a.d.ts}

@@ -62,9 +62,9 @@ declare function appendTrailingSlash(path: string | undefined): string;
  */
 declare function prependLeadingSlash(path: string | undefined): string;
 /**
- * Joins two URL paths together, handling trailing and leading slashes appropriately
- * @param {string | undefined} base - The base URL path
- * @param {string | undefined} path - The path to append to the base
+ * 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
@@ -81,16 +81,20 @@ declare function prependLeadingSlash(path: string | undefined): string;
  * 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 (POSIX-like)
+ * // 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(undefined, undefined) // "/"
+ * joinURL("", "") // "/"
  * ```
  */
-declare function joinURL(base: string | undefined, path: string | undefined): string;
+declare function joinURL(base: string, ...segments: string[]): string;
 //#endregion
 export { appendTrailingSlash, joinURL, prependLeadingSlash, trimLeadingSlash, trimTrailingSlash };

package/dist/path.d.ts

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

package/dist/path.js

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

package/dist/{string-Cwp8CD7H.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

package/dist/{string-pQApOGKP.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);
 }

package/dist/string.d.ts

@@ -1,2 +1,2 @@
-import { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-Cwp8CD7H.js";
+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 { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-pQApOGKP.js";
+import { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-BlwTLoKD.js";
 
 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-BtiMC8Uf.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.6.0",
+  "version": "2.6.2",
   "description": "A collection of utilities for JavaScript/TypeScript",
   "type": "module",
   "author": {
@@ -44,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-BtiMC8Uf.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 };