tstyche 7.2.0 → 7.2.1

package/dist/api.js

@@ -609,7 +609,7 @@ class Fetcher {
     }
     async get(request, diagnostic, options) {
         let delay = 3000;
-        request.headers.set("User-Agent", `tstyche/${"7.2.0"} ${process.platform} ${process.arch}`);
+        request.headers.set("User-Agent", `tstyche/${"7.2.1"} ${process.platform} ${process.arch}`);
         for (let attempt = 0; attempt <= this.#retries; attempt++) {
             const isLastAttempt = attempt === this.#retries;
             const suppressErrors = options?.suppressErrors || !isLastAttempt;
@@ -3430,6 +3430,11 @@ class AbilityLayer {
                 const targetNode = expect.target?.[0];
                 if (!sourceNode ||
                     !targetNode ||
+                    !(this.#compiler.isIdentifier(sourceNode) ||
+                        this.#compiler.isPropertyAccessExpression(sourceNode) ||
+                        this.#compiler.isTypeReferenceNode(sourceNode) ||
+                        this.#compiler.isExpressionWithTypeArguments(sourceNode)) ||
+                    !/^[A-Z_$]/.test(sourceNode.getText()[0]) ||
                     !this.#compiler.isObjectLiteralExpression(targetNode) ||
                     !targetNode.properties.every((property) => (this.#compiler.isPropertyAssignment(property) &&
                         (this.#compiler.isIdentifier(property.name) || this.#compiler.isStringLiteral(property.name))) ||
@@ -3455,20 +3460,22 @@ class AbilityLayer {
                 for (const property of targetNode.properties) {
                     if (this.#compiler.isPropertyAssignment(property)) {
                         this.#editor
-                            .update(property.name.getStart(), property.name.getEnd() + 1, this.#compiler.isStringLiteral(property.name)
-                            ? ` ${property.name.getText().slice(1, -1)} =`
-                            : property.name.getText() + "=")
-                            .update(property.initializer.getStart(), property.initializer.getStart(), "{")
-                            .update(property.initializer.getStart(), property.initializer.getEnd(), property.initializer.getText() + "}");
+                            .update(property.name.getStart(), property.name.getEnd(), this.#compiler.isStringLiteral(property.name)
+                            ? ` ${property.name.getText().slice(1, -1)} `
+                            : property.name.getText())
+                            .insert(property.initializer.getStart(), "={")
+                            .update(property.initializer.getStart(), property.initializer.getEnd(), property.initializer.getText())
+                            .insert(property.initializer.getEnd(), "}");
                         continue;
                     }
                     if (this.#compiler.isSpreadAssignment(property)) {
                         this.#editor
-                            .update(property.getStart(), property.getStart(), "{")
-                            .update(property.getStart(), property.getEnd(), property.getText() + "}");
+                            .insert(property.getStart(), "{")
+                            .update(property.getStart(), property.getEnd(), property.getText())
+                            .insert(property.getEnd(), "}");
                     }
                 }
-                this.#editor.update(matcherNodeEnd, matcherNodeEnd, "/>");
+                this.#editor.insert(matcherNodeEnd, "/>");
                 break;
             }
             case "toBeApplicable":
@@ -3687,6 +3694,10 @@ class TextEditor {
         }
         return this;
     }
+    insert(position, text) {
+        this.update(position, position, text);
+        return this;
+    }
     #getErased(start, end) {
         if (this.#text.indexOf("\n", start) >= end) {
             return " ".repeat(end - start);
@@ -4425,6 +4436,20 @@ class Ensure {
         }
         return true;
     }
+    jsxSetup(program, node, onDiagnostics) {
+        const diagnosticText = [];
+        if (!program.getCompilerOptions().jsx) {
+            diagnosticText.push("The matcher requires the 'jsx' compiler option to be configured.");
+        }
+        if (node.getSourceFile().languageVariant !== this.#compiler.LanguageVariant.JSX) {
+            diagnosticText.push("The matcher requires a '.tsx' file extension.");
+        }
+        if (diagnosticText.length > 0) {
+            this.#emitDiagnostic(diagnosticText, node, onDiagnostics);
+            return false;
+        }
+        return true;
+    }
     typeArgument(node, enclosingNode, onDiagnostics) {
         if (!node || nodeBelongsToArgumentList(this.#compiler, node)) {
             this.#emitDiagnostic("A type argument must be provided.", enclosingNode, onDiagnostics);
@@ -4433,8 +4458,11 @@ class Ensure {
         return true;
     }
     #emitDiagnostic(text, enclosingNode, onDiagnostics) {
+        if (!Array.isArray(text)) {
+            text = [text];
+        }
         const origin = DiagnosticOrigin.fromNode(enclosingNode);
-        onDiagnostics([Diagnostic.error(text, origin)]);
+        onDiagnostics(text.map((text) => Diagnostic.error(text, origin)));
     }
 }
 
@@ -4529,7 +4557,6 @@ class ExpectDiagnosticText {
 class MatchWorker {
     assertionNode;
     #compiler;
-    #signatureCache = new Map();
     typeChecker;
     constructor(compiler, program, assertionNode) {
         this.#compiler = compiler;
@@ -4553,17 +4580,6 @@ class MatchWorker {
             : { flags: this.#compiler.TypeFlags.NonPrimitive };
         return this.typeChecker.isTypeAssignableTo(type, nonPrimitiveType);
     }
-    getSignatures(node) {
-        let signatures = this.#signatureCache.get(node);
-        if (!signatures) {
-            const type = this.getType(node);
-            signatures = type.getCallSignatures();
-            if (signatures.length === 0) {
-                signatures = type.getConstructSignatures();
-            }
-        }
-        return signatures;
-    }
     getTypeText(node) {
         return this.typeChecker.typeToString(this.getType(node));
     }
@@ -4626,9 +4642,21 @@ class ToAcceptProps extends AbilityMatcherBase {
     explainNotText = ExpectDiagnosticText.doesNotAcceptProps;
     match(matchWorker, sourceNode, targetNode, onDiagnostics) {
         const diagnostics = [];
-        const signatures = matchWorker.getSignatures(sourceNode);
-        if (signatures.length === 0) {
-            const expectedText = "of a function or class type";
+        const sourceType = matchWorker.getType(sourceNode);
+        if (!(this.compiler.isIdentifier(sourceNode) ||
+            this.compiler.isPropertyAccessExpression(sourceNode) ||
+            this.compiler.isTypeReferenceNode(sourceNode) ||
+            this.compiler.isExpressionWithTypeArguments(sourceNode)) ||
+            !(sourceType.getCallSignatures().length > 0 || sourceType.getConstructSignatures().length > 0)) {
+            const expectedText = "an identifier of a JSX component";
+            const text = nodeBelongsToArgumentList(this.compiler, sourceNode)
+                ? ExpectDiagnosticText.argumentMustBe(expectedText)
+                : ExpectDiagnosticText.typeArgumentMustBe(expectedText);
+            const origin = DiagnosticOrigin.fromNode(sourceNode);
+            diagnostics.push(Diagnostic.error(text, origin));
+        }
+        else if (!/^[A-Z_$]/.test(sourceNode.getText()[0])) {
+            const expectedText = "an identifier that begins with an uppercase letter";
             const text = nodeBelongsToArgumentList(this.compiler, sourceNode)
                 ? ExpectDiagnosticText.argumentMustBe(expectedText)
                 : ExpectDiagnosticText.typeArgumentMustBe(expectedText);
@@ -5555,14 +5583,18 @@ class ExpectService {
     }
     match(assertionNode, onDiagnostics) {
         const matcherNameText = assertionNode.matcherNameNode.name.text;
+        if (matcherNameText === "toAcceptProps" &&
+            !this.#ensure.jsxSetup(this.#program, assertionNode.matcherNameNode.name, onDiagnostics)) {
+            return;
+        }
         if (!this.#ensure.argumentOrTypeArgument(assertionNode.source[0], assertionNode.node.expression, onDiagnostics)) {
             return;
         }
-        const matchWorker = new MatchWorker(this.#compiler, this.#program, assertionNode);
         if (!(matcherNameText === "toBeInstantiableWith" || (matcherNameText === "toRaiseError" && !assertionNode.isNot)) &&
             this.#reject.argumentType([assertionNode.source[0], assertionNode.target?.[0]], onDiagnostics)) {
             return;
         }
+        const matchWorker = new MatchWorker(this.#compiler, this.#program, assertionNode);
         switch (matcherNameText) {
             case "toAcceptProps":
             case "toBe":
@@ -5908,7 +5940,7 @@ class FileRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "7.2.0";
+    static version = "7.2.1";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tstyche",
-  "version": "7.2.0",
+  "version": "7.2.1",
   "description": "Everything You Need for Type Testing.",
   "keywords": [
     "typescript",