@valbuild/eslint-plugin 0.22.0

package/dist/valbuild-eslint-plugin.cjs.dev.js

@@ -0,0 +1,75 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var path = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+// @ts-check
+var getExpectedValModuleName = function getExpectedValModuleName( /** @type {{ report?: (arg0: { node: any; message: string; fix: ((fixer: any) => any) | ((fixer: any) => any); }) => void; getFilename?: any; cwd?: any; }} */context) {
+  var filename = context.getFilename();
+  if (filename.endsWith(".val.ts") || filename.endsWith(".val.js")) {
+    var root = context.cwd || process.cwd();
+    var relativePath = path__default["default"].relative(root, filename);
+    var expectedValue = relativePath.replace(/\.val\.(ts|js)$/, "");
+    return "/".concat(expectedValue);
+  }
+};
+var noIllegalModuleIds = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Check that the first argument of export default declaration matches the string from val.config.ts file.",
+      category: "Best Practices",
+      recommended: "error"
+    },
+    fixable: "code",
+    schema: []
+  },
+  create: function create( /** @type {{ report: (arg0: { node: any; message: string; fix: ((fixer: any) => any) | ((fixer: any) => any); }) => void; }} */context) {
+    var expectedValue = getExpectedValModuleName(context);
+    return {
+      /**
+       * @param {{ declaration: { arguments: string | any[]; }; }} node
+       */
+      ExportDefaultDeclaration: function ExportDefaultDeclaration(node) {
+        if (!expectedValue) {
+          return;
+        }
+        if (node.declaration && node.declaration.arguments && node.declaration.arguments.length > 0) {
+          var firstArg = node.declaration.arguments[0];
+          if (firstArg.type === "TemplateLiteral") {
+            context.report({
+              node: firstArg,
+              message: "val.content first argument should not be a template literal",
+              fix: function fix(fixer) {
+                return fixer.replaceText(firstArg, "\"".concat(expectedValue, "\""));
+              }
+            });
+          }
+          if (firstArg.type === "Literal" && typeof firstArg.value === "string") {
+            if (firstArg.value !== expectedValue) {
+              context.report({
+                node: firstArg,
+                message: "val.content first argument must match filename",
+                fix: function fix(fixer) {
+                  return fixer.replaceText(firstArg, "".concat(firstArg.raw[0]).concat(expectedValue).concat(firstArg.raw[0]));
+                }
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+};
+
+// @ts-check
+var rules = {
+  "no-illegal-module-ids": noIllegalModuleIds
+};
+
+exports.rules = rules;

package/dist/valbuild-eslint-plugin.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./valbuild-eslint-plugin.cjs.prod.js");
+} else {
+  module.exports = require("./valbuild-eslint-plugin.cjs.dev.js");
+}

package/dist/valbuild-eslint-plugin.cjs.prod.js

@@ -0,0 +1,75 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var path = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+// @ts-check
+var getExpectedValModuleName = function getExpectedValModuleName( /** @type {{ report?: (arg0: { node: any; message: string; fix: ((fixer: any) => any) | ((fixer: any) => any); }) => void; getFilename?: any; cwd?: any; }} */context) {
+  var filename = context.getFilename();
+  if (filename.endsWith(".val.ts") || filename.endsWith(".val.js")) {
+    var root = context.cwd || process.cwd();
+    var relativePath = path__default["default"].relative(root, filename);
+    var expectedValue = relativePath.replace(/\.val\.(ts|js)$/, "");
+    return "/".concat(expectedValue);
+  }
+};
+var noIllegalModuleIds = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Check that the first argument of export default declaration matches the string from val.config.ts file.",
+      category: "Best Practices",
+      recommended: "error"
+    },
+    fixable: "code",
+    schema: []
+  },
+  create: function create( /** @type {{ report: (arg0: { node: any; message: string; fix: ((fixer: any) => any) | ((fixer: any) => any); }) => void; }} */context) {
+    var expectedValue = getExpectedValModuleName(context);
+    return {
+      /**
+       * @param {{ declaration: { arguments: string | any[]; }; }} node
+       */
+      ExportDefaultDeclaration: function ExportDefaultDeclaration(node) {
+        if (!expectedValue) {
+          return;
+        }
+        if (node.declaration && node.declaration.arguments && node.declaration.arguments.length > 0) {
+          var firstArg = node.declaration.arguments[0];
+          if (firstArg.type === "TemplateLiteral") {
+            context.report({
+              node: firstArg,
+              message: "val.content first argument should not be a template literal",
+              fix: function fix(fixer) {
+                return fixer.replaceText(firstArg, "\"".concat(expectedValue, "\""));
+              }
+            });
+          }
+          if (firstArg.type === "Literal" && typeof firstArg.value === "string") {
+            if (firstArg.value !== expectedValue) {
+              context.report({
+                node: firstArg,
+                message: "val.content first argument must match filename",
+                fix: function fix(fixer) {
+                  return fixer.replaceText(firstArg, "".concat(firstArg.raw[0]).concat(expectedValue).concat(firstArg.raw[0]));
+                }
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+};
+
+// @ts-check
+var rules = {
+  "no-illegal-module-ids": noIllegalModuleIds
+};
+
+exports.rules = rules;

package/dist/valbuild-eslint-plugin.esm.js

@@ -0,0 +1,67 @@
+import path from 'path';
+
+// @ts-check
+var getExpectedValModuleName = function getExpectedValModuleName( /** @type {{ report?: (arg0: { node: any; message: string; fix: ((fixer: any) => any) | ((fixer: any) => any); }) => void; getFilename?: any; cwd?: any; }} */context) {
+  var filename = context.getFilename();
+  if (filename.endsWith(".val.ts") || filename.endsWith(".val.js")) {
+    var root = context.cwd || process.cwd();
+    var relativePath = path.relative(root, filename);
+    var expectedValue = relativePath.replace(/\.val\.(ts|js)$/, "");
+    return "/".concat(expectedValue);
+  }
+};
+var noIllegalModuleIds = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Check that the first argument of export default declaration matches the string from val.config.ts file.",
+      category: "Best Practices",
+      recommended: "error"
+    },
+    fixable: "code",
+    schema: []
+  },
+  create: function create( /** @type {{ report: (arg0: { node: any; message: string; fix: ((fixer: any) => any) | ((fixer: any) => any); }) => void; }} */context) {
+    var expectedValue = getExpectedValModuleName(context);
+    return {
+      /**
+       * @param {{ declaration: { arguments: string | any[]; }; }} node
+       */
+      ExportDefaultDeclaration: function ExportDefaultDeclaration(node) {
+        if (!expectedValue) {
+          return;
+        }
+        if (node.declaration && node.declaration.arguments && node.declaration.arguments.length > 0) {
+          var firstArg = node.declaration.arguments[0];
+          if (firstArg.type === "TemplateLiteral") {
+            context.report({
+              node: firstArg,
+              message: "val.content first argument should not be a template literal",
+              fix: function fix(fixer) {
+                return fixer.replaceText(firstArg, "\"".concat(expectedValue, "\""));
+              }
+            });
+          }
+          if (firstArg.type === "Literal" && typeof firstArg.value === "string") {
+            if (firstArg.value !== expectedValue) {
+              context.report({
+                node: firstArg,
+                message: "val.content first argument must match filename",
+                fix: function fix(fixer) {
+                  return fixer.replaceText(firstArg, "".concat(firstArg.raw[0]).concat(expectedValue).concat(firstArg.raw[0]));
+                }
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+};
+
+// @ts-check
+var rules = {
+  "no-illegal-module-ids": noIllegalModuleIds
+};
+
+export { rules };

package/jest.config.js

@@ -0,0 +1,4 @@
+/** @type {import("jest").Config} */
+module.exports = {
+  preset: "../../jest.preset",
+};

package/jsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "skipLibCheck": true
+  },
+  "exclude": ["dist/**/*"]
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@valbuild/eslint-plugin",
+  "version": "0.22.0",
+  "description": "ESLint rules for val",
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "val",
+    "valbuild"
+  ],
+  "main": "dist/valbuild-eslint-plugin.cjs.js",
+  "module": "dist/valbuild-eslint-plugin.esm.js",
+  "exports": {
+    ".": {
+      "module": "./dist/valbuild-eslint-plugin.esm.js",
+      "default": "./dist/valbuild-eslint-plugin.cjs.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=6"
+  },
+  "license": "MIT",
+  "peerDependencies": {
+    "eslint": "6 || 7 || 8"
+  },
+  "devDependencies": {
+    "eslint": "^7.10.0"
+  },
+  "scripts": {
+    "typecheck": "tsc -p jsconfig.json"
+  }
+}

package/src/index.js

@@ -0,0 +1,7 @@
+// @ts-check
+
+import noIllegalModuleIds from "./rules/noIllegalModuleIds";
+
+export let rules = {
+  "no-illegal-module-ids": noIllegalModuleIds,
+};

package/src/rules/noIllegalModuleIds.js

@@ -0,0 +1,74 @@
+// @ts-check
+import path from "path";
+
+const getExpectedValModuleName = (
+  /** @type {{ report?: (arg0: { node: any; message: string; fix: ((fixer: any) => any) | ((fixer: any) => any); }) => void; getFilename?: any; cwd?: any; }} */ context
+) => {
+  const filename = context.getFilename();
+  if (filename.endsWith(".val.ts") || filename.endsWith(".val.js")) {
+    const root = context.cwd || process.cwd();
+    const relativePath = path.relative(root, filename);
+    const expectedValue = relativePath.replace(/\.val\.(ts|js)$/, "");
+    return `/${expectedValue}`;
+  }
+};
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Check that the first argument of export default declaration matches the string from val.config.ts file.",
+      category: "Best Practices",
+      recommended: "error",
+    },
+    fixable: "code",
+    schema: [],
+  },
+  create: function (
+    /** @type {{ report: (arg0: { node: any; message: string; fix: ((fixer: any) => any) | ((fixer: any) => any); }) => void; }} */ context
+  ) {
+    const expectedValue = getExpectedValModuleName(context);
+    return {
+      /**
+       * @param {{ declaration: { arguments: string | any[]; }; }} node
+       */
+      ExportDefaultDeclaration(node) {
+        if (!expectedValue) {
+          return;
+        }
+        if (
+          node.declaration &&
+          node.declaration.arguments &&
+          node.declaration.arguments.length > 0
+        ) {
+          const firstArg = node.declaration.arguments[0];
+          if (firstArg.type === "TemplateLiteral") {
+            context.report({
+              node: firstArg,
+              message:
+                "val.content first argument should not be a template literal",
+              fix: (fixer) => fixer.replaceText(firstArg, `"${expectedValue}"`),
+            });
+          }
+          if (
+            firstArg.type === "Literal" &&
+            typeof firstArg.value === "string"
+          ) {
+            if (firstArg.value !== expectedValue) {
+              context.report({
+                node: firstArg,
+                message: "val.content first argument must match filename",
+                fix: (fixer) =>
+                  fixer.replaceText(
+                    firstArg,
+                    `${firstArg.raw[0]}${expectedValue}${firstArg.raw[0]}`
+                  ),
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};

package/test/rules/noIllegalModuleIds.test.js

@@ -0,0 +1,73 @@
+import { RuleTester } from "eslint";
+import { rules as valRules } from "@valbuild/eslint-plugin";
+import path from "path";
+
+const rule = valRules["no-illegal-module-ids"];
+
+RuleTester.setDefaultConfig({
+  parserOptions: {
+    ecmaVersion: 2018,
+    sourceType: "module",
+    ecmaFeatures: {
+      jsx: true,
+    },
+  },
+});
+
+const ruleTester = new RuleTester();
+
+ruleTester.run("no-illegal-module-ids", rule, {
+  valid: [
+    {
+      filename: path.join(process.cwd(), "./foo/test.val.ts"),
+      code: `import { val, s } from '../val.config.ts';
+      export const schema = s.string();
+      export default val.content('/foo/test', schema, 'String')`,
+    },
+  ],
+  invalid: [
+    {
+      filename: path.join(process.cwd(), "./foo/test.val.ts"),
+      code: `import { val, s } from '../val.config.ts';
+      export const schema = s.string();
+      export default val.content('foo', schema, 'String')`,
+      errors: [
+        {
+          message: "val.content first argument must match filename",
+        },
+      ],
+      output: `import { val, s } from '../val.config.ts';
+      export const schema = s.string();
+      export default val.content('/foo/test', schema, 'String')`,
+    },
+    {
+      filename: path.join(process.cwd(), "./foo/test.val.ts"),
+      code: `import { val, s } from "../val.config.ts";
+      export const schema = s.string();
+      export default val.content("foo", schema, 'String')`,
+      errors: [
+        {
+          message: "val.content first argument must match filename",
+        },
+      ],
+      output: `import { val, s } from "../val.config.ts";
+      export const schema = s.string();
+      export default val.content("/foo/test", schema, 'String')`,
+    },
+    {
+      filename: path.join(process.cwd(), "./foo/test.val.ts"),
+      code: `import { val, s } from "../val.config.ts";
+      export const schema = s.string();
+      export default val.content(\`foo\`, schema, 'String')`,
+      errors: [
+        {
+          message:
+            "val.content first argument should not be a template literal",
+        },
+      ],
+      output: `import { val, s } from "../val.config.ts";
+      export const schema = s.string();
+      export default val.content("/foo/test", schema, 'String')`,
+    },
+  ],
+});