lay-sing 0.1.1 → 0.1.2

package/LICENSE

@@ -1,21 +1,21 @@
-The MIT License (MIT)
-
-Copyright (c) 2025 Leawind <leawind@yeah.net>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+The MIT License (MIT)
+
+Copyright (c) 2025 Leawind <leawind@yeah.net>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -1,10 +1,9 @@
 | English | [简体中文](./README-zh.md) |
 | ------- | -------------------------- |
-|         |                            |
 
 # `lay-sing`
 
-TypeScript utilities for compile-time type validation and testing
+TypeScript utilities for compile-time type testing and utility types
 
 ## What is it
 
@@ -12,14 +11,16 @@ TypeScript utilities for compile-time type validation and testing
 
 ```ts
 // They do nothing at runtime
-expect<number>().toBe<number>().success
-expect<number>().toBe<string>().fail
+expect<never>().toBe<never>().success
+expect<never>().toBeNever // alias for above
+expect<never>().toBe<'should fail'>().fail
 
-// Type error: Property 'success' does not exist on type '{ fail: void; }'.
-expect<number>().toBe<string>().success
+// Type Error: Property 'success' does not exist on type '{ fail: void; }'.
+expect<never>().toBe<'should fail'>().success
+//                                    ^^^^^^^
 ```
 
-2. **Type Manipulation Tools**
+1. **Type Manipulation Tools**
 
 ```ts
 // Result is 'Bob'
@@ -32,78 +33,94 @@ type Result = Switch<2, [
 
 ## Install
 
-(#TODO)
+> This lib is published to both [NPM](https://www.npmjs.com/package/lay-sing) and [JSR](https://jsr.io/@leawind/lay-sing)
 
-## Testing Utilities
+### NPM
 
-The `test-utils` module provides type-level testing utilities for compile-time type validation.
+```sh
+npm i -D lay-sing
+```
 
-### Type Expectations
+```ts
+import type { Same } from 'lay-sing'
+import { expect } from 'lay-sing/test-utils'
+```
 
-The `expect` function provides a fluent API for type-level assertions:
+### Deno (JSR)
+
+```sh
+deno add jsr:@leawind/lay-sing
+```
 
 ```ts
-// Test if two types are identical
-expect<number>().toBe<number>().success
-expect<number>().toBe<string>().fail
+import type { Same } from '@leawind/lay-sing'
+import { expect } from '@leawind/lay-sing/test-utils'
+```
 
-// Test if one type extends another
-expect<2>().toExtend<number>().success
-expect<2>().toExtend<string>().fail
+Or Import directly:
 
-// Test if type has a specific property
-expect<{ name: string }>().toHaveProperty<'name'>().success
+```ts
+import type { Same } from 'jsr:@leawind/lay-sing@^0.1'
+import { expect } from 'jsr:@leawind/lay-sing@^0.1/test-utils'
+```
 
-// Test primitive types
-expect<'hello'>().toExtendString.success
-expect<true>().toExtendBoolean.success
+---
+
+## Usage
+
+### Testing Utilities
+
+```ts
+import { compare, expect, NOOP } from 'lay-sing/test-utils'
 ```
 
-Available assertion methods:
+The `test-utils` module provides utilities for **compile-time** type validation. These utilities have **no runtime effect** — they always return a special [`NOOP`](https://jsr.io/@leawind/lay-sing/doc/test-utils/~/NOOP) value that safely supports almost any property access or method call.
+
+A typical type test statement follows this pattern:
 
-- `toBe<U>()` - Tests exact type equality
-- `toExtend<U>()` - Tests if type extends another
-- `toProperExtend<U>()` - Tests if type properly extends another (extends but is not the same)
-- `toHaveProperty<K>()` - Tests if type has a property with key K
-- `toExtendNumber` - Tests if type extends the Number primitive (available only when type extends number)
-- `toExtendString` - Tests if type extends the String primitive (available only when type extends string)
-- `toExtendBoolean` - Tests if type extends the Boolean primitive (available only when type extends boolean)
-- Specific primitive type checks: `toBeAny`, `toBeNever`, `toBeUnknown`, `toBeVoid`, `toBeTrue`, `toBeFalse`
+```ts
+expect<ActualType>().toBe<ExpectedType>().success
+```
 
-### Type Comparisons
+- It starts with a function call like `expect<T>()` or `compare<T, U>()`
+- It ends with a property like `.success` or `.fail`
+- A **type error occurs only if the assertion fails**, helping you catch incorrect types at compile time
+- At runtime, the function always returns the actual value `NOOP`, which performs **no operation**. It can be accessed, called, or chained indefinitely without throwing
 
-The `compare` function allows for sophisticated type-to-type relationship testing:
+#### Common Usage
 
 ```ts
-// Check if two types are the same
-compare<number, number>().same // Available
+// Exact equality
+expect<A>().toBe<B>().success // Passes only if A and B are identical
 
-// Check if two types are different
-compare<number, string>().different // Available
+// Subtype check
+expect<A>().toExtend<B>().success // Passes if A extends B
 
-// Check if two types overlap
-compare<4, number>().overlap.different // Available
+// Property existence
+expect<{ name: string }>().toHaveProperty<'name'>().success
 
-// Check if two types are disjoint
-compare<4, 'abc'>().different.disjoint // Available
+// Primitive checks
+expect<true>().toBeTrue.success
+expect<'hello'>().toExtendString.success
 
-// Check if two types are mutually assignable
-compare<1 | 2, 1 | 2>().mutuallyAssignable // Available
+// Type comparison
+compare<A, B>().same // Available only if A ≡ B
+compare<A, B>().different // Available only if A ≠ B
 ```
 
-Available comparison methods:
-
-- `same` - Available when types are exactly the same
-- `different` - Available when types are different
-- `overlap` - Available when types have some overlap
-- `disjoint` - Available when types have no overlap
-- `mutuallyAssignable` - Available when types are mutually assignable
+> [!TIP]
+>
+> There's no need to memorize the full API.
+>
+> Your editor will show inline documentation and auto-completion for all available methods and properties
 
-These utilities are invaluable for creating type-level tests that validate your type definitions at compile time.
+#### NOOP
 
-### NOOP Placeholder
+A `Proxy`-based no-op object:
 
-A universal no-op placeholder implemented via `Proxy`. `NOOP` can be accessed, called, or chained indefinitely without throwing. Every operation returns itself, making it safe to use as a dummy fallback for APIs, optional hooks, or unimplemented interfaces.
+- Most accesses return itself.
+- `toString()` returns `"[NOOP]"`.
+- Not thenable (`then` is `undefined`).
 
 ```ts
 NOOP.foo.bar().baz.qux // safe, returns NOOP
