lay-sing 0.2.1 → 0.4.0

package/esm/main/type/compare.d.ts

@@ -1,169 +0,0 @@
-/**
- * Checks whether two types are exactly the same.
- *
- * **⚠️Important:** parameter `A` and `B` are not distributive. When they are union type, it does not check each member separately.
- *
- * @template A - The first type to compare
- * @template B - The second type to compare
- * @template Yes - The result if types are exactly the same (defaults to `true`)
- * @template No - The result if types are not exactly the same (defaults to `false`)
- *
- * ### Result
- *
- * - `Yes`: `A` and `B` are exactly the same
- * - `No`: Otherwise
- *
- * @example
- * ```ts
- * import { expect } from '@leawind/lay-sing/test-utils'
- *
- * expect<Exact<string, string>>().toBeTrue
- * expect<Exact<never, never>>().toBeTrue
- * expect<Exact<any, any>>().toBeTrue
- *
- * expect<Exact<{ a: 3 }, { a?: 3 }>>().toBeFalse
- * expect<Exact<1 | 2, 1>>().toBeFalse
- * expect<Exact<1, number>>().toBeFalse
- * expect<Exact<() => void, () => undefined>>().toBeFalse
- * ```
- */
-export type Exact<A, B, Yes = true, No = false> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? Yes : No;
-/**
- * Checks whether two types are not exactly the same.
- *
- * This is the logical negation of `Exact<A, B>`.
- *
- * @template A - The first type to compare
- * @template B - The second type to compare
- * @template Yes - The result if types are not exactly the same (defaults to `true`)
- * @template No - The result if types are exactly the same (defaults to `false`)
- *
- * @example
- * ```ts
- * type T1 = NotExact<number, string> // true
- * type T2 = NotExact<1, number> // true
- * type F1 = NotExact<number, number> // false
- * type F2 = NotExact<1, 1> // false
- * ```
- */
-export type NotExact<A, B, Yes = true, No = false> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? No : Yes;
-/**
- * Checks whether type `A` extends type `B`.
- *
- * **⚠️Important:** parameter `A` and `B` are not distributive. When they are union type, it treats them as a single entity.
- *
- * @template A - The type to check if it extends another type
- * @template B - The type to check if `A` extends
- * @template Yes - The result if `A` extends `B` (defaults to `true`)
- * @template No - The result if `A` does not extend `B` (defaults to `false`)
- *
- * ### Result
- *
- * - `Yes`: `A` is assignable to `B`
- * - `No`: Otherwise
- */
-export type Extends<A, B, Yes = true, No = false> = [A] extends [B] ? Yes : No;
-/**
- * Checks whether type `A` is a *proper* subtype of type `B`.
- *
- * A proper extension means:
- * - `A` extends `B`
- * - `A` is not exactly the same type as `B`
- *
- * @template A - The type to check if it is a proper subtype
- * @template B - The type to check against
- * @template Yes - The result if `A` is a proper subtype of `B` (defaults to `true`)
- * @template No - The result if `A` is not a proper subtype of `B` (defaults to `false`)
- *
- * ### Result
- *
- * - `Yes`: `A` is a proper subtype of `B`
- * - `No`: Otherwise
- *
- * **Note:** the result will never be `boolean`.
- *
- * @example
- * ```ts
- * type T1 = ProperExtend<true, boolean> // true
- * type T2 = ProperExtend<1, number> // true
- * type F1 = ProperExtend<boolean, boolean> // false
- * type F2 = ProperExtend<number, string> // false
- * ```
- */
-export type ProperExtend<A, B, Yes = true, No = false> = [A] extends [B] ? Exact<A, B> extends false ? Yes : No : No;
-/**
- * Checks whether two types have any overlapping members.
- *
- * @template A - The first type to check for overlap
- * @template B - The second type to check for overlap
- * @template Yes - The result if types overlap (defaults to `true`)
- * @template No - The result if types do not overlap (defaults to `false`)
- *
- * ### Result
- *
- * - `Yes`: `A` and `B` share at least one common type
- * - `No`: `A` and `B` are completely disjoint
- *
- * @example
- * ```ts
- * type T1 = Overlap<1 | 2, 2 | 3> // true
- * type T2 = Overlap<string, 'hello'> // true
- * type F1 = Overlap<string, number> // false
- * type F2 = Overlap<1, 'one'> // false
- * ```
- */
-export type Overlap<A, B, Yes = true, No = false> = [A & B] extends [never] ? No : Yes;
-/**
- * Checks whether two types are disjoint.
- *
- * This is the logical negation of `Overlap<A, B>`.
- *
- * @template A - The first type to check for disjointness
- * @template B - The second type to check for disjointness
- * @template Yes - The result if types are disjoint (defaults to `true`)
- * @template No - The result if types are not disjoint (defaults to `false`)
- *
- * ### Result
- *
- * - `Yes`: `A` and `B` have no overlap
- * - `No`: `A` and `B` share at least one common type
- *
- * @example
- * ```ts
- * type T1 = Disjoint<string, number> // true
- * type T2 = Disjoint<1, 'one'> // true
- * type F1 = Disjoint<1 | 2, 2 | 3> // false
- * type F2 = Disjoint<string, 'hello'> // false
- * ```
- */
-export type Disjoint<A, B, Yes = true, No = false> = [A & B] extends [never] ? Yes : No;
-/**
- * Checks whether two types are mutually assignable.
- *
- * This is equivalent to checking that:
- * - `A` extends `B`
- * - `B` extends `A`
- *
- * In other words, the two types describe the same set of values,
- * even if they are written differently.
- *
- * @template A - The first type to check
- * @template B - The second type to check
- * @template Yes - The result if types are mutually assignable (defaults to `true`)
- * @template No - The result if types are not mutually assignable (defaults to `false`)
- *
- * ### Result
- *
- * - `Yes`: `A` and `B` are mutually assignable
- * - `No`: Otherwise
- *
- * @example
- * ```ts
- * type T1 = MutuallyAssignable<number, number> // true
- * type T2 = MutuallyAssignable<1 | 2, 2 | 1> // true
- * type F1 = MutuallyAssignable<string, number> // false
- * type F2 = MutuallyAssignable<1, number> // false
- * ```
- */
-export type MutuallyAssignable<A, B, Yes = true, No = false> = [A] extends [B] ? [B] extends [A] ? Yes : No : No;
-//# sourceMappingURL=compare.d.ts.map

