tstyche 4.0.0-beta.0 → 4.0.0-beta.1

package/README.md

@@ -57,9 +57,10 @@ test("handles numbers", () => {
 Here is the list of all matchers:
 
 - `.toBe()`, `.toBeAssignableTo()`, `.toBeAssignableWith()` compare types or types of expression,
-- `.toAcceptProps()` checks JSX component props type,
+- `.toAcceptProps()` checks the type of JSX component props,
+- `.toBeApplicable` ensures that the decorator function can be applied,
 - `.toHaveProperty()` looks up keys on an object type,
-- `.toRaiseError()` captures the type error message or code.
+- `.toRaiseError()` captures the message or code of a type error.
 
 ## Runner
 

package/build/index.d.cts

@@ -97,6 +97,10 @@ interface Matchers {
          */
         (target: unknown): void;
     };
+    /**
+     * Checks if the decorator function can be applied.
+     */
+    toBeApplicable: (target: unknown, context: DecoratorContext) => void;
     /**
      * Checks if the source type is assignable to the target type.
      */

package/build/index.d.ts

@@ -97,6 +97,10 @@ interface Matchers {
          */
         (target: unknown): void;
     };
+    /**
+     * Checks if the decorator function can be applied.
+     */
+    toBeApplicable: (target: unknown, context: DecoratorContext) => void;
     /**
      * Checks if the source type is assignable to the target type.
      */

package/build/tstyche.d.ts

@@ -102,24 +102,16 @@ declare class TestTree {
     constructor(diagnostics: Set<ts.Diagnostic>, sourceFile: ts.SourceFile);
 }
 
-interface MatcherNode extends ts.CallExpression {
-    expression: ts.PropertyAccessExpression;
-}
 declare class AssertionNode extends TestTreeNode {
+    abilityDiagnostics: Set<ts.Diagnostic> | undefined;
     isNot: boolean;
-    matcherName: ts.MemberName;
-    matcherNode: MatcherNode;
+    matcherNode: ts.CallExpression | ts.Decorator;
+    matcherNameNode: ts.PropertyAccessExpression;
     modifierNode: ts.PropertyAccessExpression;
     notNode: ts.PropertyAccessExpression | undefined;
     source: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
-    target: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
-    constructor(compiler: typeof ts, brand: TestTreeNodeBrand, node: ts.CallExpression, parent: TestTree | TestTreeNode, flags: TestTreeNodeFlags, matcherNode: MatcherNode, modifierNode: ts.PropertyAccessExpression, notNode?: ts.PropertyAccessExpression);
-}
-
-declare class CollectService {
-    #private;
-    constructor(compiler: typeof ts);
-    createTestTree(sourceFile: ts.SourceFile, semanticDiagnostics?: Array<ts.Diagnostic>): TestTree;
+    target: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode> | undefined;
+    constructor(compiler: typeof ts, brand: TestTreeNodeBrand, node: ts.CallExpression, parent: TestTree | TestTreeNode, flags: TestTreeNodeFlags, matcherNode: ts.CallExpression | ts.Decorator, matcherNameNode: ts.PropertyAccessExpression, modifierNode: ts.PropertyAccessExpression, notNode?: ts.PropertyAccessExpression);
 }
 
 declare enum OptionBrand {
@@ -207,7 +199,7 @@ interface CommandLineOptions {
      */
     failFast?: boolean;
     /**
-     * Fetch specified versions of the 'typescript' package and exit.
+     * Fetch the specified versions of the 'typescript' package and exit.
      */
     fetch?: boolean;
     /**
@@ -330,6 +322,21 @@ declare class Options {
 
 declare const defaultOptions: Required<ConfigFileOptions>;
 
+declare class ProjectService {
+    #private;
+    constructor(resolvedConfig: ResolvedConfig, compiler: typeof ts);
+    closeFile(filePath: string): void;
+    getDefaultProject(filePath: string): ts.server.Project | undefined;
+    getLanguageService(filePath: string): ts.LanguageService | undefined;
+    openFile(filePath: string, sourceText?: string | undefined, projectRootPath?: string | undefined): void;
+}
+
+declare class CollectService {
+    #private;
+    constructor(compiler: typeof ts, projectService: ProjectService, resolvedConfig: ResolvedConfig);
+    createTestTree(sourceFile: ts.SourceFile, semanticDiagnostics?: Array<ts.Diagnostic>): TestTree;
+}
+
 interface EnvironmentOptions {
     /**
      * Is `true` if the process is running in continuous integration environment.
@@ -592,6 +599,7 @@ declare class ExpectService {
     #private;
     private toAcceptProps;
     private toBe;
+    private toBeApplicable;
     private toBeAssignableTo;
     private toBeAssignableWith;
     private toHaveProperty;
@@ -767,15 +775,6 @@ declare class PluginService {
     static removeHandlers(): void;
 }
 
-declare class ProjectService {
-    #private;
-    constructor(resolvedConfig: ResolvedConfig, compiler: typeof ts);
-    closeFile(filePath: string): void;
-    getDefaultProject(filePath: string): ts.server.Project | undefined;
-    getLanguageService(filePath: string): ts.LanguageService | undefined;
-    openFile(filePath: string, sourceText?: string | undefined, projectRootPath?: string | undefined): void;
-}
-
 declare class Runner {
     #private;
     static version: string;

package/build/tstyche.js

@@ -93,7 +93,7 @@ class DiagnosticOrigin {
         this.assertion = assertion;
     }
     static fromAssertion(assertion) {
-        const node = assertion.matcherName;
+        const node = assertion.matcherNameNode.name;
         return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), assertion);
     }
     static fromNode(node, assertion) {
@@ -903,7 +903,7 @@ class Options {
         },
         {
             brand: OptionBrand.BareTrue,
-            description: "Fetch specified versions of the 'typescript' package and exit.",
+            description: "Fetch the specified versions of the 'typescript' package and exit.",
             group: OptionGroup.CommandLine,
             name: "fetch",
         },
@@ -1948,17 +1948,17 @@ class TestTreeNode {
         };
         switch (this.brand) {
             case TestTreeNodeBrand.Describe:
-                for (const member of this.children) {
-                    if (member.brand === TestTreeNodeBrand.Expect) {
-                        diagnostics.push(Diagnostic.error(getText(member.node), DiagnosticOrigin.fromNode(getParentCallExpression(member.node))));
+                for (const child of this.children) {
+                    if (child.brand === TestTreeNodeBrand.Expect) {
+                        diagnostics.push(Diagnostic.error(getText(child.node), DiagnosticOrigin.fromNode(getParentCallExpression(child.node))));
                     }
                 }
                 break;
             case TestTreeNodeBrand.Test:
             case TestTreeNodeBrand.Expect:
-                for (const member of this.children) {
-                    if (member.brand !== TestTreeNodeBrand.Expect) {
-                        diagnostics.push(Diagnostic.error(getText(member.node), DiagnosticOrigin.fromNode(member.node)));
+                for (const child of this.children) {
+                    if (child.brand !== TestTreeNodeBrand.Expect) {
+                        diagnostics.push(Diagnostic.error(getText(child.node), DiagnosticOrigin.fromNode(child.node)));
                     }
                 }
                 break;
@@ -1968,21 +1968,24 @@ class TestTreeNode {
 }
 
 class AssertionNode extends TestTreeNode {
+    abilityDiagnostics;
     isNot;
-    matcherName;
     matcherNode;
+    matcherNameNode;
     modifierNode;
     notNode;
     source;
     target;
-    constructor(compiler, brand, node, parent, flags, matcherNode, modifierNode, notNode) {
+    constructor(compiler, brand, node, parent, flags, matcherNode, matcherNameNode, modifierNode, notNode) {
         super(compiler, brand, node, parent, flags);
         this.isNot = notNode != null;
-        this.matcherName = matcherNode.expression.name;
         this.matcherNode = matcherNode;
+        this.matcherNameNode = matcherNameNode;
         this.modifierNode = modifierNode;
         this.source = this.node.typeArguments ?? this.node.arguments;
-        this.target = this.matcherNode.typeArguments ?? this.matcherNode.arguments;
+        if (compiler.isCallExpression(this.matcherNode)) {
+            this.target = this.matcherNode.typeArguments ?? this.matcherNode.arguments;
+        }
         for (const diagnostic of parent.diagnostics) {
             if (diagnostic.start != null && diagnostic.start >= this.source.pos && diagnostic.start <= this.source.end) {
                 this.diagnostics.add(diagnostic);
@@ -1992,6 +1995,86 @@ class AssertionNode extends TestTreeNode {
     }
 }
 
+class AbilityLayer {
+    #filePath = "";
+    #nodes = [];
+    #projectService;
+    #resolvedConfig;
+    #text = "";
+    constructor(projectService, resolvedConfig) {
+        this.#projectService = projectService;
+        this.#resolvedConfig = resolvedConfig;
+    }
+    #getErasedRangeText(range) {
+        if (this.#text.indexOf("\n", range.start) >= range.end) {
+            return " ".repeat(range.end - range.start);
+        }
+        const text = [];
+        for (let i = range.start; i < range.end; i++) {
+            switch (this.#text.charAt(i)) {
+                case "\n":
+                case "\r":
+                    text.push(this.#text.charAt(i));
+                    break;
+                default:
+                    text.push(" ");
+            }
+        }
+        return text.join("");
+    }
+    #addRanges(node, ranges) {
+        this.#nodes.push(node);
+        for (const range of ranges) {
+            const rangeText = this.#getErasedRangeText(range);
+            this.#text = `${this.#text.slice(0, range.start)}${rangeText}${this.#text.slice(range.end)}`;
+        }
+    }
+    close() {
+        if (this.#nodes.length > 0) {
+            this.#projectService.openFile(this.#filePath, this.#text, this.#resolvedConfig.rootPath);
+            const languageService = this.#projectService.getLanguageService(this.#filePath);
+            const diagnostics = new Set(languageService?.getSemanticDiagnostics(this.#filePath)?.toReversed());
+            if (diagnostics.size > 0) {
+                for (const node of this.#nodes.toReversed()) {
+                    for (const diagnostic of diagnostics) {
+                        if (diagnostic.start != null &&
+                            diagnostic.start >= node.matcherNode.pos &&
+                            diagnostic.start <= node.matcherNode.end) {
+                            if (!node.abilityDiagnostics) {
+                                node.abilityDiagnostics = new Set();
+                            }
+                            node.abilityDiagnostics.add(diagnostic);
+                            diagnostics.delete(diagnostic);
+                        }
+                    }
+                }
+            }
+        }
+        this.#filePath = "";
+        this.#nodes = [];
+        this.#text = "";
+    }
+    handleNode(assertionNode) {
+        switch (assertionNode.matcherNameNode.name.text) {
+            case "toBeApplicable": {
+                const expectStart = assertionNode.node.pos;
+                const expectExpressionEnd = assertionNode.node.expression.end;
+                const expectEnd = assertionNode.node.end;
+                const matcherNameEnd = assertionNode.matcherNameNode.end;
+                this.#addRanges(assertionNode, [
+                    { end: expectExpressionEnd + 1, start: expectStart },
+                    { end: matcherNameEnd, start: expectEnd - 1 },
+                ]);
+                break;
+            }
+        }
+    }
+    open(sourceFile) {
+        this.#filePath = sourceFile.fileName;
+        this.#text = sourceFile.text;
+    }
+}
+
 var TestTreeNodeFlags;
 (function (TestTreeNodeFlags) {
     TestTreeNodeFlags[TestTreeNodeFlags["None"] = 0] = "None";
@@ -2103,9 +2186,15 @@ class TestTree {
 }
 
 class CollectService {
+    #abilityLayer;
     #compiler;
-    constructor(compiler) {
+    #projectService;
+    #resolvedConfig;
+    constructor(compiler, projectService, resolvedConfig) {
         this.#compiler = compiler;
+        this.#projectService = projectService;
+        this.#resolvedConfig = resolvedConfig;
+        this.#abilityLayer = new AbilityLayer(this.#projectService, this.#resolvedConfig);
     }
     #collectTestTreeNodes(node, identifiers, parent) {
         if (this.#compiler.isCallExpression(node)) {
@@ -2125,12 +2214,17 @@ class CollectService {
                     return;
                 }
                 const notNode = this.#getChainedNode(modifierNode, "not");
-                const matcherNode = this.#getChainedNode(notNode ?? modifierNode)?.parent;
-                if (!matcherNode || !this.#isMatcherNode(matcherNode)) {
+                const matcherNameNode = this.#getChainedNode(notNode ?? modifierNode);
+                if (!matcherNameNode) {
+                    return;
+                }
+                const matcherNode = this.#getMatcherNode(matcherNameNode);
+                if (!matcherNode) {
                     return;
                 }
-                const assertionNode = new AssertionNode(this.#compiler, meta.brand, node, parent, meta.flags, matcherNode, modifierNode, notNode);
+                const assertionNode = new AssertionNode(this.#compiler, meta.brand, node, parent, meta.flags, matcherNode, matcherNameNode, modifierNode, notNode);
                 parent.children.push(assertionNode);
+                this.#abilityLayer.handleNode(assertionNode);
                 EventEmitter.dispatch(["collect:node", { testNode: assertionNode }]);
                 this.#compiler.forEachChild(node, (node) => {
                     this.#collectTestTreeNodes(node, identifiers, assertionNode);
@@ -2149,7 +2243,9 @@ class CollectService {
     createTestTree(sourceFile, semanticDiagnostics = []) {
         const testTree = new TestTree(new Set(semanticDiagnostics), sourceFile);
         EventEmitter.dispatch(["collect:start", { testTree }]);
+        this.#abilityLayer.open(sourceFile);
         this.#collectTestTreeNodes(sourceFile, new IdentifierLookup(this.#compiler), testTree);
+        this.#abilityLayer.close();
         EventEmitter.dispatch(["collect:end", { testTree }]);
         return testTree;
     }
@@ -2162,8 +2258,17 @@ class CollectService {
         }
         return parent;
     }
-    #isMatcherNode(node) {
-        return this.#compiler.isCallExpression(node) && this.#compiler.isPropertyAccessExpression(node.expression);
+    #getMatcherNode(node) {
+        if (this.#compiler.isCallExpression(node.parent)) {
+            return node.parent;
+        }
+        if (this.#compiler.isDecorator(node.parent)) {
+            return node.parent;
+        }
+        if (this.#compiler.isParenthesizedExpression(node.parent)) {
+            return this.#getMatcherNode(node.parent);
+        }
+        return;
     }
 }
 
@@ -3335,6 +3440,12 @@ class ExpectDiagnosticText {
     static componentDoesNotAcceptProps(isTypeNode) {
         return `${isTypeNode ? "Component type" : "Component"} does not accept props of the given type.`;
     }
+    static decoratorCanBeApplied(targetText) {
+        return `The decorator function can be applied${targetText}.`;
+    }
+    static decoratorCanNotBeApplied(targetText) {
+        return `The decorator function can not be applied${targetText}.`;
+    }
     static matcherIsNotSupported(matcherNameText) {
         return `The '.${matcherNameText}()' matcher is not supported.`;
     }
@@ -3738,6 +3849,76 @@ class ToBe extends RelationMatcherBase {
     }
 }
 
+class ToBeApplicable {
+    #compiler;
+    constructor(compiler) {
+        this.#compiler = compiler;
+    }
+    #resolveTargetText(node) {
+        let text = "";
+        switch (node.kind) {
+            case this.#compiler.SyntaxKind.ClassDeclaration:
+                text = "class";
+                break;
+            case this.#compiler.SyntaxKind.MethodDeclaration:
+                text = "method";
+                break;
+            case this.#compiler.SyntaxKind.PropertyDeclaration:
+                text = node.modifiers?.some((modifier) => modifier.kind === this.#compiler.SyntaxKind.AccessorKeyword)
+                    ? "accessor"
+                    : "field";
+                break;
+            case this.#compiler.SyntaxKind.GetAccessor:
+                text = "getter";
+                break;
+            case this.#compiler.SyntaxKind.SetAccessor:
+                text = "setter";
+                break;
+        }
+        if (text.length > 0) {
+            text = ` to this ${text}`;
+        }
+        return text;
+    }
+    #explain(matchWorker, sourceNode) {
+        const targetText = this.#resolveTargetText(matchWorker.assertion.matcherNode.parent);
+        const diagnostics = [];
+        if (matchWorker.assertion.abilityDiagnostics) {
+            for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
+                const text = [
+                    ExpectDiagnosticText.decoratorCanNotBeApplied(targetText),
+                    typeof diagnostic.messageText === "string"
+                        ? diagnostic.messageText
+                        : Diagnostic.toMessageText(diagnostic.messageText),
+                ];
+                const origin = DiagnosticOrigin.fromNode(sourceNode);
+                diagnostics.push(Diagnostic.error(text.flat(), origin));
+            }
+        }
+        else {
+            const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
+            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.decoratorCanBeApplied(targetText), origin));
+        }
+        return diagnostics;
+    }
+    match(matchWorker, sourceNode, onDiagnostics) {
+        const type = matchWorker.getType(sourceNode);
+        if (type.getCallSignatures().length === 0) {
+            const expectedText = "of a function type";
+            const text = this.#compiler.isTypeNode(sourceNode)
+                ? ExpectDiagnosticText.typeArgumentMustBe("Source", expectedText)
+                : ExpectDiagnosticText.argumentMustBe("source", expectedText);
+            const origin = DiagnosticOrigin.fromNode(sourceNode);
+            onDiagnostics([Diagnostic.error(text, origin)]);
+            return;
+        }
+        return {
+            explain: () => this.#explain(matchWorker, sourceNode),
+            isMatch: !matchWorker.assertion.abilityDiagnostics,
+        };
+    }
+}
+
 class ToBeAssignableTo extends RelationMatcherBase {
     explainText = ExpectDiagnosticText.typeIsAssignableTo;
     explainNotText = ExpectDiagnosticText.typeIsNotAssignableTo;
@@ -3908,6 +4089,7 @@ class ExpectService {
     #typeChecker;
     toAcceptProps;
     toBe;
+    toBeApplicable;
     toBeAssignableTo;
     toBeAssignableWith;
     toHaveProperty;
@@ -3923,41 +4105,42 @@ class ExpectService {
         }
         this.toAcceptProps = new ToAcceptProps(compiler, typeChecker);
         this.toBe = new ToBe();
+        this.toBeApplicable = new ToBeApplicable(compiler);
         this.toBeAssignableTo = new ToBeAssignableTo();
         this.toBeAssignableWith = new ToBeAssignableWith();
         this.toHaveProperty = new ToHaveProperty(compiler);
         this.toRaiseError = new ToRaiseError(compiler);
     }
     match(assertion, onDiagnostics) {
-        const matcherNameText = assertion.matcherName.getText();
+        const matcherNameText = assertion.matcherNameNode.name.text;
         if (!assertion.source[0]) {
             this.#onSourceArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics);
             return;
         }
         const matchWorker = new MatchWorker(this.#compiler, this.#typeChecker, assertion);
+        if (!(matcherNameText === "toRaiseError" && assertion.isNot === false) &&
+            this.#rejectsTypeArguments(matchWorker, onDiagnostics)) {
+            return;
+        }
         switch (matcherNameText) {
             case "toAcceptProps":
             case "toBe":
             case "toBeAssignableTo":
             case "toBeAssignableWith":
-                if (!assertion.target[0]) {
+                if (!assertion.target?.[0]) {
                     this.#onTargetArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics);
                     return;
                 }
-                if (this.#rejectsTypeArguments(matchWorker, onDiagnostics)) {
-                    return;
-                }
                 return this[matcherNameText].match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
+            case "toBeApplicable":
+                return this.toBeApplicable.match(matchWorker, assertion.source[0], onDiagnostics);
             case "toHaveProperty":
-                if (!assertion.target[0]) {
+                if (!assertion.target?.[0]) {
                     this.#onTargetArgumentMustBeProvided("key", assertion, onDiagnostics);
                     return;
                 }
                 return this.toHaveProperty.match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
             case "toRaiseError":
-                if (assertion.isNot && this.#rejectsTypeArguments(matchWorker, onDiagnostics)) {
-                    return;
-                }
                 return this.toRaiseError.match(matchWorker, assertion.source[0], [...assertion.target], onDiagnostics);
             default:
                 this.#onMatcherIsNotSupported(matcherNameText, assertion, onDiagnostics);
@@ -3966,7 +4149,7 @@ class ExpectService {
     }
     #onMatcherIsNotSupported(matcherNameText, assertion, onDiagnostics) {
         const text = ExpectDiagnosticText.matcherIsNotSupported(matcherNameText);
-        const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
+        const origin = DiagnosticOrigin.fromNode(assertion.matcherNameNode.name);
         onDiagnostics(Diagnostic.error(text, origin));
     }
     #onSourceArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics) {
@@ -3976,23 +4159,23 @@ class ExpectService {
     }
     #onTargetArgumentMustBeProvided(argumentNameText, assertion, onDiagnostics) {
         const text = ExpectDiagnosticText.argumentMustBeProvided(argumentNameText);
-        const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
+        const origin = DiagnosticOrigin.fromNode(assertion.matcherNameNode.name);
         onDiagnostics(Diagnostic.error(text, origin));
     }
     #onTargetArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics) {
         const text = ExpectDiagnosticText.argumentOrTypeArgumentMustBeProvided("target", "Target");
-        const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
+        const origin = DiagnosticOrigin.fromNode(assertion.matcherNameNode.name);
         onDiagnostics(Diagnostic.error(text, origin));
     }
     #rejectsTypeArguments(matchWorker, onDiagnostics) {
         for (const rejectedType of this.#rejectTypes) {
             const allowedKeyword = this.#compiler.SyntaxKind[`${Format.capitalize(rejectedType)}Keyword`];
             if (matchWorker.assertion.source[0]?.kind === allowedKeyword ||
-                matchWorker.assertion.target[0]?.kind === allowedKeyword) {
+                matchWorker.assertion.target?.[0]?.kind === allowedKeyword) {
                 continue;
             }
             for (const argumentName of ["source", "target"]) {
-                const argumentNode = matchWorker.assertion[argumentName][0];
+                const argumentNode = matchWorker.assertion[argumentName]?.[0];
                 if (!argumentNode) {
                     continue;
                 }
@@ -4089,7 +4272,7 @@ class TestTreeWalker {
                 { diagnostics: Array.isArray(diagnostics) ? diagnostics : [diagnostics], result: expectResult },
             ]);
         };
-        if (assertion.diagnostics.size > 0 && assertion.matcherName.getText() !== "toRaiseError") {
+        if (assertion.diagnostics.size > 0 && assertion.matcherNameNode.name.text !== "toRaiseError") {
             onExpectDiagnostics(Diagnostic.fromDiagnostics([...assertion.diagnostics]));
             return;
         }
@@ -4173,8 +4356,8 @@ class TaskRunner {
     constructor(resolvedConfig, compiler) {
         this.#resolvedConfig = resolvedConfig;
         this.#compiler = compiler;
-        this.#collectService = new CollectService(compiler);
         this.#projectService = new ProjectService(this.#resolvedConfig, compiler);
+        this.#collectService = new CollectService(compiler, this.#projectService, this.#resolvedConfig);
     }
     run(task, cancellationToken) {
         if (cancellationToken?.isCancellationRequested) {
@@ -4238,7 +4421,7 @@ class TaskRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "4.0.0-beta.0";
+    static version = "4.0.0-beta.1";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tstyche",
-  "version": "4.0.0-beta.0",
+  "version": "4.0.0-beta.1",
   "description": "The Essential Type Testing Tool.",
   "keywords": [
     "typescript",
@@ -60,17 +60,17 @@
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
     "@rollup/plugin-typescript": "12.1.2",
-    "@types/node": "22.13.14",
-    "@types/react": "19.0.12",
+    "@types/node": "22.14.0",
+    "@types/react": "19.1.0",
     "ajv": "8.17.1",
     "cspell": "8.18.1",
     "magic-string": "0.30.17",
     "monocart-coverage-reports": "2.12.3",
     "pretty-ansi": "3.0.0",
-    "rollup": "4.38.0",
+    "rollup": "4.39.0",
     "rollup-plugin-dts": "6.2.1",
     "tslib": "2.8.1",
-    "typescript": "5.8.2"
+    "typescript": "5.8.3"
   },
   "peerDependencies": {
     "typescript": "5.x"
@@ -80,7 +80,7 @@
       "optional": true
     }
   },
-  "packageManager": "yarn@4.8.0",
+  "packageManager": "yarn@4.8.1",
   "engines": {
     "node": ">=20.9"
   }