tstyche 6.0.0-beta.3 → 6.0.0-beta.5

package/dist/index.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+function noop() {
+}
+const noopChain = new Proxy(noop, {
+    apply() {
+        return noopChain;
+    },
+    get() {
+        return noopChain;
+    },
+});
+
+exports.describe = noopChain;
+exports.expect = noopChain;
+exports.it = noopChain;
+exports.omit = noop;
+exports.pick = noop;
+exports.test = noopChain;
+exports.when = noopChain;

package/dist/index.d.cts

@@ -0,0 +1,255 @@
+interface Describe {
+    /**
+     * Defines a group of tests.
+     *
+     * @param name - The name of the group.
+     * @param callback - The function to create a scope for a group of tests.
+     */
+    (name: string, callback: () => void | Promise<void>): void;
+    /**
+     * Marks a group of tests as focused.
+     *
+     * @param name - The name of the group.
+     * @param callback - The function to create a scope for a group of tests.
+     */
+    only: (name: string, callback: () => void | Promise<void>) => void;
+    /**
+     * Marks a group of tests as skipped.
+     *
+     * @param name - The name of the group.
+     * @param callback - The function to create a scope for a group of tests.
+     */
+    skip: (name: string, callback: () => void | Promise<void>) => void;
+    /**
+     * Marks a group of tests as yet to be implemented.
+     *
+     * @param name - The name of the group.
+     * @param callback - The function to create a scope for a group of tests.
+     */
+    todo: (name: string, callback?: () => void | Promise<void>) => void;
+}
+interface Test {
+    /**
+     * Defines a single test.
+     *
+     * @param name - The name of the test.
+     * @param callback - The function with a code snippet and assertions.
+     */
+    (name: string, callback: () => void | Promise<void>): void;
+    /**
+     * Marks a test as focused.
+     *
+     * @param name - The name of the test.
+     * @param callback - The function with a code snippet and assertions.
+     */
+    only: (name: string, callback: () => void | Promise<void>) => void;
+    /**
+     * Marks a test as skipped.
+     *
+     * @param name - The name of the test.
+     * @param callback - The function with a code snippet and assertions.
+     */
+    skip: (name: string, callback: () => void | Promise<void>) => void;
+    /**
+     * Marks a test as yet to be implemented.
+     *
+     * @param name - The name of the test.
+     * @param callback - The function with a code snippet and assertions.
+     */
+    todo: (name: string, callback?: () => void | Promise<void>) => void;
+}
+interface Matchers {
+    /**
+     * Checks if the JSX component accepts props of the given type.
+     *
+     * @remarks
+     *
+     * This is a work in progress feature. Generic components are not yet supported.
+     */
+    toAcceptProps: {
+        /**
+         * Checks if the JSX component accepts props of the given type.
+         *
+         * @remarks
+         *
+         * This is a work in progress feature. Generic components are not yet supported.
+         */
+        <Target>(): void;
+        /**
+         * Checks if the JSX component accepts the given props.
+         *
+         * @remarks
+         *
+         * This is a work in progress feature. Generic components are not yet supported.
+         */
+        (target: unknown): void;
+    };
+    /**
+     * Checks if the source type is the same as the target type.
+     */
+    toBe: {
+        /**
+         * Checks if the source type is the same as the target type.
+         */
+        <Target>(): void;
+        /**
+         * Checks if the source type is the same as type of the target expression.
+         */
+        (target: unknown): void;
+    };
+    /**
+     * Checks if the decorator function can be applied.
+     */
+    toBeApplicable: (target: unknown, context: DecoratorContext) => void;
+    /**
+     * Checks if the source type is assignable from the target type.
+     */
+    toBeAssignableFrom: {
+        /**
+         * Checks if the source type is assignable from the target type.
+         */
+        <Target>(): void;
+        /**
+         * Checks if the source type is assignable from type of the target expression.
+         */
+        (target: unknown): void;
+    };
+    /**
+     * Checks if the source type is assignable to the target type.
+     */
+    toBeAssignableTo: {
+        /**
+         * Checks if the source type is assignable to the target type.
+         */
+        <Target>(): void;
+        /**
+         * Checks if the source type is assignable to type of the target expression.
+         */
+        (target: unknown): void;
+    };
+    /**
+     * Checks if the source type is callable with the given arguments.
+     */
+    toBeCallableWith: (...args: Array<unknown>) => void;
+    /**
+     * Checks if the source type is constructable with the given arguments.
+     */
+    toBeConstructableWith: (...args: Array<unknown>) => void;
+    /**
+     * Checks if a property key exists on the source type.
+     */
+    toHaveProperty: (key: string | number | symbol) => void;
+    /**
+     * Checks if the source type raises an error.
+     */
+    toRaiseError: (...target: Array<string | number | RegExp>) => void;
+}
+interface Modifier {
+    /**
+     * Indicates a type-level assertion.
+     */
+    type: Matchers & {
+        /**
+         * Negates the assertion.
+         */
+        not: Matchers;
+    };
+}
+interface Expect {
+    /**
+     * Builds an assertion.
+     *
+     * @template Source - The type which is checked.
+     */
+    <Source>(): Modifier;
+    /**
+     * Builds an assertion.
+     *
+     * @param source - The expression whose type is checked.
+     */
+    (source: unknown): Modifier;
+    /**
+     * Marks an assertion as focused.
+     */
+    only: {
+        /**
+         * Marks an assertion as focused.
+         *
+         * @template Source - The type which is checked.
+         */
+        <Source>(): Modifier;
+        /**
+         * Marks an assertion as focused.
+         *
+         * @param source - The expression whose type is checked.
+         */
+        (source: unknown): Modifier;
+    };
+    /**
+     * Marks an assertion as skipped.
+     */
+    skip: {
+        /**
+         * Marks an assertion as skipped.
+         *
+         * @template Source - The type which is checked.
+         */
+        <Source>(): Modifier;
+        /**
+         * Marks an assertion as skipped.
+         *
+         * @param source - The expression whose type is checked.
+         */
+        (source: unknown): Modifier;
+    };
+}
+/**
+ * Builds an assertion.
+ */
+declare const expect: Expect;
+/**
+ * Reshapes type of the given object by removing the specified keys.
+ */
+declare function omit<T, K extends PropertyKey>(object: T, ...keys: [K, ...Array<K>]): Omit<T, K>;
+/**
+ * Reshapes type of the given object by keeping only the specified keys.
+ */
+declare function pick<T, K extends keyof T>(object: T, ...keys: [K, ...Array<K>]): Pick<T, K>;
+/**
+ * Defines a test group.
+ */
+declare const describe: Describe;
+/**
+ * Defines a single test.
+ */
+declare const it: Test;
+/**
+ * Defines a single test.
+ */
+declare const test: Test;
+interface Actions {
+    /**
+     * Calls the given function with the provided arguments.
+     */
+    isCalledWith: (...args: Array<unknown>) => void;
+}
+interface When {
+    /**
+     * Creates a test plan.
+     *
+     * @template Target - The type upon which an action is performed.
+     */
+    <Target>(): Actions;
+    /**
+     * Creates a test plan.
+     *
+     * @param target - The expression upon which an action is performed.
+     */
+    (target: unknown): Actions;
+}
+/**
+ * Creates a test plan.
+ */
+declare const when: When;
+
+export { describe, expect, it, omit, pick, test, when };

