eslint-plugin-function 0.0.0 → 0.0.4

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,16 @@
+import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts-eslint';
+
+declare const _default: {
+    readonly meta: {
+        readonly name: string;
+        readonly version: string;
+    };
+    readonly rules: {
+        readonly "function-definition": _typescript_eslint_utils_ts_eslint.RuleModule<"functionDefinition", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
+        readonly "function-return-boolean": _typescript_eslint_utils_ts_eslint.RuleModule<"functionReturnBoolean", readonly [{
+            readonly pattern?: string;
+        } | undefined], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
+    };
+};
+
+export { _default as default };

package/dist/index.js

@@ -1,2 +1,237 @@
-export {}
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { unionConstituents, isTypeFlagSet, isTrueLiteralType, isFalseLiteralType } from 'ts-api-utils';
+import { match, isMatching, P } from 'ts-pattern';
+import ts from 'typescript';
+import * as AST from '@eslint-react/ast';
+import '@eslint-react/eff';
+import { getConstrainedTypeAtLocation } from '@typescript-eslint/type-utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/types';
 
+// package.json
+var name = "eslint-plugin-function";
+var version = "0.0.4";
+function getDocsUrl() {
+  return "TODO: add docs for local ESLint rules";
+}
+var createRule = ESLintUtils.RuleCreator(getDocsUrl);
+var tsHelpers = {
+  isAnyType: (type) => isTypeFlagSet(type, ts.TypeFlags.TypeParameter | ts.TypeFlags.Any),
+  isBigIntType: (type) => isTypeFlagSet(type, ts.TypeFlags.BigIntLike),
+  isBooleanType: (type) => isTypeFlagSet(type, ts.TypeFlags.BooleanLike),
+  isEnumType: (type) => isTypeFlagSet(type, ts.TypeFlags.EnumLike),
+  isFalsyBigIntType: (type) => type.isLiteral() && isMatching({ value: { base10Value: "0" } }, type),
+  isFalsyNumberType: (type) => type.isNumberLiteral() && type.value === 0,
+  isFalsyStringType: (type) => type.isStringLiteral() && type.value === "",
+  isNeverType: (type) => isTypeFlagSet(type, ts.TypeFlags.Never),
+  isNullishType: (type) => isTypeFlagSet(
+    type,
+    ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.VoidLike
+  ),
+  isNumberType: (type) => isTypeFlagSet(type, ts.TypeFlags.NumberLike),
+  isObjectType: (type) => !isTypeFlagSet(
+    type,
+    ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.VoidLike | ts.TypeFlags.BooleanLike | ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BigIntLike | ts.TypeFlags.TypeParameter | ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never
+  ),
+  isStringType: (type) => isTypeFlagSet(type, ts.TypeFlags.StringLike),
+  isTruthyBigIntType: (type) => type.isLiteral() && isMatching({ value: { base10Value: P.not("0") } }, type),
+  isTruthyNumberType: (type) => type.isNumberLiteral() && type.value !== 0,
+  isTruthyStringType: (type) => type.isStringLiteral() && type.value !== "",
+  isUnknownType: (type) => isTypeFlagSet(type, ts.TypeFlags.Unknown)
+};
+
+// src/utils/inspect-variant-types.ts
+function inspectVariantTypes(types) {
+  const variantTypes = /* @__PURE__ */ new Set();
+  if (types.some(tsHelpers.isUnknownType)) {
+    variantTypes.add("unknown");
+    return variantTypes;
+  }
+  if (types.some(tsHelpers.isNullishType)) {
+    variantTypes.add("nullish");
+  }
+  const booleans = types.filter(tsHelpers.isBooleanType);
+  switch (true) {
+    case (booleans.length === 1 && booleans[0] != null): {
+      const first = booleans[0];
+      if (isTrueLiteralType(first)) {
+        variantTypes.add("truthy boolean");
+      } else if (isFalseLiteralType(first)) {
+        variantTypes.add("falsy boolean");
+      }
+      break;
+    }
+    case booleans.length === 2: {
+      variantTypes.add("boolean");
+      break;
+    }
+  }
+  const strings = types.filter(tsHelpers.isStringType);
+  if (strings.length > 0) {
+    const evaluated = match(strings).when((types2) => types2.every(tsHelpers.isTruthyStringType), () => "truthy string").when((types2) => types2.every(tsHelpers.isFalsyStringType), () => "falsy string").otherwise(() => "string");
+    variantTypes.add(evaluated);
+  }
+  const bigints = types.filter(tsHelpers.isBigIntType);
+  if (bigints.length > 0) {
+    const evaluated = match(bigints).when((types2) => types2.every(tsHelpers.isTruthyBigIntType), () => "truthy bigint").when((types2) => types2.every(tsHelpers.isFalsyBigIntType), () => "falsy bigint").otherwise(() => "bigint");
+    variantTypes.add(evaluated);
+  }
+  const numbers = types.filter(tsHelpers.isNumberType);
+  if (numbers.length > 0) {
+    const evaluated = match(numbers).when((types2) => types2.every(tsHelpers.isTruthyNumberType), () => "truthy number").when((types2) => types2.every(tsHelpers.isFalsyNumberType), () => "falsy number").otherwise(() => "number");
+    variantTypes.add(evaluated);
+  }
+  if (types.some(tsHelpers.isEnumType)) {
+    variantTypes.add("enum");
+  }
+  if (types.some(tsHelpers.isObjectType)) {
+    variantTypes.add("object");
+  }
+  if (types.some(tsHelpers.isAnyType)) {
+    variantTypes.add("any");
+  }
+  if (types.some(tsHelpers.isNeverType)) {
+    variantTypes.add("never");
+  }
+  return variantTypes;
+}
+
+// src/utils/regexp.ts
+var RE_REGEXP_STR = /^\/(.+)\/([A-Za-z]*)$/u;
+function toRegExp(string) {
+  const [, pattern, flags = "u"] = RE_REGEXP_STR.exec(string) ?? [];
+  if (pattern) return new RegExp(pattern, flags);
+  return { test: (s) => s === string };
+}
+
+// src/rules/function-definition.ts
+var RULE_NAME = "function-definition";
+var RULE_FEATURES = [];
+var function_definition_default = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce a consistent function definition style.",
+      [Symbol.for("rule_features")]: RULE_FEATURES
+    },
+    messages: {
+      functionDefinition: ""
+    },
+    schema: []
+  },
+  name: RULE_NAME,
+  create,
+  defaultOptions: []
+});
+function create(context) {
+  return {};
+}
+var RULE_NAME2 = "function-return-boolean";
+var RULE_FEATURES2 = [];
+var defaultPattern = "/^(is|should)/u";
+var defaultOptions = [
+  {
+    pattern: defaultPattern
+  }
+];
+var allowedVariants = [
+  "boolean",
+  "falsy boolean",
+  "truthy boolean"
+];
+var function_return_boolean_default = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce functions that match the pattern `/^(is|should)/u` return a boolean.",
+      [Symbol.for("rule_features")]: RULE_FEATURES2
+    },
+    messages: {
+      functionReturnBoolean: "The function '{{functionName}}' should return a boolean value (got {{variants}})."
+    },
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        pattern: {
+          type: "string",
+          description: "The pattern to match function names against."
+        }
+      }
+    }]
+  },
+  name: RULE_NAME2,
+  create: create2,
+  defaultOptions
+});
+function create2(context, [opts]) {
+  const services = ESLintUtils.getParserServices(context, false);
+  const pattern = toRegExp(opts?.pattern ?? defaultPattern);
+  const functionEntries = [];
+  function handleReturnExpression(context2, returnExpression, onViolation) {
+    if (returnExpression == null) {
+      onViolation(returnExpression, { variants: "nullish" });
+      return;
+    }
+    const returnType = getConstrainedTypeAtLocation(services, returnExpression);
+    const parts = inspectVariantTypes(unionConstituents(returnType));
+    if (allowedVariants.some((variant) => parts.has(variant))) return;
+    onViolation(returnExpression, {
+      variants: [...parts].map((part) => `'${part}'`).join(", ")
+    });
+  }
+  return {
+    [":function"](node) {
+      const functionName = AST.getFunctionIdentifier(node)?.name;
+      const isMatched = functionName != null && pattern.test(functionName);
+      functionEntries.push({ functionName, functionNode: node, isMatched });
+    },
+    [":function:exit"]() {
+      functionEntries.pop();
+    },
+    ["ArrowFunctionExpression"](node) {
+      const { functionName, isMatched = false } = functionEntries.at(-1) ?? {};
+      if (functionName == null || !isMatched) return;
+      if (node.body.type === AST_NODE_TYPES.BlockStatement) return;
+      handleReturnExpression(context, node.body, (expr, data) => {
+        context.report({
+          messageId: "functionReturnBoolean",
+          node: expr ?? node,
+          data: {
+            ...data,
+            functionName
+          }
+        });
+      });
+    },
+    ["ReturnStatement"](node) {
+      const { functionName, functionNode, isMatched = false } = functionEntries.at(-1) ?? {};
+      if (functionName == null || functionNode == null || !isMatched) return;
+      handleReturnExpression(context, node.argument, (expr, data) => {
+        const functionName2 = AST.getFunctionIdentifier(functionNode)?.name;
+        if (functionName2 == null) return;
+        context.report({
+          messageId: "functionReturnBoolean",
+          node: expr ?? node.argument ?? node,
+          data: {
+            ...data,
+            functionName: functionName2
+          }
+        });
+      });
+    }
+  };
+}
+
+// src/index.ts
+var index_default = {
+  meta: {
+    name,
+    version
+  },
+  rules: {
+    "function-definition": function_definition_default,
+    "function-return-boolean": function_return_boolean_default
+  }
+};
+
+export { index_default as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-function",
-  "version": "0.0.0",
+  "version": "0.0.4",
   "description": "ESLint plugin for function",
   "sideEffects": false,
   "type": "module",
@@ -14,12 +14,36 @@
     "dist",
     "package.json"
   ],