package/esm/main/type/compare.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../../src/main/type/compare.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,MAAM,KAAK,CACf,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,GAAG,EAAE,CAAA;AAEpF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,QAAQ,CAClB,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,GAAG,CAAA;AAEpF;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,OAAO,CACjB,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,EAAE,CAAA;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,MAAM,YAAY,CACtB,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,KAAK,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,CAAA;AAE/D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,OAAO,CACjB,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,GAAG,CAAA;AAEtC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,QAAQ,CAClB,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,EAAE,CAAA;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,kBAAkB,CAC5B,CAAC,EACD,CAAC,EACD,GAAG,GAAG,IAAI,EACV,EAAE,GAAG,KAAK,IACR,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,CAAA"}

package/esm/main/type/compare.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=compare.js.map

package/esm/main/type/compare.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"compare.js","sourceRoot":"","sources":["../../../src/main/type/compare.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Checks whether two types are exactly the same.\n *\n * **⚠️Important:** parameter `A` and `B` are not distributive. When they are union type, it does not check each member separately.\n *\n * @template A - The first type to compare\n * @template B - The second type to compare\n * @template Yes - The result if types are exactly the same (defaults to `true`)\n * @template No - The result if types are not exactly the same (defaults to `false`)\n *\n * ### Result\n *\n * - `Yes`: `A` and `B` are exactly the same\n * - `No`: Otherwise\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * expect<Exact<string, string>>().toBeTrue\n * expect<Exact<never, never>>().toBeTrue\n * expect<Exact<any, any>>().toBeTrue\n *\n * expect<Exact<{ a: 3 }, { a?: 3 }>>().toBeFalse\n * expect<Exact<1 | 2, 1>>().toBeFalse\n * expect<Exact<1, number>>().toBeFalse\n * expect<Exact<() => void, () => undefined>>().toBeFalse\n * ```\n */\nexport type Exact<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? Yes : No\n\n/**\n * Checks whether two types are not exactly the same.\n *\n * This is the logical negation of `Exact<A, B>`.\n *\n * @template A - The first type to compare\n * @template B - The second type to compare\n * @template Yes - The result if types are not exactly the same (defaults to `true`)\n * @template No - The result if types are exactly the same (defaults to `false`)\n *\n * @example\n * ```ts\n * type T1 = NotExact<number, string> // true\n * type T2 = NotExact<1, number> // true\n * type F1 = NotExact<number, number> // false\n * type F2 = NotExact<1, 1> // false\n * ```\n */\nexport type NotExact<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? No : Yes\n\n/**\n * Checks whether type `A` extends type `B`.\n *\n * **⚠️Important:** parameter `A` and `B` are not distributive. When they are union type, it treats them as a single entity.\n *\n * @template A - The type to check if it extends another type\n * @template B - The type to check if `A` extends\n * @template Yes - The result if `A` extends `B` (defaults to `true`)\n * @template No - The result if `A` does not extend `B` (defaults to `false`)\n *\n * ### Result\n *\n * - `Yes`: `A` is assignable to `B`\n * - `No`: Otherwise\n */\nexport type Extends<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A] extends [B] ? Yes : No\n\n/**\n * Checks whether type `A` is a *proper* subtype of type `B`.\n *\n * A proper extension means:\n * - `A` extends `B`\n * - `A` is not exactly the same type as `B`\n *\n * @template A - The type to check if it is a proper subtype\n * @template B - The type to check against\n * @template Yes - The result if `A` is a proper subtype of `B` (defaults to `true`)\n * @template No - The result if `A` is not a proper subtype of `B` (defaults to `false`)\n *\n * ### Result\n *\n * - `Yes`: `A` is a proper subtype of `B`\n * - `No`: Otherwise\n *\n * **Note:** the result will never be `boolean`.\n *\n * @example\n * ```ts\n * type T1 = ProperExtend<true, boolean> // true\n * type T2 = ProperExtend<1, number> // true\n * type F1 = ProperExtend<boolean, boolean> // false\n * type F2 = ProperExtend<number, string> // false\n * ```\n */\nexport type ProperExtend<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A] extends [B] ? Exact<A, B> extends false ? Yes : No : No\n\n/**\n * Checks whether two types have any overlapping members.\n *\n * @template A - The first type to check for overlap\n * @template B - The second type to check for overlap\n * @template Yes - The result if types overlap (defaults to `true`)\n * @template No - The result if types do not overlap (defaults to `false`)\n *\n * ### Result\n *\n * - `Yes`: `A` and `B` share at least one common type\n * - `No`: `A` and `B` are completely disjoint\n *\n * @example\n * ```ts\n * type T1 = Overlap<1 | 2, 2 | 3> // true\n * type T2 = Overlap<string, 'hello'> // true\n * type F1 = Overlap<string, number> // false\n * type F2 = Overlap<1, 'one'> // false\n * ```\n */\nexport type Overlap<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A & B] extends [never] ? No : Yes\n\n/**\n * Checks whether two types are disjoint.\n *\n * This is the logical negation of `Overlap<A, B>`.\n *\n * @template A - The first type to check for disjointness\n * @template B - The second type to check for disjointness\n * @template Yes - The result if types are disjoint (defaults to `true`)\n * @template No - The result if types are not disjoint (defaults to `false`)\n *\n * ### Result\n *\n * - `Yes`: `A` and `B` have no overlap\n * - `No`: `A` and `B` share at least one common type\n *\n * @example\n * ```ts\n * type T1 = Disjoint<string, number> // true\n * type T2 = Disjoint<1, 'one'> // true\n * type F1 = Disjoint<1 | 2, 2 | 3> // false\n * type F2 = Disjoint<string, 'hello'> // false\n * ```\n */\nexport type Disjoint<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A & B] extends [never] ? Yes : No\n\n/**\n * Checks whether two types are mutually assignable.\n *\n * This is equivalent to checking that:\n * - `A` extends `B`\n * - `B` extends `A`\n *\n * In other words, the two types describe the same set of values,\n * even if they are written differently.\n *\n * @template A - The first type to check\n * @template B - The second type to check\n * @template Yes - The result if types are mutually assignable (defaults to `true`)\n * @template No - The result if types are not mutually assignable (defaults to `false`)\n *\n * ### Result\n *\n * - `Yes`: `A` and `B` are mutually assignable\n * - `No`: Otherwise\n *\n * @example\n * ```ts\n * type T1 = MutuallyAssignable<number, number> // true\n * type T2 = MutuallyAssignable<1 | 2, 2 | 1> // true\n * type F1 = MutuallyAssignable<string, number> // false\n * type F2 = MutuallyAssignable<1, number> // false\n * ```\n */\nexport type MutuallyAssignable<\n  A,\n  B,\n  Yes = true,\n  No = false,\n> = [A] extends [B] ? [B] extends [A] ? Yes : No : No\n"]}

