@akanjs/lint 0.0.53 → 0.0.55

package/index.mjs

@@ -0,0 +1,15 @@
+import { noImportClientFunctions } from "./src/rules/noImportClientFunctions";
+import { noImportExternalLibrary } from "./src/rules/noImportExternalLibrary";
+import { nonScalarPropsRestricted } from "./src/rules/nonScalarPropsRestricted";
+import { useClientByFile } from "./src/rules/useClientByFile";
+var lint_default = {
+  rules: {
+    noImportExternalLibrary,
+    noImportClientFunctions,
+    nonScalarPropsRestricted,
+    useClientByFile
+  }
+};
+export {
+  lint_default as default
+};

package/jest.config.mjs

@@ -0,0 +1,12 @@
+var jest_config_default = {
+  displayName: "eslint-rules",
+  // preset: "../../pkgs/@akanjs/config/src/jest.preset.js",
+  transform: {
+    "^.+\\.[tj]s$": ["ts-jest", { tsconfig: "<rootDir>/tsconfig.spec.json" }]
+  },
+  moduleFileExtensions: ["ts", "js", "html"],
+  coverageDirectory: "../../../coverage/pkgs/@akanjs/lint"
+};
+export {
+  jest_config_default as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/lint",
-  "version": "0.0.53",
+  "version": "0.0.55",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"
@@ -16,5 +16,11 @@
   },
   "dependencies": {
     "@typescript-eslint/utils": "^8.29.1"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    }
   }
 }

package/src/rules/noImportClientFunctions.mjs

@@ -0,0 +1,35 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { fileHasClientFunction, fileIsServerFile } from "../util";
+const noImportClientFunctions = ESLintUtils.RuleCreator(() => __filename)({
+  name: "noImportClientFunctions",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce that client functions are not imported."
+    },
+    messages: {
+      noImportClientFunctions: "Error: Client functions should not be imported."
+    },
+    // fixable: "code",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const isServerFile = fileIsServerFile(context.filename, context.sourceCode.text);
+    if (!isServerFile)
+      return {};
+    return {
+      ImportDeclaration(node) {
+        const hasClientFunction = fileHasClientFunction(node);
+        if (hasClientFunction)
+          context.report({
+            node,
+            messageId: "noImportClientFunctions"
+          });
+      }
+    };
+  }
+});
+export {
+  noImportClientFunctions
+};

package/src/rules/noImportExternalLibrary.mjs

@@ -0,0 +1,41 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { fileIsPureImportFile, getAppName, isInternalImport } from "../util";
+const noImportExternalLibrary = ESLintUtils.RuleCreator(() => __filename)({
+  name: "noImportExternalLibrary",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce that external libraries are not imported."
+    },
+    messages: {
+      noImportExternalLibrary: "Error: External libraries should not be imported."
+    },
+    // fixable: "code",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const isPureImportFile = fileIsPureImportFile(context.filename);
+    if (!isPureImportFile)
+      return {};
+    const filePaths = context.filename.split("/");
+    const appName = getAppName(filePaths);
+    const appPath = appName ? `@${appName}` : null;
+    return {
+      ImportDeclaration(node) {
+        const importPaths = node.source.value.split("/");
+        if (!isInternalImport(importPaths, appPath))
+          context.report({
+            node,
+            messageId: "noImportExternalLibrary"
+            // fix(fixer) {
+            //   return fixer.remove(node);
+            // },
+          });
+      }
+    };
+  }
+});
+export {
+  noImportExternalLibrary
+};

package/src/rules/nonScalarPropsRestricted.mjs

@@ -0,0 +1,41 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { fileIsServerFile, getFilename } from "../util";
+const allowedPropKeySet = /* @__PURE__ */ new Set(["loader", "render", "of"]);
+const nonScalarPropsRestricted = ESLintUtils.RuleCreator(() => __filename)({
+  name: "nonScalarPropsRestricted",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce that non-scalar props are not used."
+    },
+    messages: {
+      nonScalarPropsRestricted: "Error: Non-scalar props should not be used."
+    },
+    // fixable: "code",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const filename = getFilename(context.filename);
+    const isServerFile = fileIsServerFile(context.filename, context.sourceCode.text);
+    if (!isServerFile || !["page.tsx", "layout.tsx"].includes(filename))
+      return {};
+    return {
+      JSXAttribute(node) {
+        if (node.value?.expression) {
+          const { expression, parent } = node.value;
+          if (expression.type === "ArrowFunctionExpression" || expression.type === "FunctionExpression") {
+            if (!allowedPropKeySet.has(parent.name.name))
+              context.report({
+                node,
+                messageId: "nonScalarPropsRestricted"
+              });
+          }
+        }
+      }
+    };
+  }
+});
+export {
+  nonScalarPropsRestricted
+};

