@dxup/vanilla 0.0.1 → 0.0.2

package/README.md

@@ -36,15 +36,23 @@ Add the following to your `tsconfig.json`:
 
 ### 1. signature
 
-Go to definition for signature parameters.
-
-```ts
-export default defineConfig({
-  plugins: [{
-    name: "testify",
-    transform(code, id, options) {
-      //                ^^^^^^^
-    },
-  }],
-});
-```
+- Go to definition for signature parameters.
+
+  ```ts
+  export default defineConfig({
+    plugins: [{
+      name: "testify",
+      transform(code, id, options) {
+        //                ^^^^^^^
+      },
+    }],
+  });
+  ```
+
+- Rewrite refactor for signature parameters.
+
+  ```ts
+  function swap(foo: number, bar: string, baz: boolean, qux: symbol) {}
+  //                         ^^^ Refactor > Move parameter right
+  swap(2, "3", true, Symbol(5));
+  ```

package/dist/index.cjs

@@ -12,33 +12,65 @@ function* binaryVisit(ts, sourceFile, node, position) {
 	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;
+		const node = nodes[mid];
+		if (position > node.getEnd()) left = mid + 1;
+		else if (position < node.getStart(sourceFile)) right = mid - 1;
 		else {
-			yield node$1;
-			yield* binaryVisit(ts, sourceFile, node$1, position);
+			yield node;
+			yield* binaryVisit(ts, sourceFile, node, 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) {
+//#region src/shared.ts
+const refactors = { rewrite: { parameter: {
+	forward: {
+		name: "Move parameter left",
+		description: "Move parameter left",
+		kind: "refactor.rewrite.parameter.forward"
+	},
+	backward: {
+		name: "Move parameter right",
+		description: "Move parameter right",
+		kind: "refactor.rewrite.parameter.backward"
+	},
+	remove: {
+		name: "Remove parameter",
+		description: "Remove parameter",
+		kind: "refactor.rewrite.parameter.remove"
+	}
+} } };
+
+//#endregion
+//#region src/features/getApplicableRefactors.ts
+function getApplicableRefactors(ts, info, getApplicableRefactors) {
+	return (...args) => {
+		const result = getApplicableRefactors(...args);
+		const sourceFile = info.languageService.getProgram().getSourceFile(args[0]);
+		if (!sourceFile) return result;
+		let node;
+		const position = typeof args[1] === "number" ? args[1] : args[1].pos;
+		for (const child of forEachTouchingNode(ts, sourceFile, position)) if (ts.isParameter(child)) node = child;
+		if (node?.parent.name) result.push({
+			name: "Dxup",
+			description: "Dxup refactor actions",
+			actions: [
+				refactors.rewrite.parameter.forward,
+				refactors.rewrite.parameter.backward,
+				refactors.rewrite.parameter.remove
+			]
+		});
+		return result;
+	};
+}
+
+//#endregion
+//#region src/features/getDefinitionAndBoundSpan.ts
+function getDefinitionAndBoundSpan(ts, info, getDefinitionAndBoundSpan) {
 	return (...args) => {
-		const result = getDefinitionAndBoundSpan$1(...args);
+		const result = getDefinitionAndBoundSpan(...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();
@@ -56,15 +88,15 @@ function getDefinitionAndBoundSpan(ts, info, getDefinitionAndBoundSpan$1) {
 				for (const declaration of forEachParameter(checker, signature)) {
 					if (i++ !== index) continue;
 					if (declaration) {
-						const sourceFile$1 = declaration.getSourceFile();
+						const sourceFile = declaration.getSourceFile();
 						definitions.push({
-							fileName: sourceFile$1.fileName,
+							fileName: sourceFile.fileName,
 							textSpan: {
-								start: declaration.getStart(sourceFile$1),
-								length: declaration.getWidth(sourceFile$1)
+								start: declaration.getStart(sourceFile),
+								length: declaration.getWidth(sourceFile)
 							},
 							kind: ts.ScriptElementKind.parameterElement,
-							name: declaration.getText(sourceFile$1),
+							name: declaration.getText(sourceFile),
 							containerKind: ts.ScriptElementKind.unknown,
 							containerName: ""
 						});
@@ -110,4 +142,147 @@ function* forEachParameter(checker, signature) {
 }
 
 //#endregion
-module.exports = src_default;
+//#region src/features/getEditsForRefactor.ts
+function getEditsForRefactor(ts, info, getEditsForRefactor) {
+	return (...args) => {
+		if (args[3] !== "Dxup") return getEditsForRefactor(...args);
+		const sourceFile = info.languageService.getProgram().getSourceFile(args[0]);
+		const position = typeof args[2] === "number" ? args[2] : args[2].pos;
+		const direction = args[4] === refactors.rewrite.parameter.forward.name ? -1 : args[4] === refactors.rewrite.parameter.backward.name ? 1 : args[4] === refactors.rewrite.parameter.remove.name ? 0 : null;
+		if (direction === null) return;
+		let node;
+		for (const child of forEachTouchingNode(ts, sourceFile, position)) if (ts.isParameter(child)) node = child;
+		if (!node?.parent.name) return;
+		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);
+		if (index === -1 || index + direction < 0 || index + direction === node.parent.parameters.length || direction !== 0 && (node.dotDotDotToken || node.parent.parameters[index + direction].dotDotDotToken)) return;
+		const modifier = direction === 0 && node.dotDotDotToken ? Infinity : direction;
+		const fileTextChanges = {};
+		const references = forEachSignatureReference(ts, info.languageService, args[0], node.parent.name.getStart(sourceFile));
+		for (const node of references) {
+			const sourceFile = node.getSourceFile();
+			const textChanges = fileTextChanges[sourceFile.fileName] ??= [];
+			if (ts.isCallExpression(node)) textChanges.push(...calculateTextChanges(ts, sourceFile, node.arguments, index, modifier));
+			else {
+				let index2 = index;
+				const firstArg = node.parameters[0];
+				if (ts.isIdentifier(firstArg.name) && firstArg.name.text === "this") index2++;
+				textChanges.push(...calculateTextChanges(ts, sourceFile, node.parameters, index2, modifier));
+			}
+		}
+		return { edits: Object.entries(fileTextChanges).map(([fileName, textChanges]) => ({
+			fileName,
+			textChanges
+		})) };
+	};
+}
+function* forEachSignatureReference(ts, languageService, fileName, position, visited = /* @__PURE__ */ new Set()) {
+	const program = languageService.getProgram();
+	const references = languageService.getReferencesAtPosition(fileName, position) ?? [];
+	outer: for (const { fileName, textSpan } of references) {
+		const key = fileName + "@" + textSpan.start;
+		if (visited.has(key)) continue;
+		visited.add(key);
+		const sourceFile = program.getSourceFile(fileName);
+		let node;
+		for (const child of forEachTouchingNode(ts, sourceFile, textSpan.start)) if (ts.isIdentifier(child)) {
+			node = child;
+			break;
+		}
+		if (!node) continue;
+		if (ts.isCallExpression(node.parent) && node === node.parent.expression) {
+			yield node.parent;
+			continue;
+		}
+		if (ts.isPropertyAccessExpression(node.parent) && node === node.parent.name && ts.isCallExpression(node.parent.parent) && node.parent === node.parent.parent.expression) {
+			yield node.parent.parent;
+			continue;
+		}
+		if (ts.isFunctionLike(node.parent) && node === node.parent.name) {
+			yield node.parent;
+			continue;
+		}
+		if ((ts.isPropertyAssignment(node.parent) || ts.isPropertyDeclaration(node.parent)) && node === node.parent.name && node.parent.initializer) {
+			const expression = getUnwrappedExpression(ts, node.parent.initializer);
+			if (ts.isFunctionLike(expression)) {
+				yield expression;
+				continue;
+			}
+		}
+		let start;
+		let curr = node;
+		inner: while (curr) {
+			if (ts.isVariableDeclaration(curr.parent) && curr === curr.parent.initializer) start = curr.parent.name.getStart(sourceFile);
+			else if ((ts.isPropertyAssignment(curr.parent) || ts.isPropertyDeclaration(curr.parent)) && curr === curr.parent.initializer) start = curr.parent.name.getStart(sourceFile);
+			else if (ts.isShorthandPropertyAssignment(curr.parent)) start = curr.getStart(sourceFile);
+			else if (ts.isTypeQueryNode(curr.parent) && curr === curr.parent.exprName && ts.isVariableDeclaration(curr.parent.parent) && curr.parent.parent.initializer) {
+				const expression = getUnwrappedExpression(ts, curr.parent.parent.initializer);
+				if (ts.isFunctionLike(expression)) yield expression;
+				start = curr.parent.parent.name.getStart(sourceFile);
+			} else if (ts.isTypeQueryNode(curr.parent) && curr === curr.parent.exprName && ts.isAsExpression(curr.parent.parent) && curr.parent.parent.expression) {
+				const expression = getUnwrappedExpression(ts, curr.parent.parent.expression);
+				if (ts.isFunctionLike(expression)) yield expression;
+				curr = curr.parent.parent;
+				continue inner;
+			} else if (ts.isTypeQueryNode(curr.parent) && curr === curr.parent.exprName && ts.isPropertySignature(curr.parent.parent)) start = curr.parent.parent.name.getStart(sourceFile);
+			else continue outer;
+			break;
+		}
+		yield* forEachSignatureReference(ts, languageService, fileName, start, visited);
+	}
+}
+function getUnwrappedExpression(ts, node) {
+	while (ts.isParenthesizedExpression(node)) {
+		node = node.expression;
+		if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.CommaToken) node = node.right;
+	}
+	return node;
+}
+function* calculateTextChanges(ts, sourceFile, args, index, modifier) {
+	const spreadIndex = args.findIndex((arg) => ts.isSpreadElement(arg));
+	if (spreadIndex !== -1 && spreadIndex <= Math.max(index, index + modifier)) return;
+	if (modifier === 0 || modifier === Infinity) {
+		const from = index;
+		const to = modifier === Infinity ? args.length - 1 : Math.min(args.length - 1, index);
+		const [start, end] = from ? [args[from - 1].end, args[to].end] : [args[from].getStart(sourceFile), args[to + 1]?.getStart(sourceFile) ?? args[to].end];
+		yield {
+			span: {
+				start,
+				length: end - start
+			},
+			newText: ""
+		};
+		return;
+	}
+	for (let i = index; modifier === -1 ? i >= index + modifier : i <= index + modifier; i += modifier) yield {
+		span: {
+			start: args[i].getStart(sourceFile),
+			length: args[i].getWidth(sourceFile)
+		},
+		newText: args[i === index ? i + modifier : index].getText(sourceFile)
+	};
+}
+
+//#endregion
+//#region src/index.ts
+const plugin = (module) => {
+	const { typescript: ts } = module;
+	return { create(info) {
+		const methods = {};
+		for (const [key, method] of [
+			["getApplicableRefactors", getApplicableRefactors],
+			["getEditsForRefactor", getEditsForRefactor],
+			["getDefinitionAndBoundSpan", getDefinitionAndBoundSpan]
+		]) {
+			const original = info.languageService[key];
+			methods[key] = method(ts, info, original);
+		}
+		return new Proxy(info.languageService, { get(target, p, receiver) {
+			return methods[p] ?? Reflect.get(target, p, receiver);
+		} });
+	} };
+};
+
+//#endregion
+module.exports = plugin;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dxup/vanilla",
   "type": "module",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "TypeScript plugin for Vanilla JS",
   "author": "KazariEX",
   "license": "MIT",
@@ -15,9 +15,12 @@
   "files": [
     "dist"
   ],
+  "peerDependencies": {
+    "typescript": "*"
+  },
   "devDependencies": {
-    "@dxup/shared": "",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "@dxup/shared": "0.0.0"
   },
   "scripts": {
     "build": "tsdown",