package/esm/main/type/index.d.ts

@@ -1,3 +0,0 @@
-export * from './compare.js';
-export * from './set.js';
-//# sourceMappingURL=index.d.ts.map

package/esm/main/type/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/main/type/index.ts"],"names":[],"mappings":"AACA,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA"}

package/esm/main/type/index.js

@@ -1,5 +0,0 @@
-// Index start >>>>>>>>>>>>>>>>
-export * from './compare.js';
-export * from './set.js';
-// <<<<<<<<<<<<<<<<   Index end
-//# sourceMappingURL=index.js.map

package/esm/main/type/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/main/type/index.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,+BAA+B","sourcesContent":["// Index start >>>>>>>>>>>>>>>>\nexport * from './compare.js'\nexport * from './set.js'\n// <<<<<<<<<<<<<<<<   Index end\n"]}

package/esm/main/type/set.d.ts

@@ -1,34 +0,0 @@
-/**
- * Creates an intersection of all types in the provided tuple
- *
- * ## `IntersectOf<[A, B, ... T]>` = `A & B & ... & T`
- *
- * @template Types - A tuple of types to create an intersection from
- *
- * @example
- * ```ts
- * import { expect } from '@leawind/lay-sing/test-utils'
- *
- * type Result = IntersectOf<[{ a: string }, { b: number }, { c: boolean }]>
- * expect<Result>().toExtend<{ a: string } & { b: number } & { c: boolean }>().success
- * expect<Result>().toExtend<{ a: string; b: number; c: boolean }>().success
- * ```
- */
-export type IntersectOf<Types extends readonly unknown[]> = Types extends [infer First, ...infer Rest] ? First & IntersectOf<Rest> : unknown;
-/**
- * Creates a union of all types in the provided tuple
- *
- * ## `UnionOf<[A, B, ... T]>` = `A | B | ... | T`
- *
- * @template Types - A tuple of types to create a union from
- *
- * @example
- * ```ts
- * import { expect } from '@leawind/lay-sing/test-utils'
- *
- * type Result = UnionOf<[string, number, boolean]>
- * expect<Result>().toBe<string | number | boolean>().success
- * ```
- */
-export type UnionOf<Types extends readonly unknown[]> = Types extends [infer First, ...infer Rest] ? First | UnionOf<Rest> : never;
-//# sourceMappingURL=set.d.ts.map

