@ls-stack/utils 3.40.0 → 3.42.0

package/dist/typeUtils.d.ts

@@ -4,6 +4,10 @@ type PartialRecord<K extends keyof any, T> = {
 type NonPartial<T> = {
     [K in keyof Required<T>]: T[K];
 };
+/**
+ * @deprecated Use `ObjKeysWithValuesOfType` from `@ls-stack/utils/typeUtils`
+ *   instead
+ */
 type ObjKeysWithValuesOfType<Obj extends Record<PropertyKey, unknown>, ValueType> = {
     [K in keyof Obj]: Obj[K] extends ValueType ? K : never;
 }[keyof Obj];
@@ -26,12 +30,14 @@ type DeepReplaceValueImpl<T, ReplaceType, NewType, SkipPaths extends string | un
     [K in keyof T]: DeepReplaceValueImpl<T[K], ReplaceType, NewType, SkipPaths, SkipType, BuildPath<Path, K>>;
 } : T;
 /**
- * Replaces all values that extends `ReplaceType` with `NewType` in a deeply nested object or array.
+ * Replaces all values that extends `ReplaceType` with `NewType` in a deeply
+ * nested object or array.
  *
  * @template T - The object or array to replace values in.
  * @template ReplaceType - The type to replace.
  * @template NewType - The new type to replace with.
- * @template SkipPaths - The paths to skip in transverse. e.g. 'a.b.c' | 'array[*].b'
+ * @template SkipPaths - The paths to skip in transverse. e.g. 'a.b.c' |
+ *   'array[*].b'
  * @template SkipTypes - The types to skip in transverse and replace.
  */
 type DeepReplaceValue<T, ReplaceType, NewType, SkipPaths extends string | undefined = undefined, SkipTypes = DefaultSkipTransverseDeepReplace> = DeepReplaceValueImpl<T, ReplaceType, NewType, SkipPaths, SkipTypes>;
@@ -39,8 +45,16 @@ type KeysWithUndefinedValues<T extends Record<string, unknown>> = {
     [K in keyof T]: undefined extends T[K] ? K : never;
 }[keyof T];
 /**
- * Marks all possible undefined values as partial at the root level of the object.
+ * Marks all possible undefined values as partial at the root level of the
+ * object.
  */
 type PartialPossiblyUndefinedValues<T extends Record<string, unknown>> = Prettify<Partial<Pick<T, KeysWithUndefinedValues<T>>> & Omit<T, KeysWithUndefinedValues<T>>>;
+type PickUndefinedKeys<T> = {
+    [K in keyof T]: undefined extends T[K] ? K : never;
+}[keyof T];
+type PickRequiredKeys<T> = {
+    [K in keyof T]: undefined extends T[K] ? never : K;
+}[keyof T];
+type MakeUndefinedKeysOptional<T> = Prettify<Partial<Pick<T, PickUndefinedKeys<T>>> & Pick<T, PickRequiredKeys<T>>>;
 
-export type { DeepPrettify, DeepReplaceValue, DefaultSkipTransverseDeepReplace, IsAny, NonPartial, ObjKeysWithValuesOfType, PartialPossiblyUndefinedValues, PartialRecord, Prettify };
+export type { DeepPrettify, DeepReplaceValue, DefaultSkipTransverseDeepReplace, IsAny, MakeUndefinedKeysOptional, NonPartial, ObjKeysWithValuesOfType, PartialPossiblyUndefinedValues, PartialRecord, Prettify };

package/dist/typedStrings.d.cts

