tsl-dx 0.5.0 → 0.5.2

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import * as tsl0 from "tsl";
+import * as tsl from "tsl";
 
 //#region src/rules/no-duplicate-exports.d.ts
 /**
@@ -17,7 +17,7 @@ import * as tsl0 from "tsl";
  * export { A, B } from 'module';
  * ```
  */
-declare const noDuplicateExports: (options?: "off" | undefined) => tsl0.Rule<unknown>;
+declare const noDuplicateExports: (options?: "off" | undefined) => tsl.Rule<unknown>;
 //#endregion
 //#region src/rules/no-duplicate-imports.d.ts
 /**
@@ -36,16 +36,12 @@ declare const noDuplicateExports: (options?: "off" | undefined) => tsl0.Rule<unk
  * import { A, B } from 'module';
  * ```
  */
-declare const noDuplicateImports: (options?: "off" | undefined) => tsl0.Rule<unknown>;
+declare const noDuplicateImports: (options?: "off" | undefined) => tsl.Rule<unknown>;
 //#endregion
-//#region src/rules/nullish-comparison.d.ts
-/**
- * Enforces the use of '==' and '!=' for nullish comparisons (i.e., comparisons to null or undefined)
- *
- * Rationale:
- * In TypeScript, using '==' and '!=' for nullish comparisons is a common practice because it checks for both null and undefined values
- * This rule promotes consistency in codebases by ensuring that developers use the appropriate operators for nullish checks
- */
-declare const nullishComparison: (options?: "off" | undefined) => tsl0.Rule<unknown>;
+//#region src/rules/no-multiline-template-expressions-without-auto-dedent.d.ts
+declare const noMultilineTemplateExpressionsWithoutAutoDedent: (options?: "off" | undefined) => tsl.Rule<unknown>;
+//#endregion
+//#region src/rules/nullish.d.ts
+declare const nullish: (options?: Record<string, unknown> | "off" | undefined) => tsl.Rule<unknown>;
 //#endregion
-export { noDuplicateExports, noDuplicateImports, nullishComparison };
+export { noDuplicateExports, noDuplicateImports, noMultilineTemplateExpressionsWithoutAutoDedent, nullish };

package/dist/index.js

@@ -3,7 +3,7 @@ import ts, { SyntaxKind } from "typescript";
 import { P, match } from "ts-pattern";
 
 //#region src/rules/no-duplicate-exports.ts
-const messages$2 = { default: (p) => `Duplicate export from module ${p.source}.` };
+const messages$3 = { default: (p) => `Duplicate export from module ${p.source}.` };
 function isReExportDeclaration(node) {
 	return node.exportClause != null && node.moduleSpecifier != null;
 }
