tsl-dx 0.7.2 → 0.9.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { defineRule } from "tsl";
 import ts, { SyntaxKind } from "typescript";
-import { P, match } from "ts-pattern";
+import { match } from "ts-pattern";
 
 //#region src/rules/no-duplicate-exports.ts
 const messages$3 = { default: (p) => `Duplicate export from module ${p.source}.` };
@@ -37,7 +37,7 @@ const noDuplicateExports = defineRule(() => {
 				ctx.report({
 					node,
 					message: messages$3.default({ source }),
-					suggestions: buildSuggestions(duplicateExport, node)
+					suggestions: buildSuggestions$1(duplicateExport, node)
 				});
 				return;
 			}
@@ -45,7 +45,7 @@ const noDuplicateExports = defineRule(() => {
 		} }
 	};
 });
-function buildSuggestions(a, b) {
+function buildSuggestions$1(a, b) {
 	switch (true) {
 		case ts.isNamedExports(a.exportClause) && ts.isNamedExports(b.exportClause): {
 			const aElements = a.exportClause.elements.map((el) => el.getText());
@@ -66,128 +66,6 @@ function buildSuggestions(a, b) {
 	}
 }
 
-//#endregion
-//#region ../../.pkgs/eff/dist/index.js
-/**
-* alias for `undefined`.
-*/
-const unit = void 0;
-/**
-* Creates a function that can be used in a data-last (aka `pipe`able) or
-* data-first style.
-*
-* The first parameter to `dual` is either the arity of the uncurried function
-* or a predicate that determines if the function is being used in a data-first
-* or data-last style.
-*
-* Using the arity is the most common use case, but there are some cases where
-* you may want to use a predicate. For example, if you have a function that
-* takes an optional argument, you can use a predicate to determine if the
-* function is being used in a data-first or data-last style.
-*
-* You can pass either the arity of the uncurried function or a predicate
-* which determines if the function is being used in a data-first or
-* data-last style.
-*
-* **Example** (Using arity to determine data-first or data-last style)
-*
-* ```ts
-* import { dual, pipe } from "effect/Function"
-*
-* const sum = dual<
-*   (that: number) => (self: number) => number,
-*   (self: number, that: number) => number
-* >(2, (self, that) => self + that)
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* **Example** (Using call signatures to define the overloads)
-*
-* ```ts
-* import { dual, pipe } from "effect/Function"
-*
-* const sum: {
-*   (that: number): (self: number) => number
-*   (self: number, that: number): number
-* } = dual(2, (self: number, that: number): number => self + that)
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* **Example** (Using a predicate to determine data-first or data-last style)
-*
-* ```ts
-* import { dual, pipe } from "effect/Function"
-*
-* const sum = dual<
-*   (that: number) => (self: number) => number,
-*   (self: number, that: number) => number
-* >(
-*   (args) => args.length === 2,
-*   (self, that) => self + that
-* )
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* @param arity - The arity of the uncurried function or a predicate that determines if the function is being used in a data-first or data-last style.
-* @param body - The function to be curried.
-* @since 1.0.0
-*/
-const dual = function(arity, body) {
-	if (typeof arity === "function") return function() {
-		return arity(arguments) ? body.apply(this, arguments) : ((self) => body(self, ...arguments));
-	};
-	switch (arity) {
-		case 0:
-		case 1: throw new RangeError(`Invalid arity ${arity}`);
-		case 2: return function(a, b) {
-			if (arguments.length >= 2) return body(a, b);
-			return function(self) {
-				return body(self, a);
-			};
-		};
-		case 3: return function(a, b, c) {
-			if (arguments.length >= 3) return body(a, b, c);
-			return function(self) {
-				return body(self, a, b);
-			};
-		};
-		default: return function() {
-			if (arguments.length >= arity) return body.apply(this, arguments);
-			const args = arguments;
-			return function(self) {
-				return body(self, ...args);
-			};
-		};
-	}
-};
-/**
-* 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"
-* import { compose } from "effect/Function"
-*
-* const increment = (n: number) => n + 1;
-* const square = (n: number) => n * n;
-*
-* assert.strictEqual(compose(increment, square)(2), 9);
-* ```
-*
-* @since 1.0.0
-*/
-const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
-
 //#endregion
 //#region src/rules/no-duplicate-imports.ts
 const messages$2 = { default: (p) => `Duplicate import from module ${p.source}.` };
@@ -211,64 +89,63 @@ const noDuplicateImports = defineRule(() => {
 	return {
 		name: "dx/no-duplicate-imports",
 		createData() {
-			return { imports: [
-				[],
-				[],
-				[]
-			] };
+			return { imports: new Map([
+				["value", []],
+				["type", []],
+				["defer", []]
+			]) };
 		},
 		visitor: { ImportDeclaration(ctx, node) {
 			if (node.importClause == null) return;
-			const importKind = getImportKind(node);
+			const importKind = match(node.importClause.phaseModifier).with(ts.SyntaxKind.TypeKeyword, () => "type").with(ts.SyntaxKind.DeferKeyword, () => "defer").otherwise(() => "value");
 			const importInfo = {
 				node,
 				source: node.moduleSpecifier.getText(),
 				kind: importKind,
-				...decodeImportClause(node.importClause)
+				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())
+				})).with({ kind: ts.SyntaxKind.NamespaceImport }, (nb) => ({
+					kind: "namespace",
+					name: nb.name.getText()
+				})).otherwise(() => ({
+					kind: "named",
+					imports: []
+				}))
 			};
-			const existingImports = ctx.data.imports[importKind];
+			const existingImports = ctx.data.imports.get(importKind);
 			const duplicateImport = existingImports.find((imp) => imp.source === importInfo.source);
-			if (duplicateImport != null) {
-				ctx.report({
-					node,
-					message: messages$2.default({ source: importInfo.source }),
-					suggestions: importKind > 1 ? [] : [{
-						message: "Merge duplicate imports",
-						changes: [{
-							node,
-							newText: ""
-						}, {
-							node: duplicateImport.node,
-							newText: buildMergedImport(duplicateImport, importInfo)
-						}]
-					}]
-				});
+			if (duplicateImport == null) {
+				existingImports.push(importInfo);
 				return;
 			}
-			existingImports.push(importInfo);
+			ctx.report({
+				node,
+				message: messages$2.default({ source: importInfo.source }),
+				suggestions: buildSuggestions(duplicateImport, importInfo)
+			});
 		} }
 	};
 });