package/esm/main/type/set.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../../src/main/type/set.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,WAAW,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,IAAI,KAAK,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAClG,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,GACzB,OAAO,CAAA;AAEX;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,OAAO,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,IAAI,KAAK,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAC9F,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,GACrB,KAAK,CAAA"}

package/esm/main/type/set.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=set.js.map

package/esm/main/type/set.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"set.js","sourceRoot":"","sources":["../../../src/main/type/set.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Creates an intersection of all types in the provided tuple\n *\n * ## `IntersectOf<[A, B, ... T]>` = `A & B & ... & T`\n *\n * @template Types - A tuple of types to create an intersection from\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * type Result = IntersectOf<[{ a: string }, { b: number }, { c: boolean }]>\n * expect<Result>().toExtend<{ a: string } & { b: number } & { c: boolean }>().success\n * expect<Result>().toExtend<{ a: string; b: number; c: boolean }>().success\n * ```\n */\nexport type IntersectOf<Types extends readonly unknown[]> = Types extends [infer First, ...infer Rest]\n  ? First & IntersectOf<Rest>\n  : unknown\n\n/**\n * Creates a union of all types in the provided tuple\n *\n * ## `UnionOf<[A, B, ... T]>` = `A | B | ... | T`\n *\n * @template Types - A tuple of types to create a union from\n *\n * @example\n * ```ts\n * import { expect } from '@leawind/lay-sing/test-utils'\n *\n * type Result = UnionOf<[string, number, boolean]>\n * expect<Result>().toBe<string | number | boolean>().success\n * ```\n */\nexport type UnionOf<Types extends readonly unknown[]> = Types extends [infer First, ...infer Rest]\n  ? First | UnionOf<Rest>\n  : never\n"]}

package/esm/main/typed-array.d.ts

@@ -1,5 +0,0 @@
-/**
- * Represents all possible TypedArray types
- */
-export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Float32Array | Float64Array | Uint32Array | BigInt64Array | BigUint64Array;
-//# sourceMappingURL=typed-array.d.ts.map

package/esm/main/typed-array.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"typed-array.d.ts","sourceRoot":"","sources":["../../src/main/typed-array.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,UAAU,GAClB,SAAS,GACT,UAAU,GACV,iBAAiB,GACjB,UAAU,GACV,WAAW,GACX,UAAU,GACV,YAAY,GACZ,YAAY,GACZ,WAAW,GACX,aAAa,GACb,cAAc,CAAA"}