@@ -111,41 +128,39 @@ String(NOOP) // "[NOOP]"
 await NOOP // does not await (not thenable)
 ```
 
-## Type Tools
+### Type Tools
 
-Here are some of type tools:
+The main entry point provides a collection of utility types for common type-level programming tasks. All types are flat-exported from the main entry point — you don’t need to import from deep paths.
 
-### Conditional Types
-
-```typescript
-type Result = If<true, 'yes', 'no'> // 'yes'
-type Conditional = If<boolean, 'yes', 'no'> // 'yes' | 'no'
+```ts
+import type { Same } from 'lay-sing'
 ```
 
-### Boolean Operations
+> All types are documented — your editor will show inline documentation on hover
+
+### Examples
 
 ```typescript
-type IsTrue = And<true, true> // true
-type IsFalse = And<true, false> // false
-type Either = Or<true, false> // true
-type Negation = Not<true> // false
-```
+// Conditional Types
+type Result = If<true, 'yes', 'no'> // 'yes'
 
-### Array/Tuple Operations
+// Boolean Logic
+type IsTrue = And<true, true> // true
 
-```typescript
+// Tuple Manipulation
 type Combined = ConcatTuple<[1, 2], [3, 4]> // [1, 2, 3, 4]
-type UniqueCombined = ConcatUniqueTuple<[1, 2, 3], [2, 3, 4]> // [1, 2, 3, 4]
-type HasElement = TupleIncludes<[1, 2, 3], 2> // true
-```
-
-### Object Manipulation
 
-```typescript
-type PartialObj = DeepPartial<{ a: string; nested: { b: number } }> // { a?: string; nested?: { b?: number } }
-type PickedProps = PropsOfType<{ a: string; b: number; c: string }, string> // { a: string; c: string }
+// Object Utilities
+type PartialObj = DeepPartial<{ a: string; nested: { b: number } }>
+// { a?: string; nested?: { b?: number } }
 ```
 
