@ls-stack/utils 3.63.0 → 3.66.0

package/dist/{typeUtils.d.ts → typeUtils.d.mts}

@@ -1,34 +1,19 @@
-type PartialRecord<K extends keyof any, T> = {
-    [P in K]?: T;
-};
-type NonPartial<T> = {
-    [K in keyof Required<T>]: T[K];
-};
+//#region src/typeUtils.d.ts
+type PartialRecord<K$1 extends keyof any, T> = { [P in K$1]?: 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];
-type IsAny<T> = unknown extends T ? [
-    keyof T
-] extends [never] ? false : true : false;
-type Prettify<T extends Record<string, unknown>> = {
-    [P in keyof T]: T[P];
-} & {};
-type DeepPrettify<T> = {
-    [K in keyof T]: T[K] extends Record<string, unknown> ? DeepPrettify<T[K]> : T[K];
-} & {};
+type ObjKeysWithValuesOfType<Obj extends Record<PropertyKey, unknown>, ValueType> = { [K in keyof Obj]: Obj[K] extends ValueType ? K : never }[keyof Obj];
+type IsAny<T> = unknown extends T ? [keyof T] extends [never] ? false : true : false;
+type Prettify<T extends Record<string, unknown>> = { [P in keyof T]: T[P] } & {};
+type DeepPrettify<T> = { [K in keyof T]: T[K] extends Record<string, unknown> ? DeepPrettify<T[K]> : T[K] } & {};
 type DefaultSkipTransverseDeepReplace = Date | RegExp | ((...args: any[]) => any) | Error | Set<any> | Map<any, any> | WeakSet<any> | WeakMap<any, any>;
 type PathMatches<CurrentPath extends string, SkipPaths extends string> = true extends (SkipPaths extends any ? CurrentPath extends SkipPaths ? true : SkipPaths extends `${infer Prefix}[*]${infer Suffix}` ? CurrentPath extends `${Prefix}[${string}]${Suffix}` ? true : false : false : false) ? true : false;
 type BuildPath<BasePath extends string, Key extends PropertyKey> = BasePath extends '$' ? Key extends string | number ? `${Key}` : never : Key extends string | number ? `${BasePath}.${Key}` : never;
 type BuildArrayPath<BasePath extends string> = BasePath extends '$' ? '[*]' : `${BasePath}[*]`;