package/esm/main/typed-array.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=typed-array.js.map

package/esm/main/typed-array.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"typed-array.js","sourceRoot":"","sources":["../../src/main/typed-array.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Represents all possible TypedArray types\n */\nexport type TypedArray =\n  | Int8Array\n  | Uint8Array\n  | Uint8ClampedArray\n  | Int16Array\n  | Uint16Array\n  | Int32Array\n  | Float32Array\n  | Float64Array\n  | Uint32Array\n  | BigInt64Array\n  | BigUint64Array\n"]}

package/esm/test-utils/compare.d.ts

@@ -1,81 +0,0 @@
-import type { Disjoint, Exact, If, MutuallyAssignable, NotExact, Overlap, SafePick } from '../main/index.js';
-/**
- * Type-level utility that compares two types and provides methods to test their relationship.
- * Offers options to check if types are same, different, overlapping, disjoint, or mutually assignable.
- *
- * @template T First type to compare
- * @template U Second type to compare
- * @template H Hidden property keys that are already used (internal tracking)
- *
- * @example
- * ```ts
- * import { compare } from '@leawind/lay-sing/test-utils'
- *
- * // Check if two types are the same
- * compare<number, number>().same // Available
- * // Check if two types are different
- * compare<number, string>().different // Available
- * // Check if two types overlap
- * compare<4, number>().overlap.different // Available
- * ```
- */
-export type CompareTypes<T, U, H extends PropertyKey = never> = Omit<SafePick<{
-    /**
-     * Available when types T and U are exactly the same.
-     *
-     * @example
-     * ```ts
-     * import { compare } from '@leawind/lay-sing/test-utils'
-     *
-     * compare<3, 3>().same // Available
-     * compare<boolean, boolean>().same // Available
-     * ```
-     */
-    same: CompareTypes<T, U, H | 'same'>;
-    /**
-     * Available when types T and U are different.
-     *
-     * @example
-     * ```ts
-     * import { compare } from '@leawind/lay-sing/test-utils'
-     *
-     * compare<4, 'abc'>().different // Available
-     * compare<number, 4>().different // Available
-     * ```
-     */
-    different: CompareTypes<T, U, H | 'different'>;
-    /**
-     * Available when types T and U have some overlap.
-     *
-     * @example
-     * ```ts
-     * import { compare } from '@leawind/lay-sing/test-utils'
-     *
-     * compare<4, number>().overlap // Available since 4 overlaps with number
-     * ```
-     */
-    overlap: CompareTypes<T, U, H | 'overlap'>;
-    /**
-     * Available when types T and U have no overlap (are disjoint).
-     *
-     * @example
-     * ```ts
-     * import { compare } from '@leawind/lay-sing/test-utils'
-     *
-     * compare<4, 'abc'>().different.disjoint // Available since 4 and 'abc' are disjoint
-     * ```
-     */
-    disjoint: CompareTypes<T, U, H | 'disjoint'>;
-    /**
-     * Available when types T and U are mutually assignable (each type can be assigned to the other).
-     *
-     * @example
-     * ```ts
-     * import { compare } from '@leawind/lay-sing/test-utils'
-     *
-     * compare<1 | 2, 1 | 2>().mutuallyAssignable // Available since identical union types are mutually assignable
-     * ```
-     */
-    mutuallyAssignable: CompareTypes<T, U, H | 'mutuallyAssignable'>;
-}, If<Exact<T, U>, 'same'> | If<NotExact<T, U>, 'different'> | If<Overlap<T, U>, 'overlap'> | If<Disjoint<T, U>, 'disjoint'> | If<MutuallyAssignable<T, U>, 'mutuallyAssignable'>>, H>;
-//# sourceMappingURL=compare.d.ts.map

package/esm/test-utils/compare.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../src/test-utils/compare.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,EAAE,kBAAkB,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAE5G;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,WAAW,GAAG,KAAK,IAAI,IAAI,CAClE,QAAQ,CACN;IACE;;;;;;;;;;OAUG;IACH,IAAI,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,CAAA;IAEpC;;;;;;;;;;OAUG;IACH,SAAS,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,CAAA;IAE9C;;;;;;;;;OASG;IACH,OAAO,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAAA;IAE1C;;;;;;;;;OASG;IACH,QAAQ,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,CAAA;IAE5C;;;;;;;;;OASG;IACH,kBAAkB,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,oBAAoB,CAAC,CAAA;CACjE,EACC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC,GACvB,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,WAAW,CAAC,GAC/B,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,CAAC,GAC5B,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,CAAC,GAC9B,EAAE,CAAC,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,oBAAoB,CAAC,CACrD,EACD,CAAC,CACF,CAAA"}

