tsl-dx 0.8.0 → 0.9.0

package/dist/index.d.ts

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

package/dist/index.js

@@ -66,124 +66,6 @@ function buildSuggestions$1(a, b) {
 	}
 }
 
-//#endregion
-//#region ../../.pkgs/eff/dist/index.js
-/**
-* 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}.` };
@@ -220,7 +102,7 @@ const noDuplicateImports = defineRule(() => {
 				node,
 				source: node.moduleSpecifier.getText(),
 				kind: importKind,
-				defaultImport: node.importClause.name?.getText(),
+				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())
@@ -333,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.
@@ -359,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.8.0",
+  "version": "0.9.0",
   "description": "A tsl plugin for better JavaScript/TypeScript DX.",
   "keywords": [
     "tsl",
@@ -26,7 +26,7 @@
   "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",