package/dist/tstyche.js

@@ -4550,9 +4550,6 @@ class ToAcceptProps {
     }
 }
 
-function ensureArray(input) {
-    return input ?? [];
-}
 function getIndexSignatures(type, compiler, typeChecker) {
     if (type.flags & compiler.TypeFlags.Intersection) {
         return type.types.flatMap((type) => getIndexSignatures(type, compiler, typeChecker));
@@ -4565,6 +4562,12 @@ function getSignatures(type, kind, compiler, typeChecker) {
     }
     return typeChecker.getSignaturesOfType(type, kind);
 }
+function getThisTypeOfSignature(signature, typeChecker) {
+    return signature.thisParameter && typeChecker.getTypeOfSymbol(signature.thisParameter);
+}
+function getTypeParametersOfSignature(signature) {
+    return signature.typeParameters ?? [];
+}
 function getTypeParameterModifiers(typeParameter, compiler) {
     if (!typeParameter.symbol.declarations) {
         return compiler.ModifierFlags.None;
@@ -4583,9 +4586,6 @@ function isCheckFlagSet(symbol, flag, compiler) {
 function isSymbolFromDefaultLibrary(symbol, program) {
     return !!symbol.declarations?.every((declaration) => program.isSourceFileDefaultLibrary(declaration.getSourceFile()));
 }
-function length(array) {
-    return array?.length ?? 0;
-}
 
 function getParameterFactsFromTuple(type, position, compiler) {
     return {
@@ -4688,11 +4688,6 @@ class Structure {
         }
         return !a && !b;
     }
-    #compareTypeOfSymbol(a, b) {
-        const aTypeOfSymbol = a && this.#typeChecker.getTypeOfSymbol(a);
-        const bTypeOfSymbol = b && this.#typeChecker.getTypeOfSymbol(b);
-        return this.#compareMaybeNullish(aTypeOfSymbol, bTypeOfSymbol);
-    }
     compare(a, b) {
         a = this.#normalize(a);
         b = this.#normalize(b);
@@ -4756,6 +4751,18 @@ class Structure {
             }
             return false;
         }
+        if ((a.flags | b.flags) & this.#compiler.TypeFlags.TemplateLiteral) {
+            if (a.flags & b.flags & this.#compiler.TypeFlags.TemplateLiteral) {
+                return this.compareTemplateLiteralTypes(a, b);
+            }
+            return false;
+        }
+        if ((a.flags | b.flags) & this.#compiler.TypeFlags.StringMapping) {
+            if (a.flags & b.flags & this.#compiler.TypeFlags.StringMapping) {
+                return this.compareStringMappingTypes(a, b);
+            }
+            return false;
+        }
         return false;
     }
     compareIntersections(a, b) {
@@ -4789,16 +4796,18 @@ class Structure {
         if ((a.objectFlags | b.objectFlags) & this.#compiler.ObjectFlags.Class) {
             return this.compareStructuredTypes(a, b);
         }
-        if (!this.#compareTypeOfSymbol(a.symbol, b.symbol)) {
+        if (a.symbol !== b.symbol) {
             if (isSymbolFromDefaultLibrary(a.symbol, this.#program) || isSymbolFromDefaultLibrary(b.symbol, this.#program)) {
                 return false;
             }
             return;
         }
-        if (length(a.typeArguments) !== length(b.typeArguments)) {
+        const aTypeArguments = this.#typeChecker.getTypeArguments(a);
+        const bTypeArguments = this.#typeChecker.getTypeArguments(b);
+        if (aTypeArguments.length !== bTypeArguments.length) {
             return false;
         }
-        return ensureArray(a.typeArguments).every((type, i) => this.compare(type, ensureArray(b.typeArguments)[i]));
+        return aTypeArguments.every((type, i) => this.compare(type, bTypeArguments[i]));
     }
     compareTuples(a, b) {
         if (a.target.readonly !== b.target.readonly) {
@@ -4806,7 +4815,7 @@ class Structure {
         }
         const aTypeArguments = this.#typeChecker.getTypeArguments(a);
         const bTypeArguments = this.#typeChecker.getTypeArguments(b);
-        if (length(aTypeArguments) !== length(bTypeArguments)) {
+        if (aTypeArguments.length !== bTypeArguments.length) {
             return false;
         }
         for (let i = 0; i < aTypeArguments.length; i++) {
@@ -4888,17 +4897,17 @@ class Structure {
         return true;
     }
     #compareSignature(a, b) {
-        if (length(a.typeParameters) !== length(b.typeParameters)) {
+        const aTypeParameters = getTypeParametersOfSignature(a);
+        const bTypeParameters = getTypeParametersOfSignature(b);
+        if (aTypeParameters.length !== bTypeParameters.length) {
             return false;
         }
-        if (a.typeParameters != null && b.typeParameters != null) {
-            for (let i = 0; i < a.typeParameters.length; i++) {
-                if (!this.compareTypeParameters(a.typeParameters[i], b.typeParameters[i])) {
-                    return false;
-                }
+        for (let i = 0; i < aTypeParameters.length; i++) {
+            if (!this.compareTypeParameters(aTypeParameters[i], bTypeParameters[i])) {
+                return false;
             }
         }
-        if (!this.#compareTypeOfSymbol(a.thisParameter, b.thisParameter)) {
+        if (!this.#compareMaybeNullish(getThisTypeOfSignature(a, this.#typeChecker), getThisTypeOfSignature(b, this.#typeChecker))) {
             return false;
         }
         if (!this.compareParameters(a, b)) {
@@ -5000,14 +5009,33 @@ class Structure {
         }
         return true;
     }
+    compareTemplateLiteralTypes(a, b) {
+        if (a.texts.length !== b.texts.length) {
+            return false;
+        }
+        for (let i = 0; i < a.texts.length; i++) {
+            if (a.texts[i] !== b.texts[i]) {
+                return false;
+            }
+            if (!this.#compareMaybeNullish(a.types[i], b.types[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    compareStringMappingTypes(a, b) {
+        if (a.symbol !== b.symbol) {
+            return false;
+        }
+        if (!this.compare(a.type, b.type)) {
+            return false;
+        }
+        return true;
+    }
     #normalize(type) {
         if (type.flags & this.#compiler.TypeFlags.Freshable && type.freshType === type) {
             return type.regularType;
         }
-        if (type.flags & this.#compiler.TypeFlags.Substitution &&
-            type.constraint.flags & this.#compiler.TypeFlags.Unknown) {
-            return type.baseType;
-        }
         if (type.flags & this.#compiler.TypeFlags.UnionOrIntersection) {
             const candidateType = this.#normalize(type.types[0]);
             if (type.types.every((t) => this.compare(this.#normalize(t), candidateType))) {
@@ -5872,7 +5900,7 @@ class FileRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "6.0.0-beta.3";
+    static version = "6.0.0-beta.5";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tstyche",
-  "version": "6.0.0-beta.3",
+  "version": "6.0.0-beta.5",
   "description": "Everything You Need for Type Testing.",
   "keywords": [
     "typescript",
@@ -21,11 +21,15 @@
   "license": "MIT",
   "type": "module",
   "exports": {
-    ".": "./dist/index.js",
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
     "./tstyche": "./dist/tstyche.js",
     "./package.json": "./package.json"
   },
   "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "bin": "./dist/bin.js",
   "peerDependencies": {
     "typescript": ">=5.4"