lay-sing 0.3.0 → 0.4.1

package/esm/main/expect.d.ts

@@ -1,293 +0,0 @@
-import type { Exact, Extends, If, IfTupleIncludes, MutuallyAssignable, ProperExtend, SafePick } from '../utils/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'
-     *
-     * expect<any>().toBe<any>().success
-     * expect<never>().toBe<never>().success
-     * expect<false>().toBe<true>().fail
-     * ```
-     */
-    toBe<U>(): TypeAssertionResult<Exact<T, U>, ExpectType<T, H>>;
-    toBe<U>(_: 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'
-     *
-     * 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>>;
-    toEqual<U>(_: 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'
-     *
-     * 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>>;
-    toExtend<U>(_: 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'
-     *
-     * 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>>;
-    toProperExtend<U>(_: 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'
-     *
-     * 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>>>;
-    toHaveKey<K extends PropertyKey>(_: K): IfTupleIncludes<[
-        never,
-        any
-    ], K, never, TypeAssertionResult<Extends<K, keyof T>, ExpectType<T, H>>>;
-};
-type ExpectFunction<T, H extends PropertyKey = never> = Exact<T, any> extends true ? unknown : Exact<T, never> extends true ? unknown : [T] extends [(...args: infer Args) => infer R] ? {
-    argsType(): ExpectType<Args, H>;
-    returnType(): ExpectType<R, H>;
-} : [T] extends [new (...args: infer Args) => infer R] ? {
-    argsType(): ExpectType<Args, H>;
-    returnType(): ExpectType<R, H>;
-} : unknown;
-/**
- * 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 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> & ExpectFunction<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'
-     *
-     * 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'
-     *
-     * 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'
-     *
-     * 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'
-     *
-     * 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'
-     *
-     * 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'
-     *
-     * 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'
-     *
-     * 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'
-     *
-     * 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'
-     *
-     * 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'
-     *
-     * 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'
-     *
-     * 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

package/esm/main/expect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"expect.d.ts","sourceRoot":"","sources":["../../src/main/expect.ts"],"names":[],"mappings":"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"}

package/esm/main/expect.js

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

package/esm/main/expect.js.map

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

package/script/main/expect.d.ts

@@ -1,293 +0,0 @@
-import type { Exact, Extends, If, IfTupleIncludes, MutuallyAssignable, ProperExtend, SafePick } from '../utils/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'
-     *
-     * expect<any>().toBe<any>().success
-     * expect<never>().toBe<never>().success
-     * expect<false>().toBe<true>().fail
-     * ```
-     */
-    toBe<U>(): TypeAssertionResult<Exact<T, U>, ExpectType<T, H>>;
-    toBe<U>(_: 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'
-     *
-     * 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>>;
-    toEqual<U>(_: 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'
-     *
-     * 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>>;
-    toExtend<U>(_: 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'
-     *
-     * 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>>;
-    toProperExtend<U>(_: 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'
-     *
-     * 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>>>;
-    toHaveKey<K extends PropertyKey>(_: K): IfTupleIncludes<[
-        never,
-        any
-    ], K, never, TypeAssertionResult<Extends<K, keyof T>, ExpectType<T, H>>>;
-};
-type ExpectFunction<T, H extends PropertyKey = never> = Exact<T, any> extends true ? unknown : Exact<T, never> extends true ? unknown : [T] extends [(...args: infer Args) => infer R] ? {
-    argsType(): ExpectType<Args, H>;
-    returnType(): ExpectType<R, H>;
-} : [T] extends [new (...args: infer Args) => infer R] ? {
-    argsType(): ExpectType<Args, H>;
-    returnType(): ExpectType<R, H>;
-} : unknown;
-/**
- * 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 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> & ExpectFunction<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'
-     *
-     * 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'
-     *
-     * 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'
-     *
-     * 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'
-     *
-     * 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'
-     *
-     * 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'
-     *
-     * 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'
-     *
-     * 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'
-     *
-     * 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'
-     *
-     * 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'
-     *
-     * 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'
-     *
-     * 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

package/script/main/expect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"expect.d.ts","sourceRoot":"","sources":["../../src/main/expect.ts"],"names":[],"mappings":"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"}

package/script/main/expect.js.map

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