package/esm/test-utils/compare.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=compare.js.map

package/esm/test-utils/compare.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"compare.js","sourceRoot":"","sources":["../../src/test-utils/compare.ts"],"names":[],"mappings":"","sourcesContent":["import type { Disjoint, Exact, If, MutuallyAssignable, NotExact, Overlap, SafePick } from '../main/index.js'\n\n/**\n * Type-level utility that compares two types and provides methods to test their relationship.\n * Offers options to check if types are same, different, overlapping, disjoint, or mutually assignable.\n *\n * @template T First type to compare\n * @template U Second type to compare\n * @template H Hidden property keys that are already used (internal tracking)\n *\n * @example\n * ```ts\n * import { compare } from '@leawind/lay-sing/test-utils'\n *\n * // Check if two types are the same\n * compare<number, number>().same // Available\n * // Check if two types are different\n * compare<number, string>().different // Available\n * // Check if two types overlap\n * compare<4, number>().overlap.different // Available\n * ```\n */\nexport type CompareTypes<T, U, H extends PropertyKey = never> = Omit<\n  SafePick<\n    {\n      /**\n       * Available when types T and U are exactly the same.\n       *\n       * @example\n       * ```ts\n       * import { compare } from '@leawind/lay-sing/test-utils'\n       *\n       * compare<3, 3>().same // Available\n       * compare<boolean, boolean>().same // Available\n       * ```\n       */\n      same: CompareTypes<T, U, H | 'same'>\n\n      /**\n       * Available when types T and U are different.\n       *\n       * @example\n       * ```ts\n       * import { compare } from '@leawind/lay-sing/test-utils'\n       *\n       * compare<4, 'abc'>().different // Available\n       * compare<number, 4>().different // Available\n       * ```\n       */\n      different: CompareTypes<T, U, H | 'different'>\n\n      /**\n       * Available when types T and U have some overlap.\n       *\n       * @example\n       * ```ts\n       * import { compare } from '@leawind/lay-sing/test-utils'\n       *\n       * compare<4, number>().overlap // Available since 4 overlaps with number\n       * ```\n       */\n      overlap: CompareTypes<T, U, H | 'overlap'>\n\n      /**\n       * Available when types T and U have no overlap (are disjoint).\n       *\n       * @example\n       * ```ts\n       * import { compare } from '@leawind/lay-sing/test-utils'\n       *\n       * compare<4, 'abc'>().different.disjoint // Available since 4 and 'abc' are disjoint\n       * ```\n       */\n      disjoint: CompareTypes<T, U, H | 'disjoint'>\n\n      /**\n       * Available when types T and U are mutually assignable (each type can be assigned to the other).\n       *\n       * @example\n       * ```ts\n       * import { compare } from '@leawind/lay-sing/test-utils'\n       *\n       * compare<1 | 2, 1 | 2>().mutuallyAssignable // Available since identical union types are mutually assignable\n       * ```\n       */\n      mutuallyAssignable: CompareTypes<T, U, H | 'mutuallyAssignable'>\n    },\n    | If<Exact<T, U>, 'same'>\n    | If<NotExact<T, U>, 'different'>\n    | If<Overlap<T, U>, 'overlap'>\n    | If<Disjoint<T, U>, 'disjoint'>\n    | If<MutuallyAssignable<T, U>, 'mutuallyAssignable'>\n  >,\n  H\n>\n"]}

package/esm/test-utils/expect.d.ts

