@dxup/vanilla 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025-present KazariEX
+
+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

@@ -0,0 +1,50 @@
+# @dxup/vanilla
+
+[![version](https://img.shields.io/npm/v/@dxup/vanilla?color=007EC7&label=npm)](https://www.npmjs.com/package/@dxup/vanilla)
+[![downloads](https://img.shields.io/npm/dm/@dxup/vanilla?color=007EC7&label=downloads)](https://www.npmjs.com/package/@dxup/vanilla)
+[![license](https://img.shields.io/npm/l/@dxup/vanilla?color=007EC7&label=license)](/LICENSE)
+
+This is a TypeScript plugin for Vanilla JS.
+
+## Installation
+
+```bash
+pnpm i -D @dxup/vanilla
+```
+
+Or you can install the VS Code extension for easier setup:
+
+```bash
+code --install-extension KazariEX.dxup
+```
+
+## Usage
+
+Add the following to your `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "plugins": [
+      { "name": "@dxup/vanilla" }
+    ]
+  }
+}
+```
+
+## Features
+
+### 1. signature
+
+Go to definition for signature parameters.
+
+```ts
+export default defineConfig({
+  plugins: [{
+    name: "testify",
+    transform(code, id, options) {
+      //                ^^^^^^^
+    },
+  }],
+});
+```

package/dist/index.cjs

@@ -0,0 +1,113 @@
+
+//#region ../shared/src/index.ts
+function* forEachTouchingNode(ts, sourceFile, position) {
+	yield* binaryVisit(ts, sourceFile, sourceFile, position);
+}
+function* binaryVisit(ts, sourceFile, node, position) {
+	const nodes = [];
+	ts.forEachChild(node, (child) => {
+		nodes.push(child);
+	});
+	let left = 0;
+	let right = nodes.length - 1;
+	while (left <= right) {
+		const mid = Math.floor((left + right) / 2);
+		const node$1 = nodes[mid];
+		if (position > node$1.getEnd()) left = mid + 1;
+		else if (position < node$1.getStart(sourceFile)) right = mid - 1;
+		else {
+			yield node$1;
+			yield* binaryVisit(ts, sourceFile, node$1, position);
+			return;
+		}
+	}
+}
+
+//#endregion
+//#region src/index.ts
+const plugin = (module$1) => {
+	const { typescript: ts } = module$1;
+	return { create(info) {
+		for (const [key, method] of [["getDefinitionAndBoundSpan", getDefinitionAndBoundSpan]]) {
+			const original = info.languageService[key];
+			info.languageService[key] = method(ts, info, original);
+		}
+		return info.languageService;
+	} };
+};
+var src_default = plugin;
+function getDefinitionAndBoundSpan(ts, info, getDefinitionAndBoundSpan$1) {
+	return (...args) => {
+		const result = getDefinitionAndBoundSpan$1(...args);
+		if (!result?.definitions?.length) return result;
+		if (result.definitions[0].kind === ts.ScriptElementKind.parameterElement && result.definitions[0].textSpan.start === result.textSpan.start) {
+			const program = info.languageService.getProgram();
+			const sourceFile = program.getSourceFile(args[0]);
+			const checker = program.getTypeChecker();
+			let node;
+			for (const child of forEachTouchingNode(ts, sourceFile, args[1])) if (ts.isParameter(child)) node = child;
+			if (!node || node.dotDotDotToken) return result;
+			const firstArg = node.parent.parameters[0];
+			const withThis = ts.isIdentifier(firstArg.name) && firstArg.name.text === "this";
+			const index = node.parent.parameters.indexOf(node) - Number(withThis);
+			const definitions = [];
+			for (const signature of forEachSignature(ts, checker, node.parent)) {
+				let i = -1;
+				for (const declaration of forEachParameter(checker, signature)) {
+					if (i++ !== index) continue;
+					if (declaration) {
+						const sourceFile$1 = declaration.getSourceFile();
+						definitions.push({
+							fileName: sourceFile$1.fileName,
+							textSpan: {
+								start: declaration.getStart(sourceFile$1),
+								length: declaration.getWidth(sourceFile$1)
+							},
+							kind: ts.ScriptElementKind.parameterElement,
+							name: declaration.getText(sourceFile$1),
+							containerKind: ts.ScriptElementKind.unknown,
+							containerName: ""
+						});
+					}
+					break;
+				}
+			}
+			if (definitions.length) result.definitions = definitions;
+		}
+		return result;
+	};
+}
+function* forEachSignature(ts, checker, signature) {
+	if (ts.isExpression(signature)) yield* flattenSignatures(checker.getContextualType(signature));
+	else if (ts.isMethodDeclaration(signature) && ts.isIdentifier(signature.name) && ts.isObjectLiteralExpression(signature.parent)) {
+		const contextualType = checker.getContextualType(signature.parent);
+		for (const type of forEachType(contextualType)) {
+			const property = type.getProperty(signature.name.text);
+			if (property) yield* flattenSignatures(checker.getTypeOfSymbol(property));
+		}
+	}
+}
+function* flattenSignatures(type) {
+	if (type?.isUnionOrIntersection()) for (const subtype of type.types) yield* flattenSignatures(subtype);
+	else if (type) yield* type.getCallSignatures();
+}
+function* forEachType(type) {
+	if (type?.isUnionOrIntersection()) for (const subtype of type.types) yield* forEachType(subtype);
+	else if (type) yield type;
+}
+function* forEachParameter(checker, signature) {
+	yield signature.thisParameter?.valueDeclaration;
+	for (const parameter of signature.parameters) {
+		const declaration = parameter.valueDeclaration;
+		if (declaration?.dotDotDotToken) {
+			const type = checker.getTypeOfSymbol(parameter);
+			if (checker.isTupleType(type)) {
+				const tuple = type.target;
+				if (tuple.labeledElementDeclarations) yield* tuple.labeledElementDeclarations;
+			}
+		} else yield declaration;
+	}
+}
+
+//#endregion
+module.exports = src_default;

package/dist/index.d.cts

@@ -0,0 +1,5 @@
+import ts from "typescript";
+
+//#region src/index.d.ts
+declare const plugin: ts.server.PluginModuleFactory;
+export = plugin;

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@dxup/vanilla",
+  "type": "module",
+  "version": "0.0.1",
+  "description": "TypeScript plugin for Vanilla JS",
+  "author": "KazariEX",
+  "license": "MIT",
+  "repository": "KazariEX/dxup",
+  "exports": {
+    ".": "./dist/index.cjs",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.cts",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@dxup/shared": "",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown -w --sourcemap",
+    "release": "node ../../scripts/release.ts"
+  }
+}