package/src/rules/useClientByFile.mjs

@@ -0,0 +1,52 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { fileHasContent, fileHasUseClient, fileIsServerFile } from "../util";
+const useClientByFile = ESLintUtils.RuleCreator(() => __filename)({
+  name: "useClientByFile",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce that `use client` is not used in `server` files."
+    },
+    messages: {
+      noUseClient: 'Error: "use client" should not be used at the top of a `server` file.',
+      forceUseClient: 'Error: "use client" should be used at the top of a `client` file.'
+    },
+    // fixable: "code",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const isServerFile = fileIsServerFile(context.filename, context.sourceCode.text);
+    if (isServerFile === null)
+      return {};
+    if (isServerFile)
+      return {
+        Program(node) {
+          if (!fileHasContent(context, node))
+            return;
+          const { hasUseClient, firstLineIdx } = fileHasUseClient(context);
+          if (hasUseClient)
+            context.report({
+              node: node.body[firstLineIdx],
+              messageId: "noUseClient"
+            });
+        }
+      };
+    else
+      return {
+        Program(node) {
+          if (!fileHasContent(context, node))
+            return;
+          const { hasUseClient, firstLineIdx } = fileHasUseClient(context);
+          if (!hasUseClient)
+            context.report({
+              node: node.body[firstLineIdx],
+              messageId: "forceUseClient"
+            });
+        }
+      };
+  }
+});
+export {
+  useClientByFile
+};

package/src/util/fileHasClientFunction.mjs

@@ -0,0 +1,24 @@
+const reactClientFunctionSet = /* @__PURE__ */ new Set([
+  "useState",
+  "useEffect",
+  "useContext",
+  "useReducer",
+  "useCallback",
+  "useMemo",
+  "useRef",
+  "useImperativeHandle",
+  "useLayoutEffect",
+  "useDebugValue"
+]);
+const frameworkClientFunctionSet = /* @__PURE__ */ new Set(["st"]);
+const fileHasClientFunction = (node) => {
+  if (node.source.value === "react")
+    return node.specifiers.some((specifier) => reactClientFunctionSet.has(specifier.local.name));
+  else if (node.specifiers.some((specifier) => frameworkClientFunctionSet.has(specifier.local.name)))
+    return true;
+  else
+    return false;
+};
+export {
+  fileHasClientFunction
+};

package/src/util/fileHasContent.mjs

@@ -0,0 +1,7 @@
+const fileHasContent = (context, node) => {
+  const firstToken = context.sourceCode.getFirstToken(node);
+  return !!firstToken;
+};
+export {
+  fileHasContent
+};

package/src/util/fileHasUseClient.mjs

@@ -0,0 +1,7 @@
+const fileHasUseClient = (context) => {
+  const firstLineIdx = context.sourceCode.lines.findIndex((line) => line.trim() !== "");
+  return { hasUseClient: context.sourceCode.lines[firstLineIdx].includes('"use client"'), firstLineIdx };
+};
+export {
+  fileHasUseClient
+};

package/src/util/fileIsPureImportFile.mjs

@@ -0,0 +1,40 @@
+const fileSuffixSet = /* @__PURE__ */ new Set([
+  "page.tsx",
+  "layout.tsx",
+  "index.ts",
+  "cnst_.ts",
+  "cnst.ts",
+  "db.ts",
+  "dict.ts",
+  "fetch.ts",
+  "option.ts",
+  "sig.ts",
+  "srv.ts",
+  "st.ts",
+  "usePage.ts",
+  "_server.ts",
+  "constant.ts",
+  "dictionary.ts",
+  "document.ts",
+  "service.ts",
+  "signal.ts",
+  "spec.ts",
+  "test.ts",
+  "store.ts",
+  "Template.tsx",
+  "Unit.tsx",
+  "Util.tsx",
+  "View.tsx",
+  "Zone.tsx",
+  "index.tsx"
+]);
+const fileIsPureImportFile = (filename) => {
+  const suffixFilename = filename.split("/").at(-1)?.split(".").slice(-2).join(".") ?? "";
+  if (fileSuffixSet.has(suffixFilename))
+    return true;
+  else
+    return false;
+};
+export {
+  fileIsPureImportFile
+};