-  "dependencies": {},
+  "dependencies": {
+    "@eslint-react/ast": "^1.38.0",
+    "@eslint-react/eff": "^1.38.0",
+    "@eslint-react/kit": "^1.38.0",
+    "@typescript-eslint/scope-manager": "^8.28.0",
+    "@typescript-eslint/type-utils": "^8.28.0",
+    "@typescript-eslint/types": "^8.28.0",
+    "@typescript-eslint/utils": "^8.28.0",
+    "string-ts": "^2.2.1",
+    "ts-pattern": "^5.6.2"
+  },
   "devDependencies": {
-    "tsup": "^8.4.0"
+    "@eslint/markdown": "^6.3.0",
+    "@tsconfig/node22": "^22.0.1",
+    "@tsconfig/strictest": "^2.0.5",
+    "@types/node": "^22.13.13",
+    "@typescript-eslint/rule-tester": "^8.28.0",
+    "dedent": "^1.5.3",
+    "eslint": "^9.23.0",
+    "eslint-config-flat-gitignore": "^2.1.0",
+    "eslint-plugin-vitest": "^0.5.4",
+    "jiti": "^2.4.2",
+    "tsup": "^8.4.0",
+    "typescript-eslint": "^8.28.0",
+    "vitest": "^3.0.9",
+    "@local/configs": "0.0.0"
   },
   "peerDependencies": {
     "eslint": "^8.57.0 || ^9.0.0",
+    "ts-api-utils": "^2.1.0",
     "typescript": "^4.9.5 || ^5.3.3"
   },
   "engines": {