@@ -36,7 +36,7 @@ const noDuplicateExports = defineRule(() => {
 			if (duplicateExport != null) {
 				ctx.report({
 					node,
-					message: messages$2.default({ source }),
+					message: messages$3.default({ source }),
 					suggestions: buildSuggestions(duplicateExport, node)
 				});
 				return;
@@ -187,7 +187,7 @@ const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
 
 //#endregion
 //#region src/rules/no-duplicate-imports.ts
-const messages$1 = { default: (p) => `Duplicate import from module ${p.source}.` };
+const messages$2 = { default: (p) => `Duplicate import from module ${p.source}.` };
 /**
 * Rule to detect and merge duplicate `import from` statements from the same module.
 *
@@ -228,7 +228,7 @@ const noDuplicateImports = defineRule(() => {
 			if (duplicateImport != null) {
 				ctx.report({
 					node,
-					message: messages$1.default({ source: importInfo.source }),
+					message: messages$2.default({ source: importInfo.source }),
 					suggestions: importKind > 1 ? [] : [{
 						message: "Merge duplicate imports",
 						changes: [{
@@ -269,47 +269,87 @@ function buildMergedImport(a, b) {
 }
 
 //#endregion
-//#region src/rules/nullish-comparison.ts
-const messages = {
-	default: (p) => `Use '${p.op}' for nullish comparison.`,
-	replace: (p) => `Replace with '${p.expr}'.`
-};
-/**
-* Enforces the use of '==' and '!=' for nullish comparisons (i.e., comparisons to null or undefined)
-*
-* Rationale:
-* In TypeScript, using '==' and '!=' for nullish comparisons is a common practice because it checks for both null and undefined values
-* This rule promotes consistency in codebases by ensuring that developers use the appropriate operators for nullish checks
-*/
-const nullishComparison = defineRule(() => ({
-	name: "dx/nullish-comparison",
-	visitor: { BinaryExpression(context, node) {
-		const newOperatorText = match(node.operatorToken.kind).with(SyntaxKind.EqualsEqualsEqualsToken, () => "==").with(SyntaxKind.ExclamationEqualsEqualsToken, () => "!=").otherwise(() => null);
-		if (newOperatorText == null) return;
-		const offendingChild = [node.left, node.right].find((n) => {
-			switch (n.kind) {
-				case SyntaxKind.NullKeyword: return true;
-				case SyntaxKind.Identifier: return n.escapedText === "undefined";
-				default: return false;
-			}
-		});
-		if (offendingChild == null) return;
-		context.report({
-			message: messages.default({ op: newOperatorText }),
+//#region src/utils/source-file.ts
+function getLine(node) {
+	const sourceFile = node.getSourceFile();
+	return [sourceFile.getLineAndCharacterOfPosition(node.getStart()).line, sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line];
+}
+
+//#endregion
+//#region src/rules/no-multiline-template-expressions-without-auto-dedent.ts
+const messages$1 = { default: () => `Avoid using multiline template expressions without auto-dedent` };
+const noMultilineTemplateExpressionsWithoutAutoDedent = defineRule(() => ({
+	name: "dx/no-multiline-template-expressions-without-auto-dedent",
+	visitor: { NoSubstitutionTemplateLiteral(ctx, node) {
+		if (node.parent.kind === SyntaxKind.TaggedTemplateExpression) return;
+		const [startLine, endLine] = getLine(node);
+		if (startLine !== endLine) ctx.report({
 			node,
-			suggestions: [{
-				message: messages.replace({ expr: offendingChild === node.left ? `null ${newOperatorText} ${node.right.getText()}` : `${node.left.getText()} ${newOperatorText} null` }),
-				changes: [{
-					node: node.operatorToken,
-					newText: newOperatorText
-				}, {
-					node: offendingChild,
-					newText: "null"
-				}]
-			}]
+			message: messages$1.default()
 		});
 	} }
 }));
 
 //#endregion
-export { noDuplicateExports, noDuplicateImports, nullishComparison };
+//#region src/rules/nullish.ts
+const messages = {
+	useUnitForUndefined: "Use 'unit' instead of 'undefined'.",
+	useLooseNullishComparison: (p) => `Use '${p.op}' for nullish comparison.`
+};
+const suggestions = { replaceWithExpression: (p) => `Replace with '${p.expr}'.` };
+const nullish = defineRule((options) => ({
+	name: "dx/nullish",
+	createData(ctx) {
+		return { runtimeLibrary: options?.runtimeLibrary ?? "@local/eff" };
+	},
+	visitor: {
+		UndefinedKeyword(ctx, node) {
+			if (node.getSourceFile().isDeclarationFile) return;
+			ctx.report({
+				node,
+				message: messages.useUnitForUndefined,
+				suggestions: [{
+					message: suggestions.replaceWithExpression({ expr: "unit" }),
+					changes: [{
+						node,
+						newText: "unit"
+					}, {
+						start: 0,
+						end: 0,
+						newText: `import { unit } from '${ctx.data.runtimeLibrary}';\n`
+					}]
+				}]
+			});
+		},
+		BinaryExpression(ctx, node) {
+			if (node.getSourceFile().isDeclarationFile) return;
+			const newOperatorText = match(node.operatorToken.kind).with(SyntaxKind.EqualsEqualsEqualsToken, () => "==").with(SyntaxKind.ExclamationEqualsEqualsToken, () => "!=").otherwise(() => null);
+			if (newOperatorText == null) return;
+			const offendingChild = [node.left, node.right].find((n) => {
+				switch (n.kind) {
+					case SyntaxKind.NullKeyword: return true;
+					case SyntaxKind.Identifier: return n.escapedText === "undefined";
+					default: return false;
+				}
+			});
+			if (offendingChild == null) return;
+			ctx.report({
+				message: messages.useLooseNullishComparison({ op: newOperatorText }),
+				node,
+				suggestions: [{
+					message: suggestions.replaceWithExpression({ expr: offendingChild === node.left ? `null ${newOperatorText} ${node.right.getText()}` : `${node.left.getText()} ${newOperatorText} null` }),
+					changes: [{
+						node: node.operatorToken,
+						newText: newOperatorText
+					}, {
+						node: offendingChild,
+						newText: "null"
+					}]
+				}]
+			});
+		}
+	}
+}));
+
+//#endregion
+export { noDuplicateExports, noDuplicateImports, noMultilineTemplateExpressionsWithoutAutoDedent, nullish };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsl-dx",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "A tsl plugin for better JavaScript/TypeScript DX.",
   "keywords": [
     "tsl",
@@ -25,7 +25,7 @@
   },
   "devDependencies": {
     "dedent": "^1.7.1",
-    "tsdown": "^0.20.1",
+    "tsdown": "^0.20.3",
     "tsl": "^1.0.28",
     "vitest": "^4.0.18",
     "@local/configs": "0.0.0",