@@ -1,278 +0,0 @@
-import type { Exact, Extends, If, IfTupleIncludes, MutuallyAssignable, ProperExtend, SafePick } from '../main/index.js';
-/**
- * Represents the result of a type assertion based on a boolean condition.
- *
- * - If `true`, the result has a `success` property;
- * - If `false`, the result has a `fail` property;
- * - Otherwise, the result is `never`
- *
- * @template B The boolean condition result (true or false)
- * @template R The type of the result value (default is void)
- */
-export type TypeAssertionResult<B extends boolean, R = void> = Exact<B, never> extends true ? never : [boolean] extends [B] ? never : [B] extends [true] ? {
-    /**
-     * This field exist only when this type assertion succeed
-     *
-     * If you expect this assertion to fail, use `.fail`
-     */
-    success: R;
-} : [B] extends [false] ? {
-    /**
-     * This field exist only when this type assertion failed
-     *
-     * If you expect this assertion to success, use `.success`
-     */
-    fail: R;
-} : never;
-type ExpectTypeMethods<T, H extends PropertyKey = never> = {
-    /**
-     * Tests if the current type is exactly the same as the provided type U.
-     *
-     * @template U The type to compare with
-     *
-     * @example
-     * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
-     *
-     * expect<any>().toBe<any>().success
-     * expect<never>().toBe<never>().success
-     * expect<false>().toBe<true>().fail
-     * ```
-     */
-    toBe<U>(): TypeAssertionResult<Exact<T, U>, ExpectType<T, H>>;
-    /**
-     * Tests if the current type is mutually assignable with the provided type U.
-     *
-     * It's like:
-     *
-     * ```ts ignore
-     * [T] extends [U] ? [U] extends [T] ? Yes : No : No
-     * ```
-     *
-     * @template U The type to compare with
-     *
-     * @example
-     * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
-     *
-     * expect<{ a: 1; b: 2 }>().toEqual<{ a: 1 } & { b: 2 }>().success
-     * expect<1>().toEqual<1 | 2>().fail
-     * ```
-     */
-    toEqual<U>(): TypeAssertionResult<MutuallyAssignable<T, U>, ExpectType<T, H>>;
-    /**
-     * Tests if the current type T extends the provided type U.
-     *
-     * @template U The type to check extension against
-     *
-     * @example
-     * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
-     *
-     * expect<3.14>().toExtend<number>().success
-     * expect<2>().toExtend<string>().fail
-     * expect<'hello'>().toExtend<string>().success
-     * ```
-     */
-    toExtend<U>(): TypeAssertionResult<Extends<T, U>, ExpectType<T, H>>;
-    /**
-     * Tests if the current type T properly extends the provided type U (extends but is not the same).
-     *
-     * @template U The type to check proper extension against
-     *
-     * @example
-     * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
-     *
-     * expect<2>().toProperExtend<number>().success
-     * expect<'a' | 'b'>().toProperExtend<string>().success
-     * expect<number>().toProperExtend<number>().fail
-     * ```
-     */
-    toProperExtend<U>(): TypeAssertionResult<ProperExtend<T, U>, ExpectType<T, H>>;
-    /**
-     * Tests if the current type `T` has a property with key `K`.
-     *
-     * @template K The property key to check for
-     *
-     * ### Behavior
-     *
-     * - For single keys: succeeds if the key exists in `T`
-     * - For union types: succeeds only if **all** keys in the union exist in `T`
-     *
-     * ### Examples
-     *
-     * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
-     *
-     * type WithProp = { prop: string; another: number; may?: 5 }
-     *
-     * // Single key checks
-     * expect<WithProp>().toHaveKey<'prop'>().success
-     * expect<WithProp>().toHaveKey<'missing'>().fail
-     *
-     * // Union type checks
-     * expect<WithProp>().toHaveKey<'prop' | 'another'>().success
-     * expect<WithProp>().toHaveKey<'may' | 'unexist'>().fail
-     * ```
-     */
-    toHaveKey<K extends PropertyKey>(): IfTupleIncludes<[
-        never,
-        any
-    ], K, never, TypeAssertionResult<Extends<K, keyof T>, ExpectType<T, H>>>;
-};
-/**
- * Type-level testing utility that allows checking various relationships between types.
- * Provides methods to test type equality, extension, properties, and more.
- *
- * @template T The type being tested
- * @template H Hidden property keys that are already used (internal tracking)
- *
- * @example
- * ```ts
- * import { expect } from '@leawind/lay-sing/test-utils'
- *
- * // Test if two types are identical
- * expect<number>().toBe<number>().success
- * expect<number>().toBe<string>().fail
- * // Test if one type extends another
- * expect<2>().toExtend<number>().success
- * expect<2>().toExtend<string>().fail
- * // Test if type has a specific property
- * expect<{name: string}>().toHaveKey<'name'>().success
- * ```
- */
-export type ExpectType<T, H extends PropertyKey = never> = Omit<(ExpectTypeMethods<T, H> & {
-    T: T;
-    inspect: {
-        [K in keyof T]: T[K];
-    };
-} & SafePick<{
-    /**
-     * Tests if the current type extends the Number primitive type.
-     * Available only if the current type extends number.
-     *
-     * @example
-     * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
-     *
-     * expect<3.14>().toExtendNumber
-     * ```
-     */
-    toExtendNumber: ExpectType<T, H | 'toExtendNumber' | 'toExtend'>;
-    /**
-     * Tests if the current type extends the String primitive type.
-     * Available only if the current type extends string.
-     *
-     * @example
-     * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
-     *
-     * expect<'hello'>().toExtendString
-     * ```
-     */
-    toExtendString: ExpectType<T, H | 'toExtendString' | 'toExtend'>;
-    /**
-     * Tests if the current type extends the Boolean primitive type.
-     * Available only if the current type extends boolean.
-     *
-     * @example
-     * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
-     *
-     * expect<true>().toExtendBoolean
-     * ```
-     */
-    toExtendBoolean: ExpectType<T, H | 'toExtendBoolean' | 'toExtend'>;
-}, If<Extends<T, number>, 'toExtendNumber'> | If<Extends<T, string>, 'toExtendString'> | If<Extends<T, boolean>, 'toExtendBoolean'>> & SafePick<{
-    /**
-     * Alias for {@link ExpectTypeMethods.toBe} where `U = any`
-     *
-     * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
-     *
-     * expect<any>().toBeAny
-     * expect<any>().toBe<any>().success
-     * ```
-     */
-    toBeAny: ExpectType<T, H | 'toBeAny' | 'toBe'>;
-    /**
-     * Alias for {@link ExpectTypeMethods.toBe} where `U = never`
-     *
-     * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
-     *
-     * expect<never>().toBeNever
-     * expect<never>().toBe<never>().success
-     * ```
-     */
-    toBeNever: ExpectType<T, H | 'toBeNever' | 'toBe'>;
-    /**
-     * Alias for {@link ExpectTypeMethods.toBe} where `U = unknown`
-     *
-     * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
-     *
-     * expect<unknown>().toBeUnknown
-     * expect<unknown>().toBe<unknown>().success
-     * ```
-     */
-    toBeUnknown: ExpectType<T, H | 'toBeUnknown' | 'toBe'>;
-    /**
-     * Alias for {@link ExpectTypeMethods.toBe} where `U = void`
-     *
-     * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
-     *
-     * expect<void>().toBeVoid
-     * expect<void>().toBe<void>().success
-     * ```
-     */
-    toBeVoid: ExpectType<T, H | 'toBeVoid' | 'toBe'>;
-    /**
-     * Alias for {@link ExpectTypeMethods.toBe} where `U = null`
-     *
-     * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
-     *
-     * expect<null>().toBeNull
-     * expect<null>().toBe<null>().success
-     * ```
-     */
-    toBeNull: ExpectType<T, H | 'toBeNull' | 'toBe'>;
-    /**
-     * Alias for {@link ExpectTypeMethods.toBe} where `U = undefined`
-     *
-     * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
-     *
-     * expect<undefined>().toBeUndefined
-     * expect<undefined>().toBe<undefined>().success
-     * ```
-     */
-    toBeUndefined: ExpectType<T, H | 'toBeUndefined' | 'toBe'>;
-    /**
-     * Alias for {@link ExpectTypeMethods.toBe} where `U = true`
-     *
-     * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
-     *
-     * expect<true>().toBeTrue
-     * expect<true>().toBe<true>().success
-     * ```
-     */
-    toBeTrue: ExpectType<T, H | 'toBeTrue' | 'toBe' | 'toExtendBoolean'>;
-    /**
-     * Alias for {@link ExpectTypeMethods.toBe} where `U = false`
-     *
-     * ```ts
-     * import { expect } from '@leawind/lay-sing/test-utils'
-     *
-     * expect<false>().toBeFalse
-     * expect<false>().toBe<false>().success
-     * ```
-     */
-    toBeFalse: ExpectType<T, H | 'toBeFalse' | 'toBe' | 'toExtendBoolean'>;
-}, If<Exact<T, any>, 'toBeAny'> | If<Exact<T, never>, 'toBeNever'> | If<Exact<T, unknown>, 'toBeUnknown'> | If<Exact<T, void>, 'toBeVoid'> | If<Exact<T, null>, 'toBeNull'> | If<Exact<T, undefined>, 'toBeUndefined'> | If<Exact<T, true>, 'toBeTrue'> | If<Exact<T, false>, 'toBeFalse'>>), H>;
-export {};
-//# sourceMappingURL=expect.d.ts.map