package/src/util/fileIsServerFile.mjs

@@ -0,0 +1,37 @@
+const serverFileNameSet = /* @__PURE__ */ new Set();
+const clientFileNameSet = /* @__PURE__ */ new Set(["st.ts", "store.ts"]);
+const serverFileSuffixSet = /* @__PURE__ */ new Set(["page.tsx", "layout.tsx", "Unit.tsx", "View.tsx"]);
+const clientFileSuffixSet = /* @__PURE__ */ new Set(["Zone.tsx", "Util.tsx", "Template.tsx"]);
+const fileIsServerFile = (absFilePath, sourceCode) => {
+  if (absFilePath.includes("eslint-rules"))
+    return true;
+  const filePaths = absFilePath.split("/");
+  const filename = filePaths.at(-1) ?? "";
+  const fileLastName = absFilePath.split(".").slice(-2).join(".");
+  if (filename === "page.tsx") {
+    if (filePaths.includes("admin"))
+      return false;
+    else
+      return true;
+  }
+  if (filename === "layout.tsx") {
+    if (filePaths.at(-2) === "app")
+      return false;
+    else
+      return true;
+  }
+  if (serverFileNameSet.has(filename))
+    return true;
+  if (clientFileNameSet.has(filename))
+    return false;
+  if (serverFileSuffixSet.has(fileLastName))
+    return true;
+  if (clientFileSuffixSet.has(fileLastName))
+    return false;
+  if (new RegExp(/useEffect|useState|useContext|st\.do\.|st\.use\./g).test(sourceCode))
+    return false;
+  return null;
+};
+export {
+  fileIsServerFile
+};

package/src/util/getAppName.mjs

@@ -0,0 +1,8 @@
+const getAppName = (filePaths) => {
+  const appsIdx = filePaths.findIndex((part) => part === "apps");
+  const appName = appsIdx === -1 ? null : filePaths[appsIdx + 1];
+  return appName;
+};
+export {
+  getAppName
+};

package/src/util/getFilename.mjs

@@ -0,0 +1,7 @@
+const getFilename = (absFilePath) => {
+  const filePaths = absFilePath.split("/");
+  return filePaths.at(-1) ?? "";
+};
+export {
+  getFilename
+};

package/src/util/index.mjs

@@ -0,0 +1,18 @@
+import { fileIsServerFile } from "./fileIsServerFile";
+import { fileHasUseClient } from "./fileHasUseClient";
+import { fileHasContent } from "./fileHasContent";
+import { fileHasClientFunction } from "./fileHasClientFunction";
+import { getFilename } from "./getFilename";
+import { fileIsPureImportFile } from "./fileIsPureImportFile";
+import { isInternalImport } from "./isInternalImport";
+import { getAppName } from "./getAppName";
+export {
+  fileHasClientFunction,
+  fileHasContent,
+  fileHasUseClient,
+  fileIsPureImportFile,
+  fileIsServerFile,
+  getAppName,
+  getFilename,
+  isInternalImport
+};

package/src/util/isInternalImport.mjs

@@ -0,0 +1,25 @@
+import * as fs from "fs";
+const projectRoot = process.cwd();
+const libNames = [...fs.readdirSync(`${projectRoot}/libs`), ...fs.readdirSync(`${projectRoot}/pkgs`)];
+const internalImportSet = /* @__PURE__ */ new Set([
+  ...libNames.map((libName) => `@${libName}`),
+  "react-icons",
+  "react",
+  "next",
+  "@radix-ui",
+  "@playwright",
+  "@akanjs",
+  ".",
+  ".."
+]);
+const isInternalImport = (importPaths, appName) => {
+  if (internalImportSet.has(importPaths[0]))
+    return true;
+  else if (importPaths[0] === appName)
+    return true;
+  else
+    return false;
+};
+export {
+  isInternalImport
+};