@@ -1,37 +1,41 @@
 /**
- * A type representing a string that contains a specific substring.
- * Uses template literal types to ensure type safety at compile time.
+ * A type representing a string that contains a specific substring. Uses
+ * template literal types to ensure type safety at compile time.
  *
- * @template T - The substring that must be contained within the string
  * @example
- * ```ts
- * type EmailString = StringContaining<'@'>; // string that contains '@'
- * const email: EmailString = 'user@example.com'; // ✓ valid
- * ```
+ *   ```ts
+ *   type EmailString = StringContaining<'@'>; // string that contains '@'
+ *   const email: EmailString = 'user@example.com'; // ✓ valid
+ *   ```;
+ *
+ * @template T - The substring that must be contained within the string
  */
 type StringContaining<T extends string> = string extends T ? never : `${string}${T}${string}`;
 /**
- * A type representing a string that starts with a specific substring.
- * Uses template literal types to ensure the string begins with the specified prefix.
+ * A type representing a string that starts with a specific substring. Uses
+ * template literal types to ensure the string begins with the specified
+ * prefix.
  *
- * @template T - The substring that the string must start with
  * @example
- * ```ts
- * type HttpUrl = StringStartingWith<'http'>; // string starting with 'http'
- * const url: HttpUrl = 'https://example.com'; // ✓ valid
- * ```
+ *   ```ts
+ *   type HttpUrl = StringStartingWith<'http'>; // string starting with 'http'
+ *   const url: HttpUrl = 'https://example.com'; // ✓ valid
+ *   ```;
+ *
+ * @template T - The substring that the string must start with
  */
 type StringStartingWith<T extends string> = string extends T ? never : `${T}${string}`;
 /**
- * A type representing a string that ends with a specific substring.
- * Uses template literal types to ensure the string ends with the specified suffix.
+ * A type representing a string that ends with a specific substring. Uses
+ * template literal types to ensure the string ends with the specified suffix.
  *
- * @template T - The substring that the string must end with
  * @example
- * ```ts
- * type JavaFile = StringEndingWith<'.java'>; // string ending with '.java'
- * const filename: JavaFile = 'HelloWorld.java'; // ✓ valid
- * ```
+ *   ```ts
+ *   type JavaFile = StringEndingWith<'.java'>; // string ending with '.java'
+ *   const filename: JavaFile = 'HelloWorld.java'; // ✓ valid
+ *   ```;
+ *
+ * @template T - The substring that the string must end with
  */
 type StringEndingWith<T extends string> = string extends T ? never : `${string}${T}`;
 /**
@@ -62,70 +66,76 @@ declare function stringStartsWith<T extends string>(str: string, substring: T):
  */
 declare function stringEndsWith<T extends string>(str: string, substring: T): str is StringEndingWith<T>;
 /**
- * Splits a typed string by a separator that is guaranteed to exist in the string.
- * Returns an array with at least two elements: the parts before and after the first separator,
- * plus any additional parts if there are multiple separators.
+ * Splits a typed string by a separator that is guaranteed to exist in the
+ * string. Returns an array with at least two elements: the parts before and
+ * after the first separator, plus any additional parts if there are multiple
+ * separators.
+ *
+ * @example
+ *   ```ts
+ *   const path: StringContaining<'/'> = 'src/utils/types.ts';
+ *   const [first, second, ...rest] = splitTypedString(path, '/');
+ *   // first: 'src', second: 'utils', rest: ['types.ts']
+ *   ```;
  *
  * @param str - A string that contains, starts with, or ends with the separator
  * @param separator - The separator to split by
  * @returns An array with at least two string elements
- * @example
- * ```ts
- * const path: StringContaining<'/'> = 'src/utils/types.ts';
- * const [first, second, ...rest] = splitTypedString(path, '/');
- * // first: 'src', second: 'utils', rest: ['types.ts']
- * ```
  */
 declare function splitTypedString<T extends string>(str: StringContaining<NoInfer<T>> | StringStartingWith<NoInfer<T>> | StringEndingWith<NoInfer<T>>, separator: T): [string, string, ...string[]];
 /**
- * Splits a typed string at a specific occurrence of the separator.
- * Unlike `splitTypedString`, this returns exactly two parts: everything before
- * the nth separator and everything after it.
+ * Splits a typed string at a specific occurrence of the separator. Unlike
+ * `splitTypedString`, this returns exactly two parts: everything before the nth
+ * separator and everything after it.
+ *
+ * @example
+ *   ```ts
+ *   const path: StringContaining<'.'> = 'file.name.ext';
+ *   const [name, ext] = splitTypedStringAt(path, '.', 2);
+ *   // name: 'file.name', ext: 'ext'
+ *   ```;
  *
  * @param str - A string that contains, starts with, or ends with the separator
  * @param separator - The separator to split by
- * @param splitAtNSeparatorPos - The position of the separator to split at (1-based)
+ * @param splitAtNSeparatorPos - The position of the separator to split at
+ *   (1-based)
  * @returns A tuple with exactly two string elements
- * @example
- * ```ts
- * const path: StringContaining<'.'> = 'file.name.ext';
- * const [name, ext] = splitTypedStringAt(path, '.', 2);
- * // name: 'file.name', ext: 'ext'
- * ```
  */
 declare function splitTypedStringAt<T extends string>(str: StringContaining<NoInfer<T>> | StringStartingWith<NoInfer<T>> | StringEndingWith<NoInfer<T>>, separator: T, 
 /**
  * The position of the separator to split at.
+ *
  * @default 1 - split at the first separator
  */
 splitAtNSeparatorPos?: number): [string, string];
 /**
- * A branded type representing a string that is guaranteed to be non-empty (length > 0).
- * This type provides compile-time safety by preventing empty strings from being
- * assigned without proper validation.
+ * A branded type representing a string that is guaranteed to be non-empty
+ * (length > 0). This type provides compile-time safety by preventing empty
+ * strings from being assigned without proper validation.
  *
  * @example
- * ```ts
- * function processName(name: NonEmptyString) {
- *   // name is guaranteed to be non-empty
- *   return name.toUpperCase();
- * }
- * ```
+ *   ```ts
+ *   function processName(name: NonEmptyString) {
+ *     // name is guaranteed to be non-empty
+ *     return name.toUpperCase();
+ *   }
+ *   ```;
  */
 type NonEmptyString = string & {
     __nonEmptyString: true;
 };
 /**
- * Type guard function that checks if a string is non-empty.
- * Narrows the type to `NonEmptyString` when the check passes.
+ * Type guard function that checks if a string is non-empty. Narrows the type to
+ * `NonEmptyString` when the check passes.
  *
  * @param str - The string to check
  * @returns `true` if the string has length > 0, `false` otherwise
  */
 declare function isNonEmptyString(str: string): str is NonEmptyString;
 /**
- * Converts a string to `NonEmptyString` or throws an error if the string is empty.
- * Use this when you need to ensure a string is non-empty and want to fail fast.
+ * Converts a string to `NonEmptyString` or throws an error if the string is
+ * empty. Use this when you need to ensure a string is non-empty and want to
+ * fail fast.
  *
  * @param str - The string to convert
  * @returns The string as `NonEmptyString`
@@ -133,16 +143,17 @@ declare function isNonEmptyString(str: string): str is NonEmptyString;
  */
 declare function asNonEmptyStringOrThrow(str: string): NonEmptyString;
 /**
- * Converts a string to `NonEmptyString` or returns `null` if the string is empty.
- * Use this when empty strings should be handled gracefully rather than throwing errors.
+ * Converts a string to `NonEmptyString` or returns `null` if the string is
+ * empty. Use this when empty strings should be handled gracefully rather than
+ * throwing errors.
  *
  * @param str - The string to convert
  * @returns The string as `NonEmptyString` or `null` if empty
  */
 declare function asNonEmptyStringOrNull(str: string): NonEmptyString | null;
 /**
- * Assertion function that ensures a string is non-empty.
- * Throws an error if the string is empty, otherwise narrows the type to `NonEmptyString`.
+ * Assertion function that ensures a string is non-empty. Throws an error if the
+ * string is empty, otherwise narrows the type to `NonEmptyString`.
  *
  * @param str - The string to assert as non-empty
  * @throws Error if the string is empty

package/dist/typedStrings.d.ts

@@ -1,37 +1,41 @@
 /**
- * A type representing a string that contains a specific substring.
- * Uses template literal types to ensure type safety at compile time.
+ * A type representing a string that contains a specific substring. Uses
+ * template literal types to ensure type safety at compile time.
  *
- * @template T - The substring that must be contained within the string
  * @example
- * ```ts
- * type EmailString = StringContaining<'@'>; // string that contains '@'
- * const email: EmailString = 'user@example.com'; // ✓ valid
- * ```
+ *   ```ts
+ *   type EmailString = StringContaining<'@'>; // string that contains '@'
+ *   const email: EmailString = 'user@example.com'; // ✓ valid
+ *   ```;
+ *
+ * @template T - The substring that must be contained within the string
  */
 type StringContaining<T extends string> = string extends T ? never : `${string}${T}${string}`;
 /**
- * A type representing a string that starts with a specific substring.
- * Uses template literal types to ensure the string begins with the specified prefix.
+ * A type representing a string that starts with a specific substring. Uses
+ * template literal types to ensure the string begins with the specified
+ * prefix.
  *
- * @template T - The substring that the string must start with
  * @example
- * ```ts
- * type HttpUrl = StringStartingWith<'http'>; // string starting with 'http'
- * const url: HttpUrl = 'https://example.com'; // ✓ valid
- * ```
+ *   ```ts
+ *   type HttpUrl = StringStartingWith<'http'>; // string starting with 'http'
+ *   const url: HttpUrl = 'https://example.com'; // ✓ valid
+ *   ```;
+ *
+ * @template T - The substring that the string must start with
  */
 type StringStartingWith<T extends string> = string extends T ? never : `${T}${string}`;
 /**
- * A type representing a string that ends with a specific substring.
- * Uses template literal types to ensure the string ends with the specified suffix.
+ * A type representing a string that ends with a specific substring. Uses
+ * template literal types to ensure the string ends with the specified suffix.
  *
- * @template T - The substring that the string must end with
  * @example
- * ```ts
- * type JavaFile = StringEndingWith<'.java'>; // string ending with '.java'
- * const filename: JavaFile = 'HelloWorld.java'; // ✓ valid
- * ```
+ *   ```ts
+ *   type JavaFile = StringEndingWith<'.java'>; // string ending with '.java'
+ *   const filename: JavaFile = 'HelloWorld.java'; // ✓ valid
+ *   ```;
+ *
+ * @template T - The substring that the string must end with
  */
 type StringEndingWith<T extends string> = string extends T ? never : `${string}${T}`;
 /**
@@ -62,70 +66,76 @@ declare function stringStartsWith<T extends string>(str: string, substring: T):
  */
 declare function stringEndsWith<T extends string>(str: string, substring: T): str is StringEndingWith<T>;
 /**
- * Splits a typed string by a separator that is guaranteed to exist in the string.
- * Returns an array with at least two elements: the parts before and after the first separator,
- * plus any additional parts if there are multiple separators.
+ * Splits a typed string by a separator that is guaranteed to exist in the
+ * string. Returns an array with at least two elements: the parts before and
+ * after the first separator, plus any additional parts if there are multiple
+ * separators.
+ *
+ * @example
+ *   ```ts
+ *   const path: StringContaining<'/'> = 'src/utils/types.ts';
+ *   const [first, second, ...rest] = splitTypedString(path, '/');
+ *   // first: 'src', second: 'utils', rest: ['types.ts']
+ *   ```;
  *
  * @param str - A string that contains, starts with, or ends with the separator
  * @param separator - The separator to split by
  * @returns An array with at least two string elements
- * @example
- * ```ts
- * const path: StringContaining<'/'> = 'src/utils/types.ts';
- * const [first, second, ...rest] = splitTypedString(path, '/');
- * // first: 'src', second: 'utils', rest: ['types.ts']
- * ```
  */
 declare function splitTypedString<T extends string>(str: StringContaining<NoInfer<T>> | StringStartingWith<NoInfer<T>> | StringEndingWith<NoInfer<T>>, separator: T): [string, string, ...string[]];
 /**
- * Splits a typed string at a specific occurrence of the separator.
- * Unlike `splitTypedString`, this returns exactly two parts: everything before
- * the nth separator and everything after it.
+ * Splits a typed string at a specific occurrence of the separator. Unlike
+ * `splitTypedString`, this returns exactly two parts: everything before the nth
+ * separator and everything after it.
+ *
+ * @example
+ *   ```ts
+ *   const path: StringContaining<'.'> = 'file.name.ext';
+ *   const [name, ext] = splitTypedStringAt(path, '.', 2);
+ *   // name: 'file.name', ext: 'ext'
+ *   ```;
  *
  * @param str - A string that contains, starts with, or ends with the separator
  * @param separator - The separator to split by
- * @param splitAtNSeparatorPos - The position of the separator to split at (1-based)
+ * @param splitAtNSeparatorPos - The position of the separator to split at
+ *   (1-based)
  * @returns A tuple with exactly two string elements
- * @example
- * ```ts
- * const path: StringContaining<'.'> = 'file.name.ext';
- * const [name, ext] = splitTypedStringAt(path, '.', 2);
- * // name: 'file.name', ext: 'ext'
- * ```
  */
 declare function splitTypedStringAt<T extends string>(str: StringContaining<NoInfer<T>> | StringStartingWith<NoInfer<T>> | StringEndingWith<NoInfer<T>>, separator: T, 
 /**
  * The position of the separator to split at.
+ *
  * @default 1 - split at the first separator
  */
 splitAtNSeparatorPos?: number): [string, string];
 /**
- * A branded type representing a string that is guaranteed to be non-empty (length > 0).
- * This type provides compile-time safety by preventing empty strings from being
- * assigned without proper validation.
+ * A branded type representing a string that is guaranteed to be non-empty
+ * (length > 0). This type provides compile-time safety by preventing empty
+ * strings from being assigned without proper validation.
  *
  * @example
- * ```ts
- * function processName(name: NonEmptyString) {
- *   // name is guaranteed to be non-empty
- *   return name.toUpperCase();
- * }
- * ```
+ *   ```ts
+ *   function processName(name: NonEmptyString) {
+ *     // name is guaranteed to be non-empty
+ *     return name.toUpperCase();
+ *   }
+ *   ```;
  */
 type NonEmptyString = string & {
     __nonEmptyString: true;
 };
 /**
- * Type guard function that checks if a string is non-empty.
- * Narrows the type to `NonEmptyString` when the check passes.
+ * Type guard function that checks if a string is non-empty. Narrows the type to
+ * `NonEmptyString` when the check passes.
  *
  * @param str - The string to check
  * @returns `true` if the string has length > 0, `false` otherwise
  */
 declare function isNonEmptyString(str: string): str is NonEmptyString;
 /**
- * Converts a string to `NonEmptyString` or throws an error if the string is empty.
- * Use this when you need to ensure a string is non-empty and want to fail fast.
+ * Converts a string to `NonEmptyString` or throws an error if the string is
+ * empty. Use this when you need to ensure a string is non-empty and want to
+ * fail fast.
  *
  * @param str - The string to convert
  * @returns The string as `NonEmptyString`
@@ -133,16 +143,17 @@ declare function isNonEmptyString(str: string): str is NonEmptyString;
  */
 declare function asNonEmptyStringOrThrow(str: string): NonEmptyString;
 /**
- * Converts a string to `NonEmptyString` or returns `null` if the string is empty.
- * Use this when empty strings should be handled gracefully rather than throwing errors.
+ * Converts a string to `NonEmptyString` or returns `null` if the string is
+ * empty. Use this when empty strings should be handled gracefully rather than
+ * throwing errors.
  *
  * @param str - The string to convert
  * @returns The string as `NonEmptyString` or `null` if empty
  */
 declare function asNonEmptyStringOrNull(str: string): NonEmptyString | null;
 /**
- * Assertion function that ensures a string is non-empty.
- * Throws an error if the string is empty, otherwise narrows the type to `NonEmptyString`.
+ * Assertion function that ensures a string is non-empty. Throws an error if the
+ * string is empty, otherwise narrows the type to `NonEmptyString`.
  *
  * @param str - The string to assert as non-empty
  * @throws Error if the string is empty

package/dist/typingFnUtils.cjs

@@ -23,9 +23,12 @@ __export(typingFnUtils_exports, {
   asNonPartial: () => asNonPartial,
   asPartialUndefinedValues: () => asPartialUndefinedValues,
   asType: () => asType,
+  isNonEmptyArray: () => isNonEmptyArray,
   isObjKey: () => isObjKey,
   isSubTypeOf: () => isSubTypeOf,
   narrowStringToUnion: () => narrowStringToUnion,
+  objectHasKey: () => objectHasKey,
+  strictTypedObjectEntries: () => strictTypedObjectEntries,
   typeOnRightExtendsLeftType: () => typeOnRightExtendsLeftType,
   typedObjectEntries: () => typedObjectEntries,
   typedObjectKeys: () => typedObjectKeys,
@@ -38,6 +41,9 @@ function asNonPartial(obj) {
 function typedObjectEntries(obj) {
   return Object.entries(obj);
 }
+function strictTypedObjectEntries(obj) {
+  return Object.entries(obj);
+}
 function typedObjectKeys(obj) {
   return Object.keys(obj);
 }
@@ -66,14 +72,23 @@ function unionsAreTheSame(_diff) {
 function asPartialUndefinedValues(value) {
   return value;
 }
+function isNonEmptyArray(array) {
+  return array.length > 0;
+}
+function objectHasKey(obj, key) {
+  return key in obj;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   asNonPartial,
   asPartialUndefinedValues,
   asType,
+  isNonEmptyArray,
   isObjKey,
   isSubTypeOf,
   narrowStringToUnion,
+  objectHasKey,
+  strictTypedObjectEntries,
   typeOnRightExtendsLeftType,
   typedObjectEntries,
   typedObjectKeys,

package/dist/typingFnUtils.d.cts

@@ -3,24 +3,37 @@ import { NonPartial } from './typingUtils.cjs';
 
 declare function asNonPartial<T extends Record<string, unknown>>(obj: T): NonPartial<T>;
 /**
- * a wrapper to Object.entries with a better typing inference
+ * A wrapper to Object.entries with a better typing inference
+ *
  * @param obj
  */
 declare function typedObjectEntries<T extends Record<string, unknown>>(obj: T): NonNullable<{
     [K in keyof T]: [K, T[K]];
 }[keyof T]>[];
 /**
- * a wrapper to Object.keys with a better typing inference
+ * A wrapper to Object.entries with a better typing inference, but with strict
+ * typing narrowing keys to strings.
+ *
+ * @param obj
+ */
+declare function strictTypedObjectEntries<T extends Record<string, unknown>>(obj: T): NonNullable<{
+    [K in keyof T]: [K & string, T[K]];
+}[keyof T]>[];
+/**
+ * A wrapper to Object.keys with a better typing inference
+ *
  * @param obj
  */
 declare function typedObjectKeys<T extends Record<string, unknown>>(obj: T): (keyof T)[];
 /**
- * a safe way to cast types, use to substitute the `as Type`
+ * A safe way to cast types, use to substitute the `as Type`
+ *
  * @param value
  */
 declare function asType<T = unknown>(value: T): T;
 /**
- * narrow a string to a union of strings
+ * Narrow a string to a union of strings
+ *
  * @param key
  * @param union
  */
