tsl-dx 0.6.1 → 0.7.1

package/dist/index.d.ts

@@ -39,9 +39,55 @@ declare const noDuplicateExports: (options?: "off" | undefined) => tsl.Rule<unkn
 declare const noDuplicateImports: (options?: "off" | undefined) => tsl.Rule<unknown>;
 //#endregion
 //#region src/rules/no-multiline-template-expression-without-auto-dedent.d.ts
-declare const noMultilineTemplateExpressionWithoutAutoDedent: (options?: "off" | undefined) => tsl.Rule<unknown>;
+type noMultilineTemplateExpressionWithoutAutoDedentOptions = {
+  dedentTagNames?: string[];
+  dedentTagImportCallback?: (name: string) => string;
+};
+/**
+ * Rule to enforce the use of a dedent tag for multiline template expressions.
+ *
+ * @example
+ *
+ * ```ts
+ * // Incorrect
+ * const message = `
+ *   Hello
+ *   World
+ * `;
+ * ```
+ *
+ * ```ts
+ * // Correct
+ * import dedent from "dedent";
+ * const message = dedent`
+ *   Hello
+ *   World
+ * `;
+ * ```
+ */
+declare const noMultilineTemplateExpressionWithoutAutoDedent: (options?: "off" | noMultilineTemplateExpressionWithoutAutoDedentOptions | undefined) => tsl.Rule<unknown>;
 //#endregion
 //#region src/rules/nullish.d.ts
-declare const nullish: (options?: Record<string, unknown> | "off" | undefined) => tsl.Rule<unknown>;
+type nullishOptions = {
+  runtimeLibrary?: string;
+};
+/**
+ * Rule to enforce the use of `unit` instead of `undefined` and loose equality for nullish checks.
+ *
+ * @example
+ *
+ * ```ts
+ * // Incorrect
+ * let x = undefined;
+ * if (x === undefined) { }
+ * ```
+ *
+ * ```ts
+ * // Correct
+ * let x = unit;
+ * if (x == null) { }
+ * ```
+ */
+declare const nullish: (options?: "off" | nullishOptions | undefined) => tsl.Rule<unknown>;
 //#endregion
 export { noDuplicateExports, noDuplicateImports, noMultilineTemplateExpressionWithoutAutoDedent, nullish };

package/dist/index.js

