lay-sing 0.1.0

package/script/test-utils.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOOP = void 0;
+exports.expect = expect;
+exports.compare = compare;
+/**
+ * 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.
+ *
+ * ### Special behaviors
+ *
+ * - Callable: invoking `NOOP()` returns `NOOP`
+ * - Property access: `NOOP.anything` returns `NOOP`
+ * - Promise-safe: `NOOP.then` is `undefined`, so it is not treated as a Promise
+ * - Primitive coercion (`toString`, `valueOf`, `Symbol.toPrimitive`) yields
+ *   a stable string representation: `"[NOOP]"`
+ *
+ * This is useful in scenarios where a value is required syntactically but
+ * should perform no action and never fail at runtime.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * NOOP.foo.bar().baz.qux; // safe, returns NOOP
+ * String(NOOP); // "[NOOP]"
+ * await NOOP; // does not await (not thenable)
+ * ```
+ */
+exports.NOOP = new Proxy(function () {
+    return exports.NOOP;
+}, {
+    get(_, prop) {
+        switch (prop) {
+            case 'then':
+                return undefined;
+            case 'valueOf':
+            case 'toString':
+            case Symbol.toPrimitive:
+                return () => '[NOOP]';
+            default:
+                return exports.NOOP;
+        }
+    },
+});
+function expect() {
+    return exports.NOOP;
+}
+function compare() {
+    return exports.NOOP;
+}
+//# sourceMappingURL=test-utils.js.map

package/script/test-utils.js.map

@@ -0,0 +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"]}