@@ -33,10 +46,11 @@ declare function narrowStringToUnion<const T extends string>(key: string | undef
  * @returns Returns undefined, only used for type checking
  */
 declare function typeOnRightExtendsLeftType<BaseType, SubType extends BaseType>(): unknown;
-/** @deprecated use typeOnRightExtendsLeftType instead */
+/** @deprecated Use typeOnRightExtendsLeftType instead */
 declare const isSubTypeOf: typeof typeOnRightExtendsLeftType;
 /**
  * Type helper to narrow a string to a key of an object.
+ *
  * @param key
  * @param obj
  */
@@ -58,9 +72,22 @@ type UnionDiff<T, U> = [
  *
  * @template T - The first union type (left side)
  * @template U - The second union type (right side)
- * @param _diff - null if unions are identical, or an object describing the errors
+ * @param _diff - Null if unions are identical, or an object describing the
+ *   errors
  */
 declare function unionsAreTheSame<T, U>(_diff: UnionDiff<T, U>): void;
 declare function asPartialUndefinedValues<T extends Record<string, unknown>>(value: PartialPossiblyUndefinedValues<T>): T;
+/** A type representing an array that is guaranteed to have at least one element. */
+type NonEmptyArray<T> = [T, ...T[]];
+/**
+ * Type guard to check if an array has at least one element.
+ *
+ * @param array - The array to check
+ * @returns True if the array is non-empty, false otherwise
+ */
+declare function isNonEmptyArray<T>(array: T[]): array is NonEmptyArray<T>;
+declare function objectHasKey<T extends string>(obj: object, key: T): obj is object & {
+    [K in T]: unknown;
+};
 
-export { asNonPartial, asPartialUndefinedValues, asType, isObjKey, isSubTypeOf, narrowStringToUnion, typeOnRightExtendsLeftType, typedObjectEntries, typedObjectKeys, unionsAreTheSame };
+export { type NonEmptyArray, asNonPartial, asPartialUndefinedValues, asType, isNonEmptyArray, isObjKey, isSubTypeOf, narrowStringToUnion, objectHasKey, strictTypedObjectEntries, typeOnRightExtendsLeftType, typedObjectEntries, typedObjectKeys, unionsAreTheSame };

package/dist/typingFnUtils.d.ts

@@ -3,24 +3,37 @@ import { NonPartial } from './typingUtils.js';
 
 declare function asNonPartial<T extends Record<string, unknown>>(obj: T): NonPartial<T>;
 /**
- * a wrapper to Object.entries with a better typing inference
+ * A wrapper to Object.entries with a better typing inference
+ *
  * @param obj
  */
 declare function typedObjectEntries<T extends Record<string, unknown>>(obj: T): NonNullable<{
     [K in keyof T]: [K, T[K]];
 }[keyof T]>[];
 /**
- * a wrapper to Object.keys with a better typing inference
+ * A wrapper to Object.entries with a better typing inference, but with strict
+ * typing narrowing keys to strings.
+ *
+ * @param obj
+ */
+declare function strictTypedObjectEntries<T extends Record<string, unknown>>(obj: T): NonNullable<{
+    [K in keyof T]: [K & string, T[K]];
+}[keyof T]>[];
+/**
+ * A wrapper to Object.keys with a better typing inference
+ *
  * @param obj
  */
 declare function typedObjectKeys<T extends Record<string, unknown>>(obj: T): (keyof T)[];
 /**
- * a safe way to cast types, use to substitute the `as Type`
+ * A safe way to cast types, use to substitute the `as Type`
+ *
  * @param value
  */
 declare function asType<T = unknown>(value: T): T;
 /**
- * narrow a string to a union of strings
+ * Narrow a string to a union of strings
+ *
  * @param key
  * @param union
  */
@@ -33,10 +46,11 @@ declare function narrowStringToUnion<const T extends string>(key: string | undef
  * @returns Returns undefined, only used for type checking
  */
 declare function typeOnRightExtendsLeftType<BaseType, SubType extends BaseType>(): unknown;
-/** @deprecated use typeOnRightExtendsLeftType instead */
+/** @deprecated Use typeOnRightExtendsLeftType instead */
 declare const isSubTypeOf: typeof typeOnRightExtendsLeftType;
 /**
  * Type helper to narrow a string to a key of an object.
+ *
  * @param key
  * @param obj
  */
@@ -58,9 +72,22 @@ type UnionDiff<T, U> = [
  *
  * @template T - The first union type (left side)
  * @template U - The second union type (right side)
- * @param _diff - null if unions are identical, or an object describing the errors
+ * @param _diff - Null if unions are identical, or an object describing the
+ *   errors
  */
 declare function unionsAreTheSame<T, U>(_diff: UnionDiff<T, U>): void;
 declare function asPartialUndefinedValues<T extends Record<string, unknown>>(value: PartialPossiblyUndefinedValues<T>): T;
+/** A type representing an array that is guaranteed to have at least one element. */
+type NonEmptyArray<T> = [T, ...T[]];
+/**
+ * Type guard to check if an array has at least one element.
+ *
+ * @param array - The array to check
+ * @returns True if the array is non-empty, false otherwise
+ */
+declare function isNonEmptyArray<T>(array: T[]): array is NonEmptyArray<T>;
+declare function objectHasKey<T extends string>(obj: object, key: T): obj is object & {
+    [K in T]: unknown;
+};
 
-export { asNonPartial, asPartialUndefinedValues, asType, isObjKey, isSubTypeOf, narrowStringToUnion, typeOnRightExtendsLeftType, typedObjectEntries, typedObjectKeys, unionsAreTheSame };
+export { type NonEmptyArray, asNonPartial, asPartialUndefinedValues, asType, isNonEmptyArray, isObjKey, isSubTypeOf, narrowStringToUnion, objectHasKey, strictTypedObjectEntries, typeOnRightExtendsLeftType, typedObjectEntries, typedObjectKeys, unionsAreTheSame };