tsl-dx 0.11.0 → 0.12.0

package/dist/index.d.ts

@@ -86,6 +86,6 @@ type nullishOptions = {
  * if (x == null) { }
  * ```
  */
-declare const nullish: (options?: "off" | nullishOptions | undefined) => _$tsl.Rule<unknown>;
+declare const nullish: (options?: nullishOptions | "off" | undefined) => _$tsl.Rule<unknown>;
 //#endregion
 export { noDuplicateExports, noDuplicateImports, noMultilineTemplateExpressionWithoutAutoDedent, nullish };

package/dist/index.js

@@ -2,6 +2,14 @@ import { defineRule } from "tsl";
 import ts, { SyntaxKind } from "typescript";
 import { match } from "ts-pattern";
 
+//#region src/utils/print-node.ts
+const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+const dummySourceFile = ts.createSourceFile("", "", ts.ScriptTarget.Latest);
+function printNode(node) {
+	return printer.printNode(ts.EmitHint.Unspecified, node, dummySourceFile);
+}
+
+//#endregion
 //#region src/rules/no-duplicate-exports.ts
 const messages$3 = { default: (p) => `Duplicate export from module ${p.source}.` };
 function isReExportDeclaration(node) {
@@ -48,9 +56,18 @@ const noDuplicateExports = defineRule(() => {
 function buildSuggestions$1(existing, incoming) {
 	switch (true) {
 		case ts.isNamedExports(existing.exportClause) && ts.isNamedExports(incoming.exportClause): {
-			const existingElements = existing.exportClause.elements.map((el) => el.getText());
-			const incomingElements = incoming.exportClause.elements.map((el) => el.getText());
-			const parts = Array.from(new Set([...existingElements, ...incomingElements]));
+			const seen = /* @__PURE__ */ new Set();
+			const elements = [];
+			for (const el of [...existing.exportClause.elements, ...incoming.exportClause.elements]) {
+				const text = el.getText();
+				if (seen.has(text)) continue;
+				seen.add(text);
+				elements.push(ts.factory.createExportSpecifier(el.isTypeOnly, el.propertyName != null ? ts.factory.createIdentifier(el.propertyName.text) : void 0, ts.factory.createIdentifier(el.name.text)));
+			}
+			const specifierText = existing.moduleSpecifier.getText();
+			const isSingleQuote = specifierText.startsWith("'");
+			const specifierValue = specifierText.slice(1, -1);
+			const exportDecl = ts.factory.createExportDeclaration(void 0, existing.isTypeOnly, ts.factory.createNamedExports(elements), ts.factory.createStringLiteral(specifierValue, isSingleQuote));
 			return [{
 				message: "Merge duplicate exports",
 				changes: [{
@@ -59,7 +76,7 @@ function buildSuggestions$1(existing, incoming) {
 					newText: ""
 				}, {
 					node: existing,
-					newText: `export ${existing.isTypeOnly ? "type " : ""}{ ${parts.join(", ")} } from ${existing.moduleSpecifier.getText()};`
+					newText: printNode(exportDecl)
 				}]
 			}];
 		}
@@ -106,13 +123,13 @@ const noDuplicateImports = defineRule(() => {
 				defaultImport: node.importClause.name?.getText() ?? null,
 				bindings: match(node.importClause.namedBindings).with({ kind: ts.SyntaxKind.NamedImports }, (nb) => ({
 					kind: "named",
-					imports: nb.elements.map((el) => el.getText())
+					elements: nb.elements
 				})).with({ kind: ts.SyntaxKind.NamespaceImport }, (nb) => ({
 					kind: "namespace",
 					name: nb.name.getText()
 				})).otherwise(() => ({
 					kind: "named",
-					imports: []
+					elements: []
 				}))
 			};
 			const existingImports = ctx.data.imports.get(importKind);
@@ -135,12 +152,19 @@ function buildSuggestions(existing, incoming) {
 		case existing.defaultImport != null && incoming.defaultImport != null && existing.defaultImport !== incoming.defaultImport: return [];
 		default: break;
 	}
-	const parts = [];
 	const defaultImport = existing.defaultImport ?? incoming.defaultImport;
-	if (defaultImport != null) parts.push(defaultImport);
-	const mergedImports = Array.from(new Set([...existing.bindings.imports, ...incoming.bindings.imports]));
-	if (mergedImports.length > 0) parts.push(`{ ${mergedImports.join(", ")} }`);
-	const importKindPrefix = incoming.kind === "value" ? "import" : "import type";
+	const seen = /* @__PURE__ */ new Set();
+	const elements = [];
+	for (const el of [...existing.bindings.elements, ...incoming.bindings.elements]) {
+		const text = el.getText();
+		if (seen.has(text)) continue;
+		seen.add(text);
+		elements.push(ts.factory.createImportSpecifier(el.isTypeOnly, el.propertyName ? ts.factory.createIdentifier(el.propertyName.text) : void 0, ts.factory.createIdentifier(el.name.text)));
+	}
+	const sourceText = existing.source;
+	const isSingleQuote = sourceText.startsWith("'");
+	const sourceValue = sourceText.slice(1, -1);
+	const importDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(incoming.kind === "type", defaultImport != null ? ts.factory.createIdentifier(defaultImport) : void 0, ts.factory.createNamedImports(elements)), ts.factory.createStringLiteral(sourceValue, isSingleQuote));
 	return [{
 		message: "Merge duplicate imports",
 		changes: [{
@@ -149,7 +173,7 @@ function buildSuggestions(existing, incoming) {
 			newText: ""
 		}, {
 			node: existing.node,
-			newText: `${importKindPrefix} ${parts.join(", ")} from ${existing.source};`
+			newText: printNode(importDecl)
 		}]
 	}];
 }
@@ -184,7 +208,9 @@ const messages$1 = {
 */
 const noMultilineTemplateExpressionWithoutAutoDedent = defineRule((options) => {
 	const dedentTagNames = options?.dedentTagNames ?? ["dedent"];
-	const dedentTagImportCallback = options?.dedentTagImportCallback ?? ((name) => `import ${name} from "dedent";\n`);
+	const dedentTagImportCallback = options?.dedentTagImportCallback ?? ((name) => {
+		return printNode(ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(void 0, ts.factory.createIdentifier(name), void 0), ts.factory.createStringLiteral("dedent"))) + "\n";
+	});
 	function getLine(node) {
 		const sourceFile = node.getSourceFile();
 		return [sourceFile.getLineAndCharacterOfPosition(node.getStart()).line, sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line];
@@ -244,6 +270,7 @@ const nullish = defineRule((options) => ({
 	visitor: { BinaryExpression(ctx, node) {
 		const newOperatorText = match(node.operatorToken.kind).with(SyntaxKind.EqualsEqualsEqualsToken, () => "==").with(SyntaxKind.ExclamationEqualsEqualsToken, () => "!=").otherwise(() => null);
 		if (newOperatorText == null) return;
+		const operatorToken = newOperatorText === "==" ? ts.factory.createToken(ts.SyntaxKind.EqualsEqualsToken) : ts.factory.createToken(ts.SyntaxKind.ExclamationEqualsToken);
 		const offendingChild = [node.left, node.right].find((n) => {
 			switch (n.kind) {
 				case SyntaxKind.NullKeyword: return true;
@@ -252,17 +279,18 @@ const nullish = defineRule((options) => ({
 			}
 		});
 		if (offendingChild == null) return;
+		const nullNode = ts.factory.createNull();
 		ctx.report({
 			message: messages.default({ op: newOperatorText }),
 			node,
 			suggestions: [{
-				message: messages.replace({ expr: offendingChild === node.left ? `null ${newOperatorText} ${node.right.getText()}` : `${node.left.getText()} ${newOperatorText} null` }),
+				message: messages.replace({ expr: printNode(offendingChild === node.left ? ts.factory.createBinaryExpression(nullNode, operatorToken, node.right) : ts.factory.createBinaryExpression(node.left, operatorToken, nullNode)) }),
 				changes: [{
 					node: node.operatorToken,
-					newText: newOperatorText
+					newText: printNode(operatorToken)
 				}, {
 					node: offendingChild,
-					newText: "null"
+					newText: printNode(nullNode)
 				}]
 			}]
 		});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsl-dx",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "A tsl plugin for better JavaScript/TypeScript DX.",
   "keywords": [
     "tsl",
@@ -28,7 +28,7 @@
     "dedent": "^1.7.2",
     "tsdown": "^0.21.9",
     "tsl": "^1.0.30",
-    "vitest": "^4.1.4",
+    "vitest": "^4.1.5",
     "@local/configs": "0.0.0",
     "@local/eff": "0.2.9"
   },