-function getImportKind(node) {
-	return match(node.importClause?.phaseModifier).with(P.nullish, () => 0).with(ts.SyntaxKind.TypeKeyword, () => 1).with(ts.SyntaxKind.DeferKeyword, () => 2).otherwise(() => 0);
-}
-function decodeImportClause(node) {
-	const { name, namedBindings } = node;
-	return {
-		defaultImport: name?.getText(),
-		namedImports: namedBindings != null && ts.isNamedImports(namedBindings) ? namedBindings.elements.map((el) => el.getText()) : [],
-		namespaceImport: namedBindings != null && ts.isNamespaceImport(namedBindings) ? namedBindings.name.getText() : unit
-	};
-}
-function buildMergedImport(a, b) {
+function buildSuggestions(existing, incoming) {
+	if (incoming.kind === "defer" || incoming.bindings.kind === "namespace" || existing.bindings.kind === "namespace") return [];
 	const parts = [];
-	if (a.defaultImport != null) parts.push(a.defaultImport);
-	else if (b.defaultImport != null) parts.push(b.defaultImport);
-	if (a.namespaceImport != null) parts.push(`* as ${a.namespaceImport}`);
-	else if (b.namespaceImport != null) parts.push(`* as ${b.namespaceImport}`);
-	const namedImports = Array.from(new Set([...a.namedImports, ...b.namedImports]));
-	if (namedImports.length > 0) parts.push(`{ ${namedImports.join(", ")} }`);
-	return `${match(a.kind).with(0, () => "import").with(1, () => "import type").with(2, () => "import defer").exhaustive()} ${parts.join(", ")} from ${a.source};`;
+	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";
+	return [{
+		message: "Merge duplicate imports",
+		changes: [{
+			node: incoming.node,
+			newText: ""
+		}, {
+			node: existing.node,
+			newText: `${importKindPrefix} ${parts.join(", ")} from ${existing.source};`
+		}]
+	}];
 }
 
 //#endregion
@@ -338,9 +215,8 @@ const noMultilineTemplateExpressionWithoutAutoDedent = defineRule((options) => {
 //#endregion
 //#region src/rules/nullish.ts
 const messages = {
-	useUnitForUndefined: "Use 'unit' instead of 'undefined'.",
-	useLooseNullishComparison: (p) => `Use '${p.op}' for nullish comparison.`,
-	replaceWithExpression: (p) => `Replace with '${p.expr}'.`
+	default: (p) => `Use '${p.op}' for nullish comparison.`,
+	replace: (p) => `Replace with '${p.expr}'.`
 };
 /**
 * Rule to enforce the use of `unit` instead of `undefined` and loose equality for nullish checks.
@@ -364,69 +240,32 @@ const nullish = defineRule((options) => ({
 	createData(ctx) {
 		return { runtimeLibrary: options?.runtimeLibrary ?? "@local/eff" };
 	},
-	visitor: {
-		Identifier(ctx, node) {
-			if (node.parent.kind === SyntaxKind.BinaryExpression || node.text !== "undefined") return;
-			ctx.report({
-				node,
-				message: messages.useUnitForUndefined,
-				suggestions: [{
-					message: messages.replaceWithExpression({ expr: "unit" }),
-					changes: [{
-						start: 0,
-						end: 0,
-						newText: `import { unit } from '${ctx.data.runtimeLibrary}';\n`
-					}, {
-						node,
-						newText: "unit"
-					}]
-				}]
-			});
-		},
-		UndefinedKeyword(ctx, node) {
-			ctx.report({
-				node,
-				message: messages.useUnitForUndefined,
-				suggestions: [{
-					message: messages.replaceWithExpression({ expr: "unit" }),
-					changes: [{
-						start: 0,
-						end: 0,
-						newText: `import type { unit } from '${ctx.data.runtimeLibrary}';\n`
-					}, {
-						node,
-						newText: "unit"
-					}]
-				}]
-			});
-		},
-		BinaryExpression(ctx, 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.text === "unit" || n.text === "undefined";
-					default: return false;
-				}
-			});
-			if (offendingChild == null) return;
-			ctx.report({
-				message: messages.useLooseNullishComparison({ op: newOperatorText }),
-				node,
-				suggestions: [{
-					message: messages.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"
-					}]
+	visitor: { BinaryExpression(ctx, 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.text === "unit" || n.text === "undefined";
+				default: return false;
+			}
+		});
+		if (offendingChild == null) return;
+		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` }),
+				changes: [{
+					node: node.operatorToken,
+					newText: newOperatorText
+				}, {
+					node: offendingChild,
+					newText: "null"
 				}]
-			});
-		}
-	}
+			}]
+		});
+	} }
 }));
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsl-dx",
-  "version": "0.7.2",
+  "version": "0.9.0",
   "description": "A tsl plugin for better JavaScript/TypeScript DX.",
   "keywords": [
     "tsl",
@@ -24,8 +24,9 @@
     "ts-pattern": "^5.9.0"
   },
   "devDependencies": {
+    "@liautaud/typezod": "^2.0.0",
     "dedent": "^1.7.1",
-    "tsdown": "^0.20.3",
+    "tsdown": "^0.21.0-beta.2",
     "tsl": "^1.0.29",
     "vitest": "^4.0.18",
     "@local/configs": "0.0.0",