-## Name
+> [!NOTE]
+>
+> [Full API documentation is available on JSR](https://jsr.io/@leawind/lay-sing/doc)
+
+---
 
-The name "lay-sing" (pronounced /leɪ sɪŋ/) is phonetically similar to the Chinese word "类型" (pinyin: lèi xíng), which translates to "type" in English.
+> ## _Pronunciation of lay-sing_
+>
+> _"lay-sing" mimics Mandarin "lèi xíng" ("type") — Say "LAY-sing" with a sharp "LAY" (like a command) followed by a rising "sing" (like a question)._

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

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

package/esm/test-utils.js

@@ -39,6 +39,14 @@ export const NOOP = new Proxy(function () {
                 return NOOP;
         }
     },
+    set: () => true,
+    getOwnPropertyDescriptor: () => ({
+        configurable: true,
+        value: NOOP,
+    }),
+    getPrototypeOf: () => null,
+    has: () => true,
+    ownKeys: () => ['prototype'],
 });
 export function expect() {
     return NOOP;

package/esm/test-utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"test-utils.js","sourceRoot":"","sources":["../src/test-utils.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,IAAI,GAAQ,IAAI,KAAK,CAChC;IACE,OAAO,IAAI,CAAA;AACb,CAAC,EACD;IACE,GAAG,CAAC,CAAC,EAAE,IAAI;QACT,QAAQ,IAAI,EAAE,CAAC;YACb,KAAK,MAAM;gBACT,OAAO,SAAS,CAAA;YAClB,KAAK,SAAS,CAAC;YACf,KAAK,UAAU,CAAC;YAChB,KAAK,MAAM,CAAC,WAAW;gBACrB,OAAO,GAAG,EAAE,CAAC,QAAQ,CAAA;YACvB;gBACE,OAAO,IAAI,CAAA;QACf,CAAC;IACH,CAAC;CACF,CACF,CAAA;AAkQD,MAAM,UAAU,MAAM;IACpB,OAAO,IAAI,CAAA;AACb,CAAC;AA+GD,MAAM,UAAU,OAAO;IACrB,OAAO,IAAI,CAAA;AACb,CAAC","sourcesContent":["// deno-lint-ignore-file no-explicit-any\nimport type {\n  Diff,\n  Disjoint,\n  Extends,\n  If,\n  MutuallyAssignable,\n  Overlap,\n  ProperExtend,\n  SafePick,\n  Same,\n} from './main/index.js'\n\n/**\n * A universal no-op placeholder implemented via `Proxy`.\n *\n * `NOOP` can be accessed, called, or chained indefinitely without throwing.\n * Every operation returns itself, making it safe to use as a dummy fallback\n * for APIs, optional hooks, or unimplemented interfaces.\n *\n * ### Special behaviors\n *\n * - Callable: invoking `NOOP()` returns `NOOP`\n * - Property access: `NOOP.anything` returns `NOOP`\n * - Promise-safe: `NOOP.then` is `undefined`, so it is not treated as a Promise\n * - Primitive coercion (`toString`, `valueOf`, `Symbol.toPrimitive`) yields\n *   a stable string representation: `\"[NOOP]\"`\n *\n * This is useful in scenarios where a value is required syntactically but\n * should perform no action and never fail at runtime.\n *\n * ### Examples\n *\n * ```ts\n * NOOP.foo.bar().baz.qux; // safe, returns NOOP\n * String(NOOP); // \"[NOOP]\"\n * await NOOP; // does not await (not thenable)\n * ```\n */\nexport const NOOP: any = new Proxy(\n  function () {\n    return NOOP\n  },\n  {\n    get(_, prop) {\n      switch (prop) {\n        case 'then':\n          return undefined\n        case 'valueOf':\n        case 'toString':\n        case Symbol.toPrimitive:\n          return () => '[NOOP]'\n        default:\n          return NOOP\n      }\n    },\n  },\n)\n\n/**\n * Represents the result of a type assertion based on a boolean condition.\n * If the condition is true, the result has a `success` property; otherwise, it has a `fail` property.\n *\n * @template B The boolean condition result (true or false)\n * @template R The type of the result value (default is void)\n */\ntype Result<B extends true | false, R = void> = B extends true ? {\n    /**\n     * ## Expect to succeed without type error\n     */\n    success: R\n  }\n  : {\n    /**\n     * ## Expect to fail with type error\n     */\n    fail: R\n  }\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 * ### Examples\n *\n * ```ts\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}>().toHaveProperty<'name'>().success\n * ```\n */\nexport type ExpectType<T, H extends PropertyKey = never> = Omit<\n  (\n    & {\n      T: T\n      inspect: { [K in keyof T]: T[K] }\n\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       * ### Examples\n       *\n       * ```ts\n       * expect<any>().toBe<any>().success\n       * expect<never>().toBe<never>().success\n       * expect<false>().toBe<true>().fail\n       * ```\n       */\n      toBe<U>(): Result<Same<T, U>>\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       * ### Examples\n       *\n       * ```ts\n       * expect<3.14>().toExtend<number>().success\n       * expect<2>().toExtend<string>().fail\n       * expect<'hello'>().toExtend<string>().success\n       * ```\n       */\n      toExtend<U>(): Result<Extends<T, U>>\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       * ### Examples\n       *\n       * ```ts\n       * expect<2>().toProperExtend<number>().success\n       * expect<'a' | 'b'>().toProperExtend<string>().success\n       * expect<number>().toProperExtend<number>().fail\n       * ```\n       */\n      toProperExtend<U>(): Result<ProperExtend<T, U>>\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       * ### Examples\n       *\n       * ```ts\n       * type WithProp = { prop: string; another: number }\n       * expect<WithProp>().toHaveProperty<'prop'>().success\n       * expect<WithProp>().toHaveProperty<'another'>().success\n       * expect<WithProp>().toHaveProperty<'missing'>().fail\n       * ```\n       */\n      toHaveProperty<K extends PropertyKey>(): Result<Extends<K, keyof T>>\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         * ### Examples\n         *\n         * ```ts\n         * expect<3.14>().toExtendNumber // Available and would succeed\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         * ### Examples\n         *\n         * ```ts\n         * expect<'hello'>().toExtendString // Available and would succeed\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         * ### Examples\n         *\n         * ```ts\n         * expect<true>().toExtendBoolean // Available and would succeed\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         * Tests if the current type is exactly `any`.\n         * Available only if the current type is `any`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<any>().toBeAny // Available and would succeed\n         * ```\n         */\n        toBeAny: ExpectType<T, H | 'toBeAny' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `never`.\n         * Available only if the current type is `never`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<never>().toBeNever // Available and would succeed\n         * ```\n         */\n        toBeNever: ExpectType<T, H | 'toBeNever' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `unknown`.\n         * Available only if the current type is `unknown`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<unknown>().toBeUnknown // Available and would succeed\n         * ```\n         */\n        toBeUnknown: ExpectType<T, H | 'toBeUnknown' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `void`.\n         * Available only if the current type is `void`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<void>().toBeVoid // Available and would succeed\n         * ```\n         */\n        toBeVoid: ExpectType<T, H | 'toBeVoid' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `true` (boolean literal).\n         * Available only if the current type is `true`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<true>().toBeTrue // Available and would succeed\n         * ```\n         */\n        toBeTrue: ExpectType<T, H | 'toBeTrue' | 'toBe' | 'toExtendBoolean'>\n\n        /**\n         * Tests if the current type is exactly `false` (boolean literal).\n         * Available only if the current type is `false`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<false>().toBeFalse // Available and would succeed\n         * ```\n         */\n        toBeFalse: ExpectType<T, H | 'toBeFalse' | 'toBe' | 'toExtendBoolean'>\n      },\n      | If<Same<T, any>, 'toBeAny'>\n      | If<Same<T, never>, 'toBeNever'>\n      | If<Same<T, unknown>, 'toBeUnknown'>\n      | If<Same<T, void>, 'toBeVoid'>\n      | If<Same<T, true>, 'toBeTrue'>\n      | If<Same<T, false>, 'toBeFalse'>\n    >\n  ),\n  H\n>\n\n/**\n * Creates an instance of ExpectType to perform type-level assertions on the given type.\n * This function enables testing various type relationships at compile time.\n * NOTE: This function does nothing at runtime and is purely for type-level testing.\n *\n * @template T The type to be tested\n *\n * @returns An ExpectType instance with methods to test type relationships\n *\n * ### Examples\n *\n * ```ts\n * // Test exact type equality\n * expect<number>().toBe<number>().success\n * expect<number>().toBe<string>().fail\n * // Test if one type extends another\n * expect<3.14>().toExtend<number>().success\n * expect<2>().toExtend<string>().fail\n * ```\n */\nexport function expect<T>(): ExpectType<T>\nexport function expect<T>(_: T): ExpectType<T>\nexport function expect<T>(): ExpectType<T> {\n  return NOOP\n}\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 * ### Examples\n *\n * ```ts\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       * ### Examples\n       *\n       * ```ts\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       * ### Examples\n       *\n       * ```ts\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       * ### Examples\n       *\n       * ```ts\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       * ### Examples\n       *\n       * ```ts\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       * ### Examples\n       *\n       * ```ts\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<Same<T, U>, 'same'>\n    | If<Diff<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\n/**\n * Creates an instance of CompareTypes to perform type-level comparisons between two types.\n * This function enables testing various relationships between types at compile time.\n * NOTE: This function does nothing at runtime and is purely for type-level testing.\n *\n * @template T First type to compare\n * @template U Second type to compare\n *\n * @returns A CompareTypes instance with methods to test relationships between T and U\n *\n * ### Examples\n *\n * ```ts\n * // Compare two identical types\n * compare<number, number>().same // Results in an available property\n * // Compare two different but overlapping types\n * compare<4, number>().overlap.different // Results in available properties\n * ```\n */\nexport function compare<T, U>(): CompareTypes<T, U>\nexport function compare<T, U>(t: T, u: U): CompareTypes<T, U>\nexport function compare<T, U>(): CompareTypes<T, U> {\n  return NOOP\n}\n"]}
+{"version":3,"file":"test-utils.js","sourceRoot":"","sources":["../src/test-utils.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,IAAI,GAAQ,IAAI,KAAK,CAChC;IACE,OAAO,IAAI,CAAA;AACb,CAAC,EACD;IACE,GAAG,CAAC,CAAC,EAAE,IAAI;QACT,QAAQ,IAAI,EAAE,CAAC;YACb,KAAK,MAAM;gBACT,OAAO,SAAS,CAAA;YAClB,KAAK,SAAS,CAAC;YACf,KAAK,UAAU,CAAC;YAChB,KAAK,MAAM,CAAC,WAAW;gBACrB,OAAO,GAAG,EAAE,CAAC,QAAQ,CAAA;YACvB;gBACE,OAAO,IAAI,CAAA;QACf,CAAC;IACH,CAAC;IACD,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI;IACf,wBAAwB,EAAE,GAAG,EAAE,CAAC,CAAC;QAC/B,YAAY,EAAE,IAAI;QAClB,KAAK,EAAE,IAAI;KACZ,CAAC;IACF,cAAc,EAAE,GAAG,EAAE,CAAC,IAAI;IAC1B,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI;IACf,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,WAAW,CAAC;CAC7B,CACF,CAAA;AAkQD,MAAM,UAAU,MAAM;IACpB,OAAO,IAAI,CAAA;AACb,CAAC;AA+GD,MAAM,UAAU,OAAO;IACrB,OAAO,IAAI,CAAA;AACb,CAAC","sourcesContent":["// deno-lint-ignore-file no-explicit-any\nimport type {\n  Diff,\n  Disjoint,\n  Extends,\n  If,\n  MutuallyAssignable,\n  Overlap,\n  ProperExtend,\n  SafePick,\n  Same,\n} from './main/index.js'\n\n/**\n * A universal no-op placeholder implemented via `Proxy`.\n *\n * `NOOP` can be accessed, called, or chained indefinitely without throwing.\n * Every operation returns itself, making it safe to use as a dummy fallback\n * for APIs, optional hooks, or unimplemented interfaces.\n *\n * ### Special behaviors\n *\n * - Callable: invoking `NOOP()` returns `NOOP`\n * - Property access: `NOOP.anything` returns `NOOP`\n * - Promise-safe: `NOOP.then` is `undefined`, so it is not treated as a Promise\n * - Primitive coercion (`toString`, `valueOf`, `Symbol.toPrimitive`) yields\n *   a stable string representation: `\"[NOOP]\"`\n *\n * This is useful in scenarios where a value is required syntactically but\n * should perform no action and never fail at runtime.\n *\n * ### Examples\n *\n * ```ts\n * NOOP.foo.bar().baz.qux; // safe, returns NOOP\n * String(NOOP); // \"[NOOP]\"\n * await NOOP; // does not await (not thenable)\n * ```\n */\nexport const NOOP: any = new Proxy(\n  function () {\n    return NOOP\n  },\n  {\n    get(_, prop) {\n      switch (prop) {\n        case 'then':\n          return undefined\n        case 'valueOf':\n        case 'toString':\n        case Symbol.toPrimitive:\n          return () => '[NOOP]'\n        default:\n          return NOOP\n      }\n    },\n    set: () => true,\n    getOwnPropertyDescriptor: () => ({\n      configurable: true,\n      value: NOOP,\n    }),\n    getPrototypeOf: () => null,\n    has: () => true,\n    ownKeys: () => ['prototype'],\n  },\n)\n\n/**\n * Represents the result of a type assertion based on a boolean condition.\n * If the condition is true, the result has a `success` property; otherwise, it has a `fail` property.\n *\n * @template B The boolean condition result (true or false)\n * @template R The type of the result value (default is void)\n */\ntype Result<B extends true | false, R = void> = B extends true ? {\n    /**\n     * ## Expect to succeed without type error\n     */\n    success: R\n  }\n  : {\n    /**\n     * ## Expect to fail with type error\n     */\n    fail: R\n  }\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 * ### Examples\n *\n * ```ts\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}>().toHaveProperty<'name'>().success\n * ```\n */\nexport type ExpectType<T, H extends PropertyKey = never> = Omit<\n  (\n    & {\n      T: T\n      inspect: { [K in keyof T]: T[K] }\n\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       * ### Examples\n       *\n       * ```ts\n       * expect<any>().toBe<any>().success\n       * expect<never>().toBe<never>().success\n       * expect<false>().toBe<true>().fail\n       * ```\n       */\n      toBe<U>(): Result<Same<T, U>>\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       * ### Examples\n       *\n       * ```ts\n       * expect<3.14>().toExtend<number>().success\n       * expect<2>().toExtend<string>().fail\n       * expect<'hello'>().toExtend<string>().success\n       * ```\n       */\n      toExtend<U>(): Result<Extends<T, U>>\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       * ### Examples\n       *\n       * ```ts\n       * expect<2>().toProperExtend<number>().success\n       * expect<'a' | 'b'>().toProperExtend<string>().success\n       * expect<number>().toProperExtend<number>().fail\n       * ```\n       */\n      toProperExtend<U>(): Result<ProperExtend<T, U>>\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       * ### Examples\n       *\n       * ```ts\n       * type WithProp = { prop: string; another: number }\n       * expect<WithProp>().toHaveProperty<'prop'>().success\n       * expect<WithProp>().toHaveProperty<'another'>().success\n       * expect<WithProp>().toHaveProperty<'missing'>().fail\n       * ```\n       */\n      toHaveProperty<K extends PropertyKey>(): Result<Extends<K, keyof T>>\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         * ### Examples\n         *\n         * ```ts\n         * expect<3.14>().toExtendNumber // Available and would succeed\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         * ### Examples\n         *\n         * ```ts\n         * expect<'hello'>().toExtendString // Available and would succeed\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         * ### Examples\n         *\n         * ```ts\n         * expect<true>().toExtendBoolean // Available and would succeed\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         * Tests if the current type is exactly `any`.\n         * Available only if the current type is `any`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<any>().toBeAny // Available and would succeed\n         * ```\n         */\n        toBeAny: ExpectType<T, H | 'toBeAny' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `never`.\n         * Available only if the current type is `never`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<never>().toBeNever // Available and would succeed\n         * ```\n         */\n        toBeNever: ExpectType<T, H | 'toBeNever' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `unknown`.\n         * Available only if the current type is `unknown`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<unknown>().toBeUnknown // Available and would succeed\n         * ```\n         */\n        toBeUnknown: ExpectType<T, H | 'toBeUnknown' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `void`.\n         * Available only if the current type is `void`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<void>().toBeVoid // Available and would succeed\n         * ```\n         */\n        toBeVoid: ExpectType<T, H | 'toBeVoid' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `true` (boolean literal).\n         * Available only if the current type is `true`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<true>().toBeTrue // Available and would succeed\n         * ```\n         */\n        toBeTrue: ExpectType<T, H | 'toBeTrue' | 'toBe' | 'toExtendBoolean'>\n\n        /**\n         * Tests if the current type is exactly `false` (boolean literal).\n         * Available only if the current type is `false`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<false>().toBeFalse // Available and would succeed\n         * ```\n         */\n        toBeFalse: ExpectType<T, H | 'toBeFalse' | 'toBe' | 'toExtendBoolean'>\n      },\n      | If<Same<T, any>, 'toBeAny'>\n      | If<Same<T, never>, 'toBeNever'>\n      | If<Same<T, unknown>, 'toBeUnknown'>\n      | If<Same<T, void>, 'toBeVoid'>\n      | If<Same<T, true>, 'toBeTrue'>\n      | If<Same<T, false>, 'toBeFalse'>\n    >\n  ),\n  H\n>\n\n/**\n * Creates an instance of ExpectType to perform type-level assertions on the given type.\n * This function enables testing various type relationships at compile time.\n * NOTE: This function does nothing at runtime and is purely for type-level testing.\n *\n * @template T The type to be tested\n *\n * @returns An ExpectType instance with methods to test type relationships\n *\n * ### Examples\n *\n * ```ts\n * // Test exact type equality\n * expect<number>().toBe<number>().success\n * expect<number>().toBe<string>().fail\n * // Test if one type extends another\n * expect<3.14>().toExtend<number>().success\n * expect<2>().toExtend<string>().fail\n * ```\n */\nexport function expect<T>(): ExpectType<T>\nexport function expect<T>(_: T): ExpectType<T>\nexport function expect<T>(): ExpectType<T> {\n  return NOOP\n}\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 * ### Examples\n *\n * ```ts\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       * ### Examples\n       *\n       * ```ts\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       * ### Examples\n       *\n       * ```ts\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       * ### Examples\n       *\n       * ```ts\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       * ### Examples\n       *\n       * ```ts\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       * ### Examples\n       *\n       * ```ts\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<Same<T, U>, 'same'>\n    | If<Diff<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\n/**\n * Creates an instance of CompareTypes to perform type-level comparisons between two types.\n * This function enables testing various relationships between types at compile time.\n * NOTE: This function does nothing at runtime and is purely for type-level testing.\n *\n * @template T First type to compare\n * @template U Second type to compare\n *\n * @returns A CompareTypes instance with methods to test relationships between T and U\n *\n * ### Examples\n *\n * ```ts\n * // Compare two identical types\n * compare<number, number>().same // Results in an available property\n * // Compare two different but overlapping types\n * compare<4, number>().overlap.different // Results in available properties\n * ```\n */\nexport function compare<T, U>(): CompareTypes<T, U>\nexport function compare<T, U>(t: T, u: U): CompareTypes<T, U>\nexport function compare<T, U>(): CompareTypes<T, U> {\n  return NOOP\n}\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lay-sing",
-  "version": "0.1.1",
-  "description": "TypeScript utilities for compile-time type validation and testing",
+  "version": "0.1.2",
+  "description": "Utilities for compile-time type testing and utility types",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Leawind/lay-sing.git"

package/script/test-utils.d.ts.map

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

package/script/test-utils.js

@@ -44,6 +44,14 @@ exports.NOOP = new Proxy(function () {
                 return exports.NOOP;
         }
     },
+    set: () => true,
+    getOwnPropertyDescriptor: () => ({
+        configurable: true,
+        value: exports.NOOP,
+    }),
+    getPrototypeOf: () => null,
+    has: () => true,
+    ownKeys: () => ['prototype'],
 });
 function expect() {
     return exports.NOOP;

package/script/test-utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"test-utils.js","sourceRoot":"","sources":["../src/test-utils.ts"],"names":[],"mappings":";;;AA2TA,wBAEC;AA+GD,0BAEC;AAjaD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACU,QAAA,IAAI,GAAQ,IAAI,KAAK,CAChC;IACE,OAAO,YAAI,CAAA;AACb,CAAC,EACD;IACE,GAAG,CAAC,CAAC,EAAE,IAAI;QACT,QAAQ,IAAI,EAAE,CAAC;YACb,KAAK,MAAM;gBACT,OAAO,SAAS,CAAA;YAClB,KAAK,SAAS,CAAC;YACf,KAAK,UAAU,CAAC;YAChB,KAAK,MAAM,CAAC,WAAW;gBACrB,OAAO,GAAG,EAAE,CAAC,QAAQ,CAAA;YACvB;gBACE,OAAO,YAAI,CAAA;QACf,CAAC;IACH,CAAC;CACF,CACF,CAAA;AAkQD,SAAgB,MAAM;IACpB,OAAO,YAAI,CAAA;AACb,CAAC;AA+GD,SAAgB,OAAO;IACrB,OAAO,YAAI,CAAA;AACb,CAAC","sourcesContent":["// deno-lint-ignore-file no-explicit-any\nimport type {\n  Diff,\n  Disjoint,\n  Extends,\n  If,\n  MutuallyAssignable,\n  Overlap,\n  ProperExtend,\n  SafePick,\n  Same,\n} from './main/index.js'\n\n/**\n * A universal no-op placeholder implemented via `Proxy`.\n *\n * `NOOP` can be accessed, called, or chained indefinitely without throwing.\n * Every operation returns itself, making it safe to use as a dummy fallback\n * for APIs, optional hooks, or unimplemented interfaces.\n *\n * ### Special behaviors\n *\n * - Callable: invoking `NOOP()` returns `NOOP`\n * - Property access: `NOOP.anything` returns `NOOP`\n * - Promise-safe: `NOOP.then` is `undefined`, so it is not treated as a Promise\n * - Primitive coercion (`toString`, `valueOf`, `Symbol.toPrimitive`) yields\n *   a stable string representation: `\"[NOOP]\"`\n *\n * This is useful in scenarios where a value is required syntactically but\n * should perform no action and never fail at runtime.\n *\n * ### Examples\n *\n * ```ts\n * NOOP.foo.bar().baz.qux; // safe, returns NOOP\n * String(NOOP); // \"[NOOP]\"\n * await NOOP; // does not await (not thenable)\n * ```\n */\nexport const NOOP: any = new Proxy(\n  function () {\n    return NOOP\n  },\n  {\n    get(_, prop) {\n      switch (prop) {\n        case 'then':\n          return undefined\n        case 'valueOf':\n        case 'toString':\n        case Symbol.toPrimitive:\n          return () => '[NOOP]'\n        default:\n          return NOOP\n      }\n    },\n  },\n)\n\n/**\n * Represents the result of a type assertion based on a boolean condition.\n * If the condition is true, the result has a `success` property; otherwise, it has a `fail` property.\n *\n * @template B The boolean condition result (true or false)\n * @template R The type of the result value (default is void)\n */\ntype Result<B extends true | false, R = void> = B extends true ? {\n    /**\n     * ## Expect to succeed without type error\n     */\n    success: R\n  }\n  : {\n    /**\n     * ## Expect to fail with type error\n     */\n    fail: R\n  }\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 * ### Examples\n *\n * ```ts\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}>().toHaveProperty<'name'>().success\n * ```\n */\nexport type ExpectType<T, H extends PropertyKey = never> = Omit<\n  (\n    & {\n      T: T\n      inspect: { [K in keyof T]: T[K] }\n\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       * ### Examples\n       *\n       * ```ts\n       * expect<any>().toBe<any>().success\n       * expect<never>().toBe<never>().success\n       * expect<false>().toBe<true>().fail\n       * ```\n       */\n      toBe<U>(): Result<Same<T, U>>\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       * ### Examples\n       *\n       * ```ts\n       * expect<3.14>().toExtend<number>().success\n       * expect<2>().toExtend<string>().fail\n       * expect<'hello'>().toExtend<string>().success\n       * ```\n       */\n      toExtend<U>(): Result<Extends<T, U>>\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       * ### Examples\n       *\n       * ```ts\n       * expect<2>().toProperExtend<number>().success\n       * expect<'a' | 'b'>().toProperExtend<string>().success\n       * expect<number>().toProperExtend<number>().fail\n       * ```\n       */\n      toProperExtend<U>(): Result<ProperExtend<T, U>>\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       * ### Examples\n       *\n       * ```ts\n       * type WithProp = { prop: string; another: number }\n       * expect<WithProp>().toHaveProperty<'prop'>().success\n       * expect<WithProp>().toHaveProperty<'another'>().success\n       * expect<WithProp>().toHaveProperty<'missing'>().fail\n       * ```\n       */\n      toHaveProperty<K extends PropertyKey>(): Result<Extends<K, keyof T>>\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         * ### Examples\n         *\n         * ```ts\n         * expect<3.14>().toExtendNumber // Available and would succeed\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         * ### Examples\n         *\n         * ```ts\n         * expect<'hello'>().toExtendString // Available and would succeed\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         * ### Examples\n         *\n         * ```ts\n         * expect<true>().toExtendBoolean // Available and would succeed\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         * Tests if the current type is exactly `any`.\n         * Available only if the current type is `any`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<any>().toBeAny // Available and would succeed\n         * ```\n         */\n        toBeAny: ExpectType<T, H | 'toBeAny' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `never`.\n         * Available only if the current type is `never`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<never>().toBeNever // Available and would succeed\n         * ```\n         */\n        toBeNever: ExpectType<T, H | 'toBeNever' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `unknown`.\n         * Available only if the current type is `unknown`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<unknown>().toBeUnknown // Available and would succeed\n         * ```\n         */\n        toBeUnknown: ExpectType<T, H | 'toBeUnknown' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `void`.\n         * Available only if the current type is `void`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<void>().toBeVoid // Available and would succeed\n         * ```\n         */\n        toBeVoid: ExpectType<T, H | 'toBeVoid' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `true` (boolean literal).\n         * Available only if the current type is `true`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<true>().toBeTrue // Available and would succeed\n         * ```\n         */\n        toBeTrue: ExpectType<T, H | 'toBeTrue' | 'toBe' | 'toExtendBoolean'>\n\n        /**\n         * Tests if the current type is exactly `false` (boolean literal).\n         * Available only if the current type is `false`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<false>().toBeFalse // Available and would succeed\n         * ```\n         */\n        toBeFalse: ExpectType<T, H | 'toBeFalse' | 'toBe' | 'toExtendBoolean'>\n      },\n      | If<Same<T, any>, 'toBeAny'>\n      | If<Same<T, never>, 'toBeNever'>\n      | If<Same<T, unknown>, 'toBeUnknown'>\n      | If<Same<T, void>, 'toBeVoid'>\n      | If<Same<T, true>, 'toBeTrue'>\n      | If<Same<T, false>, 'toBeFalse'>\n    >\n  ),\n  H\n>\n\n/**\n * Creates an instance of ExpectType to perform type-level assertions on the given type.\n * This function enables testing various type relationships at compile time.\n * NOTE: This function does nothing at runtime and is purely for type-level testing.\n *\n * @template T The type to be tested\n *\n * @returns An ExpectType instance with methods to test type relationships\n *\n * ### Examples\n *\n * ```ts\n * // Test exact type equality\n * expect<number>().toBe<number>().success\n * expect<number>().toBe<string>().fail\n * // Test if one type extends another\n * expect<3.14>().toExtend<number>().success\n * expect<2>().toExtend<string>().fail\n * ```\n */\nexport function expect<T>(): ExpectType<T>\nexport function expect<T>(_: T): ExpectType<T>\nexport function expect<T>(): ExpectType<T> {\n  return NOOP\n}\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 * ### Examples\n *\n * ```ts\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       * ### Examples\n       *\n       * ```ts\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       * ### Examples\n       *\n       * ```ts\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       * ### Examples\n       *\n       * ```ts\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       * ### Examples\n       *\n       * ```ts\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       * ### Examples\n       *\n       * ```ts\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<Same<T, U>, 'same'>\n    | If<Diff<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\n/**\n * Creates an instance of CompareTypes to perform type-level comparisons between two types.\n * This function enables testing various relationships between types at compile time.\n * NOTE: This function does nothing at runtime and is purely for type-level testing.\n *\n * @template T First type to compare\n * @template U Second type to compare\n *\n * @returns A CompareTypes instance with methods to test relationships between T and U\n *\n * ### Examples\n *\n * ```ts\n * // Compare two identical types\n * compare<number, number>().same // Results in an available property\n * // Compare two different but overlapping types\n * compare<4, number>().overlap.different // Results in available properties\n * ```\n */\nexport function compare<T, U>(): CompareTypes<T, U>\nexport function compare<T, U>(t: T, u: U): CompareTypes<T, U>\nexport function compare<T, U>(): CompareTypes<T, U> {\n  return NOOP\n}\n"]}
+{"version":3,"file":"test-utils.js","sourceRoot":"","sources":["../src/test-utils.ts"],"names":[],"mappings":";;;AAmUA,wBAEC;AA+GD,0BAEC;AAzaD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACU,QAAA,IAAI,GAAQ,IAAI,KAAK,CAChC;IACE,OAAO,YAAI,CAAA;AACb,CAAC,EACD;IACE,GAAG,CAAC,CAAC,EAAE,IAAI;QACT,QAAQ,IAAI,EAAE,CAAC;YACb,KAAK,MAAM;gBACT,OAAO,SAAS,CAAA;YAClB,KAAK,SAAS,CAAC;YACf,KAAK,UAAU,CAAC;YAChB,KAAK,MAAM,CAAC,WAAW;gBACrB,OAAO,GAAG,EAAE,CAAC,QAAQ,CAAA;YACvB;gBACE,OAAO,YAAI,CAAA;QACf,CAAC;IACH,CAAC;IACD,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI;IACf,wBAAwB,EAAE,GAAG,EAAE,CAAC,CAAC;QAC/B,YAAY,EAAE,IAAI;QAClB,KAAK,EAAE,YAAI;KACZ,CAAC;IACF,cAAc,EAAE,GAAG,EAAE,CAAC,IAAI;IAC1B,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI;IACf,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,WAAW,CAAC;CAC7B,CACF,CAAA;AAkQD,SAAgB,MAAM;IACpB,OAAO,YAAI,CAAA;AACb,CAAC;AA+GD,SAAgB,OAAO;IACrB,OAAO,YAAI,CAAA;AACb,CAAC","sourcesContent":["// deno-lint-ignore-file no-explicit-any\nimport type {\n  Diff,\n  Disjoint,\n  Extends,\n  If,\n  MutuallyAssignable,\n  Overlap,\n  ProperExtend,\n  SafePick,\n  Same,\n} from './main/index.js'\n\n/**\n * A universal no-op placeholder implemented via `Proxy`.\n *\n * `NOOP` can be accessed, called, or chained indefinitely without throwing.\n * Every operation returns itself, making it safe to use as a dummy fallback\n * for APIs, optional hooks, or unimplemented interfaces.\n *\n * ### Special behaviors\n *\n * - Callable: invoking `NOOP()` returns `NOOP`\n * - Property access: `NOOP.anything` returns `NOOP`\n * - Promise-safe: `NOOP.then` is `undefined`, so it is not treated as a Promise\n * - Primitive coercion (`toString`, `valueOf`, `Symbol.toPrimitive`) yields\n *   a stable string representation: `\"[NOOP]\"`\n *\n * This is useful in scenarios where a value is required syntactically but\n * should perform no action and never fail at runtime.\n *\n * ### Examples\n *\n * ```ts\n * NOOP.foo.bar().baz.qux; // safe, returns NOOP\n * String(NOOP); // \"[NOOP]\"\n * await NOOP; // does not await (not thenable)\n * ```\n */\nexport const NOOP: any = new Proxy(\n  function () {\n    return NOOP\n  },\n  {\n    get(_, prop) {\n      switch (prop) {\n        case 'then':\n          return undefined\n        case 'valueOf':\n        case 'toString':\n        case Symbol.toPrimitive:\n          return () => '[NOOP]'\n        default:\n          return NOOP\n      }\n    },\n    set: () => true,\n    getOwnPropertyDescriptor: () => ({\n      configurable: true,\n      value: NOOP,\n    }),\n    getPrototypeOf: () => null,\n    has: () => true,\n    ownKeys: () => ['prototype'],\n  },\n)\n\n/**\n * Represents the result of a type assertion based on a boolean condition.\n * If the condition is true, the result has a `success` property; otherwise, it has a `fail` property.\n *\n * @template B The boolean condition result (true or false)\n * @template R The type of the result value (default is void)\n */\ntype Result<B extends true | false, R = void> = B extends true ? {\n    /**\n     * ## Expect to succeed without type error\n     */\n    success: R\n  }\n  : {\n    /**\n     * ## Expect to fail with type error\n     */\n    fail: R\n  }\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 * ### Examples\n *\n * ```ts\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}>().toHaveProperty<'name'>().success\n * ```\n */\nexport type ExpectType<T, H extends PropertyKey = never> = Omit<\n  (\n    & {\n      T: T\n      inspect: { [K in keyof T]: T[K] }\n\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       * ### Examples\n       *\n       * ```ts\n       * expect<any>().toBe<any>().success\n       * expect<never>().toBe<never>().success\n       * expect<false>().toBe<true>().fail\n       * ```\n       */\n      toBe<U>(): Result<Same<T, U>>\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       * ### Examples\n       *\n       * ```ts\n       * expect<3.14>().toExtend<number>().success\n       * expect<2>().toExtend<string>().fail\n       * expect<'hello'>().toExtend<string>().success\n       * ```\n       */\n      toExtend<U>(): Result<Extends<T, U>>\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       * ### Examples\n       *\n       * ```ts\n       * expect<2>().toProperExtend<number>().success\n       * expect<'a' | 'b'>().toProperExtend<string>().success\n       * expect<number>().toProperExtend<number>().fail\n       * ```\n       */\n      toProperExtend<U>(): Result<ProperExtend<T, U>>\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       * ### Examples\n       *\n       * ```ts\n       * type WithProp = { prop: string; another: number }\n       * expect<WithProp>().toHaveProperty<'prop'>().success\n       * expect<WithProp>().toHaveProperty<'another'>().success\n       * expect<WithProp>().toHaveProperty<'missing'>().fail\n       * ```\n       */\n      toHaveProperty<K extends PropertyKey>(): Result<Extends<K, keyof T>>\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         * ### Examples\n         *\n         * ```ts\n         * expect<3.14>().toExtendNumber // Available and would succeed\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         * ### Examples\n         *\n         * ```ts\n         * expect<'hello'>().toExtendString // Available and would succeed\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         * ### Examples\n         *\n         * ```ts\n         * expect<true>().toExtendBoolean // Available and would succeed\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         * Tests if the current type is exactly `any`.\n         * Available only if the current type is `any`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<any>().toBeAny // Available and would succeed\n         * ```\n         */\n        toBeAny: ExpectType<T, H | 'toBeAny' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `never`.\n         * Available only if the current type is `never`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<never>().toBeNever // Available and would succeed\n         * ```\n         */\n        toBeNever: ExpectType<T, H | 'toBeNever' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `unknown`.\n         * Available only if the current type is `unknown`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<unknown>().toBeUnknown // Available and would succeed\n         * ```\n         */\n        toBeUnknown: ExpectType<T, H | 'toBeUnknown' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `void`.\n         * Available only if the current type is `void`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<void>().toBeVoid // Available and would succeed\n         * ```\n         */\n        toBeVoid: ExpectType<T, H | 'toBeVoid' | 'toBe'>\n\n        /**\n         * Tests if the current type is exactly `true` (boolean literal).\n         * Available only if the current type is `true`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<true>().toBeTrue // Available and would succeed\n         * ```\n         */\n        toBeTrue: ExpectType<T, H | 'toBeTrue' | 'toBe' | 'toExtendBoolean'>\n\n        /**\n         * Tests if the current type is exactly `false` (boolean literal).\n         * Available only if the current type is `false`.\n         *\n         * ### Examples\n         *\n         * ```ts\n         * expect<false>().toBeFalse // Available and would succeed\n         * ```\n         */\n        toBeFalse: ExpectType<T, H | 'toBeFalse' | 'toBe' | 'toExtendBoolean'>\n      },\n      | If<Same<T, any>, 'toBeAny'>\n      | If<Same<T, never>, 'toBeNever'>\n      | If<Same<T, unknown>, 'toBeUnknown'>\n      | If<Same<T, void>, 'toBeVoid'>\n      | If<Same<T, true>, 'toBeTrue'>\n      | If<Same<T, false>, 'toBeFalse'>\n    >\n  ),\n  H\n>\n\n/**\n * Creates an instance of ExpectType to perform type-level assertions on the given type.\n * This function enables testing various type relationships at compile time.\n * NOTE: This function does nothing at runtime and is purely for type-level testing.\n *\n * @template T The type to be tested\n *\n * @returns An ExpectType instance with methods to test type relationships\n *\n * ### Examples\n *\n * ```ts\n * // Test exact type equality\n * expect<number>().toBe<number>().success\n * expect<number>().toBe<string>().fail\n * // Test if one type extends another\n * expect<3.14>().toExtend<number>().success\n * expect<2>().toExtend<string>().fail\n * ```\n */\nexport function expect<T>(): ExpectType<T>\nexport function expect<T>(_: T): ExpectType<T>\nexport function expect<T>(): ExpectType<T> {\n  return NOOP\n}\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 * ### Examples\n *\n * ```ts\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       * ### Examples\n       *\n       * ```ts\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       * ### Examples\n       *\n       * ```ts\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       * ### Examples\n       *\n       * ```ts\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       * ### Examples\n       *\n       * ```ts\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       * ### Examples\n       *\n       * ```ts\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<Same<T, U>, 'same'>\n    | If<Diff<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\n/**\n * Creates an instance of CompareTypes to perform type-level comparisons between two types.\n * This function enables testing various relationships between types at compile time.\n * NOTE: This function does nothing at runtime and is purely for type-level testing.\n *\n * @template T First type to compare\n * @template U Second type to compare\n *\n * @returns A CompareTypes instance with methods to test relationships between T and U\n *\n * ### Examples\n *\n * ```ts\n * // Compare two identical types\n * compare<number, number>().same // Results in an available property\n * // Compare two different but overlapping types\n * compare<4, number>().overlap.different // Results in available properties\n * ```\n */\nexport function compare<T, U>(): CompareTypes<T, U>\nexport function compare<T, U>(t: T, u: U): CompareTypes<T, U>\nexport function compare<T, U>(): CompareTypes<T, U> {\n  return NOOP\n}\n"]}