@@ -170,6 +170,9 @@ const dual = function(arity, body) {
 * Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
 * The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
 *
+* @param self - The first function to apply (or the composed function in data-last style).
+* @param bc - The second function to apply.
+* @returns A composed function that applies both functions in sequence.
 * @example
 * ```ts
 * import * as assert from "node:assert"
@@ -277,26 +280,85 @@ function getLine(node) {
 
 //#endregion
 //#region src/rules/no-multiline-template-expression-without-auto-dedent.ts
-const messages$1 = { default: () => `Avoid using multiline template expression without auto-dedent` };
-const noMultilineTemplateExpressionWithoutAutoDedent = defineRule(() => ({
-	name: "dx/no-multiline-template-expression-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,
-			message: messages$1.default()
-		});
-	} }
-}));
+const messages$1 = {
+	useDedentTag: () => "Use a dedent tag to auto-dedent this template expression's content.",
+	addDedentTag: (p) => `Add a/an '${p.name}' tag to this template expression to auto-dedent its content.`
+};
+/**
+* Rule to enforce the use of a dedent tag for multiline template expressions.
+*
+* @example
+*
+* ```ts
+* // Incorrect
+* const message = `
+*   Hello
+*   World
+* `;
+* ```
+*
+* ```ts
+* // Correct
+* import dedent from "dedent";
+* const message = dedent`
+*   Hello
+*   World
+* `;
+* ```
+*/
+const noMultilineTemplateExpressionWithoutAutoDedent = defineRule((options) => {
+	const dedentTagNames = options?.dedentTagNames ?? ["dedent"];
+	const dedentTagImportCallback = options?.dedentTagImportCallback ?? ((name) => `import ${name} from "dedent";\n`);
+	return {
+		name: "dx/no-multiline-template-expression-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,
+				message: messages$1.useDedentTag(),
+				suggestions: dedentTagNames.map((name) => {
+					return {
+						message: messages$1.addDedentTag({ name }),
+						changes: [{
+							start: 0,
+							end: 0,
+							newText: dedentTagImportCallback(name)
+						}, {
+							node,
+							newText: `${name}${node.getFullText()}`
+						}]
+					};
+				})
+			});
+		} }
+	};
+});
 
 //#endregion
 //#region src/rules/nullish.ts
 const messages = {
 	useUnitForUndefined: "Use 'unit' instead of 'undefined'.",
-	useLooseNullishComparison: (p) => `Use '${p.op}' for nullish comparison.`
+	useLooseNullishComparison: (p) => `Use '${p.op}' for nullish comparison.`,
+	replaceWithExpression: (p) => `Replace with '${p.expr}'.`
 };
-const suggestions = { replaceWithExpression: (p) => `Replace with '${p.expr}'.` };
+/**
+* Rule to enforce the use of `unit` instead of `undefined` and loose equality for nullish checks.
+*
+* @example
+*
+* ```ts
+* // Incorrect
+* let x = undefined;
+* if (x === undefined) { }
+* ```
+*
+* ```ts
+* // Correct
+* let x = unit;
+* if (x == null) { }
+* ```
+*/
 const nullish = defineRule((options) => ({
 	name: "dx/nullish",
 	createData(ctx) {
@@ -304,44 +366,41 @@ const nullish = defineRule((options) => ({
 	},
 	visitor: {
 		Identifier(ctx, node) {
-			if (node.getSourceFile().isDeclarationFile) return;
 			if (node.parent.kind === SyntaxKind.BinaryExpression || node.text !== "undefined") return;
 			ctx.report({
 				node,
 				message: messages.useUnitForUndefined,
 				suggestions: [{
-					message: suggestions.replaceWithExpression({ expr: "unit" }),
+					message: messages.replaceWithExpression({ expr: "unit" }),
 					changes: [{
-						node,
-						newText: "unit"
-					}, {
 						start: 0,
 						end: 0,
 						newText: `import { unit } from '${ctx.data.runtimeLibrary}';\n`
+					}, {
+						node,
+						newText: "unit"
 					}]
 				}]
 			});
 		},
 		UndefinedKeyword(ctx, node) {
-			if (node.getSourceFile().isDeclarationFile) return;
 			ctx.report({
 				node,
 				message: messages.useUnitForUndefined,
 				suggestions: [{
-					message: suggestions.replaceWithExpression({ expr: "unit" }),
+					message: messages.replaceWithExpression({ expr: "unit" }),
 					changes: [{
-						node,
-						newText: "unit"
-					}, {
 						start: 0,
 						end: 0,
 						newText: `import type { unit } from '${ctx.data.runtimeLibrary}';\n`
+					}, {
+						node,
+						newText: "unit"
 					}]
 				}]
 			});
 		},
 		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) => {
@@ -356,7 +415,7 @@ const nullish = defineRule((options) => ({
 				message: messages.useLooseNullishComparison({ op: newOperatorText }),
 				node,
 				suggestions: [{
-					message: suggestions.replaceWithExpression({ expr: offendingChild === node.left ? `null ${newOperatorText} ${node.right.getText()}` : `${node.left.getText()} ${newOperatorText} null` }),
+					message: messages.replaceWithExpression({ expr: offendingChild === node.left ? `null ${newOperatorText} ${node.right.getText()}` : `${node.left.getText()} ${newOperatorText} null` }),
 					changes: [{
 						node: node.operatorToken,
 						newText: newOperatorText

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsl-dx",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "description": "A tsl plugin for better JavaScript/TypeScript DX.",
   "keywords": [
     "tsl",
@@ -26,7 +26,7 @@
   "devDependencies": {
     "dedent": "^1.7.1",
     "tsdown": "^0.20.3",
-    "tsl": "^1.0.28",
+    "tsl": "^1.0.29",
     "vitest": "^4.0.18",
     "@local/configs": "0.0.0",
     "@local/eff": "0.2.9"