@luxass/utils 2.6.2 → 2.7.0

package/dist/index.d.ts

@@ -3,7 +3,7 @@ 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 { ElementOf, InferArguments, Prettify, RemoveIndexSignature } from "./types-CdpK0-xy.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 { 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 };
+export { type ElementOf, type InferArguments, InvariantError, type Prettify, type 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 };

package/dist/types-CdpK0-xy.d.ts

@@ -0,0 +1,62 @@
+//#region src/types.d.ts
+/**
+ * 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] };
+//#endregion
+export { ElementOf, InferArguments, Prettify, RemoveIndexSignature };

package/dist/types.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luxass/utils",
-  "version": "2.6.2",
+  "version": "2.7.0",
   "description": "A collection of utilities for JavaScript/TypeScript",
   "type": "module",
   "author": {
@@ -8,6 +8,7 @@
     "email": "lucasnrgaard@gmail.com",
     "url": "https://luxass.dev"
   },
+  "packageManager": "pnpm@10.13.1",
   "license": "MIT",
   "homepage": "https://github.com/luxass/utils",
   "repository": {
@@ -40,6 +41,14 @@
   "engines": {
     "node": ">=20"
   },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest --run",
+    "test:watch": "vitest",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit"
+  },
   "dependencies": {
     "p-retry": "^6.2.1"
   },
@@ -54,13 +63,5 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "vitest-package-exports": "^0.1.1"
-  },
-  "scripts": {
-    "build": "tsdown",
-    "dev": "tsdown --watch",
-    "test": "vitest --run",
-    "test:watch": "vitest",
-    "lint": "eslint .",
-    "typecheck": "tsc --noEmit"
   }
-}
+}

package/dist/types-DwW0ucVr.d.ts

@@ -1,143 +0,0 @@
-//#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 };