-type DeepReplaceValueImpl<T, ReplaceType, NewType, SkipPaths extends string | undefined, SkipType, Path extends string = '$'> = SkipPaths extends string ? PathMatches<Path, SkipPaths> extends true ? T : T extends ReplaceType ? T extends SkipType ? T : NewType : T extends readonly (infer U)[] ? Array<DeepReplaceValueImpl<U, ReplaceType, NewType, SkipPaths, SkipType, BuildArrayPath<Path>>> : T extends SkipType ? T : T extends Record<string, any> ? {
-    [K in keyof T]: DeepReplaceValueImpl<T[K], ReplaceType, NewType, SkipPaths, SkipType, BuildPath<Path, K>>;
-} : T : T extends ReplaceType ? T extends SkipType ? T : NewType : T extends readonly (infer U)[] ? Array<DeepReplaceValueImpl<U, ReplaceType, NewType, SkipPaths, SkipType, BuildArrayPath<Path>>> : T extends SkipType ? T : T extends Record<string, any> ? {
-    [K in keyof T]: DeepReplaceValueImpl<T[K], ReplaceType, NewType, SkipPaths, SkipType, BuildPath<Path, K>>;
-} : T;
+type DeepReplaceValueImpl<T, ReplaceType, NewType, SkipPaths extends string | undefined, SkipType, Path extends string = '$'> = SkipPaths extends string ? PathMatches<Path, SkipPaths> extends true ? T : T extends ReplaceType ? T extends SkipType ? T : NewType : T extends readonly (infer U)[] ? Array<DeepReplaceValueImpl<U, ReplaceType, NewType, SkipPaths, SkipType, BuildArrayPath<Path>>> : T extends SkipType ? T : T extends Record<string, any> ? { [K in keyof T]: DeepReplaceValueImpl<T[K], ReplaceType, NewType, SkipPaths, SkipType, BuildPath<Path, K>> } : T : T extends ReplaceType ? T extends SkipType ? T : NewType : T extends readonly (infer U)[] ? Array<DeepReplaceValueImpl<U, ReplaceType, NewType, SkipPaths, SkipType, BuildArrayPath<Path>>> : T extends SkipType ? T : T extends Record<string, any> ? { [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.
@@ -41,21 +26,15 @@ type DeepReplaceValueImpl<T, ReplaceType, NewType, SkipPaths extends string | un
  * @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>;
-type KeysWithUndefinedValues<T extends Record<string, unknown>> = {
-    [K in keyof T]: undefined extends T[K] ? K : never;
-}[keyof T];
+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.
  */
 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 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>>>;
 type StringWithAutoComplete<T extends string> = T | (string & {});
-
-export type { DeepPrettify, DeepReplaceValue, DefaultSkipTransverseDeepReplace, IsAny, MakeUndefinedKeysOptional, NonPartial, ObjKeysWithValuesOfType, PartialPossiblyUndefinedValues, PartialRecord, Prettify, StringWithAutoComplete };
+//#endregion
+export { DeepPrettify, DeepReplaceValue, DefaultSkipTransverseDeepReplace, IsAny, MakeUndefinedKeysOptional, NonPartial, ObjKeysWithValuesOfType, PartialPossiblyUndefinedValues, PartialRecord, Prettify, StringWithAutoComplete };

package/dist/typeUtils.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/{typedStrings.d.cts → typedStrings.d.mts}

@@ -1,3 +1,4 @@
+//#region src/typedStrings.d.ts
 /**
  * A type representing a string that contains a specific substring. Uses
  * template literal types to ensure type safety at compile time.
@@ -101,7 +102,7 @@ declare function splitTypedString<T extends string>(str: StringContaining<NoInfe
  *   (1-based)
  * @returns A tuple with exactly two string elements
  */
-declare function splitTypedStringAt<T extends string>(str: StringContaining<NoInfer<T>> | StringStartingWith<NoInfer<T>> | StringEndingWith<NoInfer<T>>, separator: T, 
+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.
  *
@@ -122,7 +123,7 @@ splitAtNSeparatorPos?: number): [string, string];
  *   ```;
  */
 type NonEmptyString = string & {
-    __nonEmptyString: true;
+  __nonEmptyString: true;
 };
 /**
  * Type guard function that checks if a string is non-empty. Narrows the type to
@@ -159,5 +160,5 @@ declare function asNonEmptyStringOrNull(str: string): NonEmptyString | null;
  * @throws Error if the string is empty
  */
 declare function assertStringIsNonEmpty(str: string): asserts str is NonEmptyString;
-
-export { type NonEmptyString, type StringContaining, type StringEndingWith, type StringStartingWith, asNonEmptyStringOrNull, asNonEmptyStringOrThrow, assertStringIsNonEmpty, isNonEmptyString, splitTypedString, splitTypedStringAt, stringContains, stringEndsWith, stringStartsWith };
+//#endregion
+export { NonEmptyString, StringContaining, StringEndingWith, StringStartingWith, asNonEmptyStringOrNull, asNonEmptyStringOrThrow, assertStringIsNonEmpty, isNonEmptyString, splitTypedString, splitTypedStringAt, stringContains, stringEndsWith, stringStartsWith };

package/dist/typedStrings.mjs

@@ -0,0 +1,131 @@
+//#region src/typedStrings.ts
+/**
+* Type guard function that checks if a string contains a specific substring.
+* Narrows the type to `StringContaining<T>` when the check passes.
+*
+* @param str - The string to check
+* @param substring - The substring to search for
+* @returns `true` if the string contains the substring, `false` otherwise
+*/
+function stringContains(str, substring) {
+	return str.includes(substring);
+}
+/**
+* Type guard function that checks if a string starts with a specific substring.
+* Narrows the type to `StringStartingWith<T>` when the check passes.
+*
+* @param str - The string to check
+* @param substring - The substring to check for at the beginning
+* @returns `true` if the string starts with the substring, `false` otherwise
+*/
+function stringStartsWith(str, substring) {
+	return str.startsWith(substring);
+}
+/**
+* Type guard function that checks if a string ends with a specific substring.
+* Narrows the type to `StringEndingWith<T>` when the check passes.
+*
+* @param str - The string to check
+* @param substring - The substring to check for at the end
+* @returns `true` if the string ends with the substring, `false` otherwise
+*/
+function stringEndsWith(str, substring) {
+	return str.endsWith(substring);
+}
+/**
+* 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
+*/
+function splitTypedString(str, separator) {
+	return str.split(separator);
+}
+/**
+* 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)
+* @returns A tuple with exactly two string elements
+*/
+function splitTypedStringAt(str, separator, splitAtNSeparatorPos = 1) {
+	const parts = str.split(separator);
+	let leftPart = parts[0];
+	let rightPart = parts.slice(1).join(separator);
+	if (leftPart === void 0) throw new Error("String does not contain the separator");
+	if (splitAtNSeparatorPos > 1) {
+		leftPart = parts.slice(0, splitAtNSeparatorPos).join(separator);
+		rightPart = parts.slice(splitAtNSeparatorPos).join(separator);
+	}
+	return [leftPart, rightPart];
+}
+/**
+* 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
+*/
+function isNonEmptyString(str) {
+	return str.length > 0;
+}
+/**
+* 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`
+* @throws Error if the string is empty
+*/
+function asNonEmptyStringOrThrow(str) {
+	if (isNonEmptyString(str)) return str;
+	throw new Error("String is empty");
+}
+/**
+* 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
+*/
+function asNonEmptyStringOrNull(str) {
+	if (isNonEmptyString(str)) return str;
+	return null;
+}
+/**
+* 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
+*/
+function assertStringIsNonEmpty(str) {
+	if (!isNonEmptyString(str)) throw new Error("String is empty");
+}
+
+//#endregion
+export { asNonEmptyStringOrNull, asNonEmptyStringOrThrow, assertStringIsNonEmpty, isNonEmptyString, splitTypedString, splitTypedStringAt, stringContains, stringEndsWith, stringStartsWith };

package/dist/typingFnUtils-Bb8drgKF.mjs

@@ -0,0 +1,101 @@
+//#region src/typingFnUtils.ts
+function asNonPartial(obj) {
+	return obj;
+}
+/**
+* A wrapper to Object.entries with a better typing inference
+*
+* @param obj
+*/
+function typedObjectEntries(obj) {
+	return Object.entries(obj);
+}
+/**
+* A wrapper to Object.entries with a better typing inference, but with strict
+* typing narrowing keys to strings.
+*
+* @param obj
+*/
+function strictTypedObjectEntries(obj) {
+	return Object.entries(obj);
+}
+/**
+* A wrapper to Object.keys with a better typing inference
+*
+* @param obj
+*/
+function typedObjectKeys(obj) {
+	return Object.keys(obj);
+}
+/**
+* A safe way to cast types, use to substitute the `as Type`
+*
+* @param value
+*/
+function asType(value) {
+	return value;
+}
+/**
+* Narrow a string to a union of strings
+*
+* @param key
+* @param union
+*/
+function narrowStringToUnion(key, union) {
+	if (!key) return void 0;
+	if (union instanceof Set) return union.has(key) ? key : void 0;
+	if (union.includes(key)) return key;
+}
+/**
+* Type helper to check if a type is a subtype of another type.
+*
+* @template BaseType - The base type to check against
+* @template SubType - The type that should extend BaseType
+* @returns Returns undefined, only used for type checking
+*/
+function typeOnRightExtendsLeftType() {}
+/** @deprecated Use typeOnRightExtendsLeftType instead */
+const isSubTypeOf = typeOnRightExtendsLeftType;
+/**
+* Type helper to narrow a string to a key of an object.
+*
+* @param key
+* @param obj
+*/
+function isObjKey(key, obj) {
+	return typeof key === "string" && key in obj;
+}
+/**
+* Type helper to compare two union types and determine their relationship.
+*
+* @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
+*/
+function unionsAreTheSame(_diff) {}
+function asPartialUndefinedValues(value) {
+	return value;
+}
+/**
+* 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
+*/
+function isNonEmptyArray(array) {
+	return array.length > 0;
+}
+/**
+* Type guard to check if an object has a specific key and narrow its type.
+*
+* @param obj - The object to check
+* @param key - The key to check for
+* @returns True if the object has the key, false otherwise
+*/
+function objectHasKey(obj, key) {
+	return key in obj;
+}
+
+//#endregion
+export { isObjKey as a, objectHasKey as c, typedObjectEntries as d, typedObjectKeys as f, isNonEmptyArray as i, strictTypedObjectEntries as l, asPartialUndefinedValues as n, isSubTypeOf as o, unionsAreTheSame as p, asType as r, narrowStringToUnion as s, asNonPartial as t, typeOnRightExtendsLeftType as u };

package/dist/{typingFnUtils.d.cts → typingFnUtils.d.mts}

@@ -1,24 +1,21 @@
-import { PartialPossiblyUndefinedValues } from './typeUtils.cjs';
-import { NonPartial } from './typingUtils.cjs';
+import { PartialPossiblyUndefinedValues } from "./typeUtils.mjs";
+import { NonPartial } from "./typingUtils.mjs";
 
+//#region src/typingFnUtils.d.ts
 declare function asNonPartial<T extends Record<string, unknown>>(obj: T): NonPartial<T>;
 /**
  * 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]>[];
+declare function typedObjectEntries<T extends Record<string, unknown>>(obj: T): NonNullable<{ [K in keyof T]: [K, T[K]] }[keyof T]>[];
 /**
  * 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]>[];
+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
  *
@@ -55,17 +52,13 @@ declare const isSubTypeOf: typeof typeOnRightExtendsLeftType;
  * @param obj
  */
 declare function isObjKey<T extends Record<string, unknown>>(key: unknown, obj: T): key is keyof T;
-type UnionDiff<T, U> = [
-    T
-] extends [U] ? [
-    U
-] extends [T] ? null : {
-    onRightHasExtraErr: Exclude<U, T>;
+type UnionDiff<T, U> = [T] extends [U] ? [U] extends [T] ? null : {
+  onRightHasExtraErr: Exclude<U, T>;
 } : [U] extends [T] ? {
-    onRightHasMissingErr: Exclude<T, U>;
+  onRightHasMissingErr: Exclude<T, U>;
 } : {
-    onRightHasExtraErr: Exclude<U, T>;
-    onRightHasMissingErr: Exclude<T, U>;
+  onRightHasExtraErr: Exclude<U, T>;
+  onRightHasMissingErr: Exclude<T, U>;
 };
 /**
  * Type helper to compare two union types and determine their relationship.
@@ -93,8 +86,6 @@ declare function isNonEmptyArray<T>(array: T[]): array is NonEmptyArray<T>;
  * @param key - The key to check for
  * @returns True if the object has the key, false otherwise
  */
-declare function objectHasKey<T extends string>(obj: object, key: T): obj is object & {
-    [K in T]: unknown;
-};
-
-export { type NonEmptyArray, asNonPartial, asPartialUndefinedValues, asType, isNonEmptyArray, isObjKey, isSubTypeOf, narrowStringToUnion, objectHasKey, strictTypedObjectEntries, typeOnRightExtendsLeftType, typedObjectEntries, typedObjectKeys, unionsAreTheSame };
+declare function objectHasKey<T extends string>(obj: object, key: T): obj is object & { [K in T]: unknown };
+//#endregion
+export { NonEmptyArray, asNonPartial, asPartialUndefinedValues, asType, isNonEmptyArray, isObjKey, isSubTypeOf, narrowStringToUnion, objectHasKey, strictTypedObjectEntries, typeOnRightExtendsLeftType, typedObjectEntries, typedObjectKeys, unionsAreTheSame };

package/dist/typingFnUtils.mjs

@@ -0,0 +1,3 @@
+import { a as isObjKey, c as objectHasKey, d as typedObjectEntries, f as typedObjectKeys, i as isNonEmptyArray, l as strictTypedObjectEntries, n as asPartialUndefinedValues, o as isSubTypeOf, p as unionsAreTheSame, r as asType, s as narrowStringToUnion, t as asNonPartial, u as typeOnRightExtendsLeftType } from "./typingFnUtils-Bb8drgKF.mjs";
+
+export { asNonPartial, asPartialUndefinedValues, asType, isNonEmptyArray, isObjKey, isSubTypeOf, narrowStringToUnion, objectHasKey, strictTypedObjectEntries, typeOnRightExtendsLeftType, typedObjectEntries, typedObjectKeys, unionsAreTheSame };

package/dist/{typingTestUtils.d.cts → typingTestUtils.d.mts}

@@ -1,4 +1,5 @@
-type TestTypeIsEqual<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+//#region src/typingTestUtils.d.ts
+type TestTypeIsEqual<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
 type TestTypeNotEqual<X, Y> = true extends TestTypeIsEqual<X, Y> ? false : true;
 declare function test(title: string, func: () => any): void;
 declare function describe(title: string, func: () => any): void;
@@ -48,12 +49,7 @@ declare function expectTypesAre<X, Y>(result: TestTypeIsEqual<X, Y> extends true
  * @param result Optional error parameter that appears only when types don't
  *   match
  */
-declare function expectTypesAreEqual<X, Y>(...result: TestTypeIsEqual<X, Y> extends true ? [] : [
-    error: 'type assertion failed, types should be equal but',
-    typeOnLeft: X,
-    _: 'is not equal to',
-    typeOnRight: Y
-]): void;
+declare function expectTypesAreEqual<X, Y>(...result: TestTypeIsEqual<X, Y> extends true ? [] : [error: 'type assertion failed, types should be equal but', typeOnLeft: X, _: 'is not equal to', typeOnRight: Y]): void;
 /**
  * Helper function for type testing that ensures two types are not equal. If
  * types are equal, it will show a compile-time error.
@@ -68,12 +64,12 @@ declare function expectTypesAreEqual<X, Y>(...result: TestTypeIsEqual<X, Y> exte
  */
 declare function expectTypesAreNotEqual<X, Y>(...result: TestTypeIsEqual<X, Y> extends false ? [] : ['error: type assertion failed, types should be NOT equal']): void;
 declare const typingTest: {
-    test: typeof test;
-    describe: typeof describe;
-    expectType: typeof expectType;
-    expectTypesAre: typeof expectTypesAre;
-    expectTypesAreEqual: typeof expectTypesAreEqual;
-    expectTypesAreNotEqual: typeof expectTypesAreNotEqual;
+  test: typeof test;
+  describe: typeof describe;
+  expectType: typeof expectType;
+  expectTypesAre: typeof expectTypesAre;
+  expectTypesAreEqual: typeof expectTypesAreEqual;
+  expectTypesAreNotEqual: typeof expectTypesAreNotEqual;
 };
-
-export { type TestTypeIsEqual, type TestTypeNotEqual, typingTest };
+//#endregion
+export { TestTypeIsEqual, TestTypeNotEqual, typingTest };

package/dist/typingTestUtils.mjs

@@ -0,0 +1,80 @@
+//#region src/typingTestUtils.ts
+function test(title, func) {
+	func();
+}
+function describe(title, func) {
+	func();
+}
+/**
+* Helper function for type testing that ensures a type extends `true`. Used in
+* combination with `TestTypeIsEqual` to verify type equality at compile time.
+*
+* @deprecated Use {@link expectTypesAreEqual} or {@link expectTypesAreNotEqual}
+*   instead
+* @example
+*   expectType<TestTypeIsEqual<string, string>>(); // OK
+*   expectType<TestTypeIsEqual<string, number>>(); // Type error
+*
+* @template T Type that must extend `true`
+* @returns An empty object cast to type T
+*/
+function expectType() {
+	return {};
+}
+/**
+* Helper function for type testing that compares two types and expects a
+* specific result. This function allows for more explicit type equality
+* assertions with a descriptive result.
+*
+* @deprecated Use {@link expectTypesAreEqual} or {@link expectTypesAreNotEqual}
+*   instead
+* @example
+*   expectTypesAre<string, string>('equal'); // OK
+*   expectTypesAre<string, number>('notEqual'); // OK
+*   expectTypesAre<string, string>('notEqual'); // Type error
+*
+* @template X First type to compare
+* @template Y Second type to compare
+* @param result Expected comparison result: 'equal' if types are equal,
+*   'notEqual' if they differ
+*/
+function expectTypesAre(result) {}
+/**
+* Helper function for type testing that ensures two types are equal. If types
+* are not equal, it will show a compile-time error with details about the
+* mismatch.
+*
+* @example
+*   expectTypesAreEqual<string, string>(); // OK
+*   expectTypesAreEqual<string, number>(); // Compile error with details
+*
+* @template X First type to compare
+* @template Y Second type to compare
+* @param result Optional error parameter that appears only when types don't
+*   match
+*/
+function expectTypesAreEqual(...result) {}
+/**
+* Helper function for type testing that ensures two types are not equal. If
+* types are equal, it will show a compile-time error.
+*
+* @example
+*   expectTypesAreNotEqual<string, number>(); // OK
+*   expectTypesAreNotEqual<string, string>(); // Compile error
+*
+* @template X First type to compare
+* @template Y Second type to compare
+* @param result Optional error parameter that appears only when types match
+*/
+function expectTypesAreNotEqual(...result) {}
+const typingTest = {
+	test,
+	describe,
+	expectType,
+	expectTypesAre,
+	expectTypesAreEqual,
+	expectTypesAreNotEqual
+};
+
+//#endregion
+export { typingTest };

package/dist/typingUtils.d.mts

@@ -0,0 +1,20 @@
+//#region src/typingUtils.d.ts
+/** @deprecated Use `PartialRecord` from `@ls-stack/utils/typeUtils` instead */
+type PartialRecord<K$1 extends keyof any, T> = { [P in K$1]?: T };
+/** @deprecated Use `NonPartial` from `@ls-stack/utils/typeUtils` instead */
+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];
+/** @deprecated Use `IsAny` from `@ls-stack/utils/typeUtils` instead */
+type IsAny<T> = unknown extends T ? [keyof T] extends [never] ? false : true : false;
+/** @deprecated Use `DeepPrettify` from `@ls-stack/utils/typeUtils` instead */
+type Prettify<T extends Record<string, unknown>> = { [P in keyof T]: T[P] } & {};
+/** @deprecated Use `DeepPrettify` from `@ls-stack/utils/typeUtils` instead */
+type DeepPrettify<T> = { [K in keyof T]: T[K] extends Record<string, unknown> ? DeepPrettify<T[K]> : T[K] } & {};
+type AddPrefixToObjKeys<T extends Record<string, unknown>, Prefix extends string> = { [K in keyof T & string as `${Prefix}${K}`]: T[K] };
+type AddSuffixToObjKeys<T extends Record<string, unknown>, Suffix extends string> = { [K in keyof T & string as `${K}${Suffix}`]: T[K] };
+//#endregion
+export { AddPrefixToObjKeys, AddSuffixToObjKeys, DeepPrettify, IsAny, NonPartial, ObjKeysWithValuesOfType, PartialRecord, Prettify };

package/dist/typingUtils.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/yamlStringify.d.mts

@@ -0,0 +1,17 @@
+//#region src/yamlStringify.d.ts
+type YamlStringifyOptions = {
+  maxLineLength?: number;
+  showUndefined?: boolean;
+  maxDepth?: number;
+  collapseObjects?: boolean;
+  addRootObjSpaces?: 'before' | 'after' | 'beforeAndAfter' | false;
+};
+declare function yamlStringify(obj: unknown, {
+  maxLineLength,
+  showUndefined,
+  maxDepth,
+  collapseObjects,
+  addRootObjSpaces
+}?: YamlStringifyOptions): string;
+//#endregion
+export { YamlStringifyOptions, yamlStringify };