tsl-dx 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rel1cx
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+import * as tsl0 from "tsl";
+
+//#region src/rules/consistent-nullish-comparison.d.ts
+/**
+ * Rule to enforce the use of `== null` or `!= null` for nullish comparisons.
+ *
+ * @since 0.0.0
+ */
+declare const consistentNullishComparison: (options?: "off" | undefined) => tsl0.Rule<unknown>;
+//#endregion
+//#region src/rules/no-duplicate-exports.d.ts
+/**
+ * Rule to detect and merge duplicate `export from` statements from the same module.
+ *
+ * @example
+ *
+ * ```ts
+ * // Incorrect
+ * export { A } from 'module';
+ * export { B } from 'module';
+ * ```
+ *
+ * ```ts
+ * // Correct
+ * export { A, B } from 'module';
+ * ```
+ */
+declare const noDuplicateExports: (options?: "off" | undefined) => tsl0.Rule<unknown>;
+//#endregion
+//#region src/rules/no-duplicate-imports.d.ts
+/**
+ * Rule to detect and merge duplicate `import from` statements from the same module.
+ *
+ * @example
+ *
+ * ```ts
+ * // Incorrect
+ * import { A } from 'module';
+ * import { B } from 'module';
+ * ```
+ *
+ * ```ts
+ * // Correct
+ * import { A, B } from 'module';
+ * ```
+ */
+declare const noDuplicateImports: (options?: "off" | undefined) => tsl0.Rule<unknown>;
+//#endregion
+export { consistentNullishComparison, noDuplicateExports, noDuplicateImports };

package/dist/index.js

@@ -0,0 +1,309 @@
+import { P, match } from "ts-pattern";
+import { defineRule } from "tsl";
+import ts, { SyntaxKind } from "typescript";
+
+//#region src/rules/consistent-nullish-comparison.ts
+/**
+* Rule to enforce the use of `== null` or `!= null` for nullish comparisons.
+*
+* @since 0.0.0
+*/
+const consistentNullishComparison = defineRule(() => ({
+	name: "local/consistentNullishComparison",
+	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: `Use '${newOperatorText}' for nullish comparison.`,
+			node,
+			suggestions: [{
+				message: offendingChild === node.left ? `Replace with 'null ${newOperatorText} ${node.right.getText()}'.` : `Replace with '${node.left.getText()} ${newOperatorText} null'.`,
+				changes: [{
+					node: node.operatorToken,
+					newText: newOperatorText
+				}, {
+					node: offendingChild,
+					newText: "null"
+				}]
+			}]
+		});
+	} }
+}));
+
+//#endregion
+//#region src/rules/no-duplicate-exports.ts
+const messages$1 = { noDuplicateExports: (p) => `Duplicate export from module ${p.source}.` };
+function isReExportDeclaration(node) {
+	return node.exportClause != null && node.moduleSpecifier != null;
+}
+/**
+* Rule to detect and merge duplicate `export from` statements from the same module.
+*
+* @example
+*
+* ```ts
+* // Incorrect
+* export { A } from 'module';
+* export { B } from 'module';
+* ```
+*
+* ```ts
+* // Correct
+* export { A, B } from 'module';
+* ```
+*/
+const noDuplicateExports = defineRule(() => {
+	return {
+		name: "module/no-duplicate-exports",
+		createData() {
+			return { exports: [] };
+		},
+		visitor: { ExportDeclaration(ctx, node) {
+			if (!isReExportDeclaration(node)) return;
+			const source = node.moduleSpecifier.getText();
+			const duplicateExport = ctx.data.exports.find((exp) => exp.isTypeOnly === node.isTypeOnly && exp.moduleSpecifier.getText() === source);
+			if (duplicateExport != null) {
+				ctx.report({
+					node,
+					message: messages$1.noDuplicateExports({ source }),
+					suggestions: buildSuggestions(duplicateExport, node)
+				});
+				return;
+			}
+			ctx.data.exports.push(node);
+		} }
+	};
+});
+function buildSuggestions(a, b) {
+	switch (true) {
+		case ts.isNamedExports(a.exportClause) && ts.isNamedExports(b.exportClause): {
+			const aElements = a.exportClause.elements.map((el) => el.getText());
+			const bElements = b.exportClause.elements.map((el) => el.getText());
+			const parts = Array.from(new Set([...aElements, ...bElements]));
+			return [{
+				message: "Merge duplicate exports",
+				changes: [{
+					node: a,
+					newText: ""
+				}, {
+					node: b,
+					newText: `export ${a.isTypeOnly ? "type " : ""}{ ${parts.join(", ")} } from ${a.moduleSpecifier.getText()};`
+				}]
+			}];
+		}
+		default: return [];
+	}
+}
+
+//#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`.
+*
+* @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 = { noDuplicateImports: (p) => `Duplicate import from module ${p.source}.` };
+/**
+* Rule to detect and merge duplicate `import from` statements from the same module.
+*
+* @example
+*
+* ```ts
+* // Incorrect
+* import { A } from 'module';
+* import { B } from 'module';
+* ```
+*
+* ```ts
+* // Correct
+* import { A, B } from 'module';
+* ```
+*/
+const noDuplicateImports = defineRule(() => {
+	return {
+		name: "module/no-duplicate-imports",
+		createData() {
+			return { imports: [
+				[],
+				[],
+				[]
+			] };
+		},
+		visitor: { ImportDeclaration(ctx, node) {
+			if (node.importClause == null) return;
+			const importKind = getImportKind(node);
+			const importInfo = {
+				node,
+				source: node.moduleSpecifier.getText(),
+				kind: importKind,
+				...decodeImportClause(node.importClause)
+			};
+			const existingImports = ctx.data.imports[importKind];
+			const duplicateImport = existingImports.find((imp) => imp.source === importInfo.source);
+			if (duplicateImport != null) {
+				ctx.report({
+					node,
+					message: messages.noDuplicateImports({ source: importInfo.source }),
+					suggestions: importKind > 1 ? [] : [{
+						message: "Merge duplicate imports",
+						changes: [{
+							node,
+							newText: ""
+						}, {
+							node: duplicateImport.node,
+							newText: buildMergedImport(duplicateImport, importInfo)
+						}]
+					}]
+				});
+				return;
+			}
+			existingImports.push(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) {
+	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};`;
+}
+
+//#endregion
+export { consistentNullishComparison, noDuplicateExports, noDuplicateImports };

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "tsl-dx",
+  "version": "0.4.0",
+  "description": "A tsl plugin for better JavaScript/TypeScript DX.",
+  "keywords": [
+    "tsl",
+    "tsl-dx"
+  ],
+  "license": "MIT",
+  "author": "Rel1cx<let@ik.me>",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "ts-pattern": "^5.9.0"
+  },
+  "devDependencies": {
+    "dedent": "^1.7.1",
+    "tsdown": "^0.20.1",
+    "tsl": "^1.0.28",
+    "vitest": "^4.0.18",
+    "@local/configs": "0.0.0",
+    "@local/eff": "0.2.9"
+  },
+  "peerDependencies": {
+    "tsl": "^1.0.28",
+    "typescript": "*"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown --dts-resolve",
+    "build:docs": "typedoc",
+    "lint:publish": "pnpm publint",
+    "lint:ts": "tsl",
+    "test": "vitest"
+  }
+}