@valbuild/eslint-plugin 0.63.5 → 0.64.0

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

@@ -168,13 +168,122 @@ var exportContentMustBeValid = {
 
 // @ts-check
 
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+var noDefineWithVariable = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Cannot c.define with a variable",
+      recommended: true
+    },
+    fixable: "code",
+    schema: []
+  },
+  create: function create(context) {
+    return {
+      ExportDefaultDeclaration: function ExportDefaultDeclaration(node) {
+        var decl = node.declaration;
+        if (decl.type === "CallExpression") {
+          var callee = decl.callee;
+          var isDefine = callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "c" && callee.property.type === "Identifier" && callee.property.name === "define";
+          if (isDefine) {
+            var args = decl.arguments;
+            var valueArg = args[2];
+            if (valueArg.type === "Identifier") {
+              context.report({
+                node: valueArg,
+                message: "Val: third argument of c.define cannot be a variable"
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+};
+
+// @ts-check
+
+var message = "Val: c.define must be exported as default";
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+var defaultExportValModule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "c.define must be exported as default",
+      recommended: true
+    },
+    fixable: "code",
+    schema: []
+  },
+  create: function create(context) {
+    return {
+      CallExpression: function CallExpression(node) {
+        if (node.callee.type === "MemberExpression") {
+          var memberExpression = node.callee;
+          if (memberExpression.object.type === "Identifier") {
+            var object = memberExpression.object;
+            if (object.name === "c" && memberExpression.property.type === "Identifier") {
+              var property = memberExpression.property;
+              if (property.name === "define") {
+                var parent = node.parent;
+                if (parent.type === "ExportDefaultDeclaration") {
+                  return;
+                }
+                if (parent.type === "VariableDeclarator") {
+                  var variableInit = parent.init;
+                  if (variableInit && parent.parent.type === "VariableDeclaration") {
+                    context.report({
+                      node: node,
+                      message: message,
+                      fix: function fix(fixer) {
+                        return fixer.replaceText(parent.parent, "export default ".concat(context.sourceCode.getText(variableInit)));
+                      }
+                    });
+                  } else {
+                    context.report({
+                      node: node,
+                      message: message
+                    });
+                  }
+                } else if (parent.type === "ExpressionStatement" && parent.parent.type === "Program") {
+                  context.report({
+                    node: node,
+                    message: message,
+                    fix: function fix(fixer) {
+                      return fixer.replaceText(parent, "export default ".concat(context.sourceCode.getText(parent)));
+                    }
+                  });
+                } else {
+                  context.report({
+                    node: node,
+                    message: message
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+};
+
+// @ts-check
+
 /**
  * @type {Plugin["rules"]}
  */
 var rules = {
   "no-illegal-module-paths": noIllegalModulePaths,
   "no-illegal-imports": noIllegalImports,
-  "export-content-must-be-valid": exportContentMustBeValid
+  "export-content-must-be-valid": exportContentMustBeValid,
+  "no-define-with-variable": noDefineWithVariable,
+  "default-export-val-module": defaultExportValModule
 };
 
 /**
@@ -191,7 +300,9 @@ var configs = {
     rules: {
       "@valbuild/no-illegal-module-paths": "error",
       "@valbuild/no-illegal-imports": "error",
-      "@valbuild/export-content-must-be-valid": "error"
+      "@valbuild/export-content-must-be-valid": "error",
+      "@valbuild/no-define-with-variable": "error",
+      "@valbuild/default-export-val-module": "error"
     }
   }
 };

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

@@ -168,13 +168,122 @@ var exportContentMustBeValid = {
 
 // @ts-check
 
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+var noDefineWithVariable = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Cannot c.define with a variable",
+      recommended: true
+    },
+    fixable: "code",
+    schema: []
+  },
+  create: function create(context) {
+    return {
+      ExportDefaultDeclaration: function ExportDefaultDeclaration(node) {
+        var decl = node.declaration;
+        if (decl.type === "CallExpression") {
+          var callee = decl.callee;
+          var isDefine = callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "c" && callee.property.type === "Identifier" && callee.property.name === "define";
+          if (isDefine) {
+            var args = decl.arguments;
+            var valueArg = args[2];
+            if (valueArg.type === "Identifier") {
+              context.report({
+                node: valueArg,
+                message: "Val: third argument of c.define cannot be a variable"
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+};
+
+// @ts-check
+
+var message = "Val: c.define must be exported as default";
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+var defaultExportValModule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "c.define must be exported as default",
+      recommended: true
+    },
+    fixable: "code",
+    schema: []
+  },
+  create: function create(context) {
+    return {
+      CallExpression: function CallExpression(node) {
+        if (node.callee.type === "MemberExpression") {
+          var memberExpression = node.callee;
+          if (memberExpression.object.type === "Identifier") {
+            var object = memberExpression.object;
+            if (object.name === "c" && memberExpression.property.type === "Identifier") {
+              var property = memberExpression.property;
+              if (property.name === "define") {
+                var parent = node.parent;
+                if (parent.type === "ExportDefaultDeclaration") {
+                  return;
+                }
+                if (parent.type === "VariableDeclarator") {
+                  var variableInit = parent.init;
+                  if (variableInit && parent.parent.type === "VariableDeclaration") {
+                    context.report({
+                      node: node,
+                      message: message,
+                      fix: function fix(fixer) {
+                        return fixer.replaceText(parent.parent, "export default ".concat(context.sourceCode.getText(variableInit)));
+                      }
+                    });
+                  } else {
+                    context.report({
+                      node: node,
+                      message: message
+                    });
+                  }
+                } else if (parent.type === "ExpressionStatement" && parent.parent.type === "Program") {
+                  context.report({
+                    node: node,
+                    message: message,
+                    fix: function fix(fixer) {
+                      return fixer.replaceText(parent, "export default ".concat(context.sourceCode.getText(parent)));
+                    }
+                  });
+                } else {
+                  context.report({
+                    node: node,
+                    message: message
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+};
+
+// @ts-check
+
 /**
  * @type {Plugin["rules"]}
  */
 var rules = {
   "no-illegal-module-paths": noIllegalModulePaths,
   "no-illegal-imports": noIllegalImports,
-  "export-content-must-be-valid": exportContentMustBeValid
+  "export-content-must-be-valid": exportContentMustBeValid,
+  "no-define-with-variable": noDefineWithVariable,
+  "default-export-val-module": defaultExportValModule
 };
 
 /**
@@ -191,7 +300,9 @@ var configs = {
     rules: {
       "@valbuild/no-illegal-module-paths": "error",
       "@valbuild/no-illegal-imports": "error",
-      "@valbuild/export-content-must-be-valid": "error"
+      "@valbuild/export-content-must-be-valid": "error",
+      "@valbuild/no-define-with-variable": "error",
+      "@valbuild/default-export-val-module": "error"
     }
   }
 };

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

@@ -159,13 +159,122 @@ var exportContentMustBeValid = {
 
 // @ts-check
 
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+var noDefineWithVariable = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Cannot c.define with a variable",
+      recommended: true
+    },
+    fixable: "code",
+    schema: []
+  },
+  create: function create(context) {
+    return {
+      ExportDefaultDeclaration: function ExportDefaultDeclaration(node) {
+        var decl = node.declaration;
+        if (decl.type === "CallExpression") {
+          var callee = decl.callee;
+          var isDefine = callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "c" && callee.property.type === "Identifier" && callee.property.name === "define";
+          if (isDefine) {
+            var args = decl.arguments;
+            var valueArg = args[2];
+            if (valueArg.type === "Identifier") {
+              context.report({
+                node: valueArg,
+                message: "Val: third argument of c.define cannot be a variable"
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+};
+
+// @ts-check
+
+var message = "Val: c.define must be exported as default";
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+var defaultExportValModule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "c.define must be exported as default",
+      recommended: true
+    },
+    fixable: "code",
+    schema: []
+  },
+  create: function create(context) {
+    return {
+      CallExpression: function CallExpression(node) {
+        if (node.callee.type === "MemberExpression") {
+          var memberExpression = node.callee;
+          if (memberExpression.object.type === "Identifier") {
+            var object = memberExpression.object;
+            if (object.name === "c" && memberExpression.property.type === "Identifier") {
+              var property = memberExpression.property;
+              if (property.name === "define") {
+                var parent = node.parent;
+                if (parent.type === "ExportDefaultDeclaration") {
+                  return;
+                }
+                if (parent.type === "VariableDeclarator") {
+                  var variableInit = parent.init;
+                  if (variableInit && parent.parent.type === "VariableDeclaration") {
+                    context.report({
+                      node: node,
+                      message: message,
+                      fix: function fix(fixer) {
+                        return fixer.replaceText(parent.parent, "export default ".concat(context.sourceCode.getText(variableInit)));
+                      }
+                    });
+                  } else {
+                    context.report({
+                      node: node,
+                      message: message
+                    });
+                  }
+                } else if (parent.type === "ExpressionStatement" && parent.parent.type === "Program") {
+                  context.report({
+                    node: node,
+                    message: message,
+                    fix: function fix(fixer) {
+                      return fixer.replaceText(parent, "export default ".concat(context.sourceCode.getText(parent)));
+                    }
+                  });
+                } else {
+                  context.report({
+                    node: node,
+                    message: message
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+};
+
+// @ts-check
+
 /**
  * @type {Plugin["rules"]}
  */
 var rules = {
   "no-illegal-module-paths": noIllegalModulePaths,
   "no-illegal-imports": noIllegalImports,
-  "export-content-must-be-valid": exportContentMustBeValid
+  "export-content-must-be-valid": exportContentMustBeValid,
+  "no-define-with-variable": noDefineWithVariable,
+  "default-export-val-module": defaultExportValModule
 };
 
 /**
@@ -182,7 +291,9 @@ var configs = {
     rules: {
       "@valbuild/no-illegal-module-paths": "error",
       "@valbuild/no-illegal-imports": "error",
-      "@valbuild/export-content-must-be-valid": "error"
+      "@valbuild/export-content-must-be-valid": "error",
+      "@valbuild/no-define-with-variable": "error",
+      "@valbuild/default-export-val-module": "error"
     }
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@valbuild/eslint-plugin",
-  "version": "0.63.5",
+  "version": "0.64.0",
   "description": "ESLint rules for val",
   "keywords": [
     "eslint",
@@ -33,6 +33,7 @@
     "minimatch": "^3.0.4"
   },
   "scripts": {
+    "test": "jest",
     "typecheck": "tsc -p jsconfig.json"
   }
 }

package/src/index.js

@@ -9,14 +9,18 @@
 import noIllegalModulePaths from "./rules/noIllegalModulePaths";
 import noIllegalImports from "./rules/noIllegalImports";
 import exportContentMustBeValid from "./rules/exportContentMustBeValid";
+import noDefineWithVariable from "./rules/noDefineWithVariable";
+import defaultExportValModule from "./rules/defaultExportValModule";
 
 /**
  * @type {Plugin["rules"]}
  */
-export let rules = {
+export const rules = {
   "no-illegal-module-paths": noIllegalModulePaths,
   "no-illegal-imports": noIllegalImports,
   "export-content-must-be-valid": exportContentMustBeValid,
+  "no-define-with-variable": noDefineWithVariable,
+  "default-export-val-module": defaultExportValModule,
 };
 
 /**
@@ -34,6 +38,8 @@ export const configs = {
       "@valbuild/no-illegal-module-paths": "error",
       "@valbuild/no-illegal-imports": "error",
       "@valbuild/export-content-must-be-valid": "error",
+      "@valbuild/no-define-with-variable": "error",
+      "@valbuild/default-export-val-module": "error",
     },
   },
 };

package/src/rules/defaultExportValModule.js

@@ -0,0 +1,85 @@
+// @ts-check
+
+const message = "Val: c.define must be exported as default";
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "c.define must be exported as default",
+      recommended: true,
+    },
+    fixable: "code",
+    schema: [],
+  },
+  create: function (context) {
+    return {
+      CallExpression(node) {
+        if (node.callee.type === "MemberExpression") {
+          const memberExpression = node.callee;
+          if (memberExpression.object.type === "Identifier") {
+            const object = memberExpression.object;
+            if (
+              object.name === "c" &&
+              memberExpression.property.type === "Identifier"
+            ) {
+              const property = memberExpression.property;
+              if (property.name === "define") {
+                const parent = node.parent;
+                if (parent.type === "ExportDefaultDeclaration") {
+                  return;
+                }
+                if (parent.type === "VariableDeclarator") {
+                  const variableInit = parent.init;
+                  if (
+                    variableInit &&
+                    parent.parent.type === "VariableDeclaration"
+                  ) {
+                    context.report({
+                      node: node,
+                      message,
+                      fix: function (fixer) {
+                        return fixer.replaceText(
+                          parent.parent,
+                          `export default ${context.sourceCode.getText(
+                            variableInit,
+                          )}`,
+                        );
+                      },
+                    });
+                  } else {
+                    context.report({
+                      node: node,
+                      message,
+                    });
+                  }
+                } else if (
+                  parent.type === "ExpressionStatement" &&
+                  parent.parent.type === "Program"
+                ) {
+                  context.report({
+                    node: node,
+                    message,
+                    fix: function (fixer) {
+                      return fixer.replaceText(
+                        parent,
+                        `export default ${context.sourceCode.getText(parent)}`,
+                      );
+                    },
+                  });
+                } else {
+                  context.report({
+                    node: node,
+                    message,
+                  });
+                }
+              }
+            }
+          }
+        }
+      },
+    };
+  },
+};

package/src/rules/noDefineWithVariable.js

@@ -0,0 +1,43 @@
+// @ts-check
+
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Cannot c.define with a variable",
+      recommended: true,
+    },
+    fixable: "code",
+    schema: [],
+  },
+  create: function (context) {
+    return {
+      ExportDefaultDeclaration(node) {
+        const decl = node.declaration;
+        if (decl.type === "CallExpression") {
+          const callee = decl.callee;
+          const isDefine =
+            callee.type === "MemberExpression" &&
+            callee.object.type === "Identifier" &&
+            callee.object.name === "c" &&
+            callee.property.type === "Identifier" &&
+            callee.property.name === "define";
+
+          if (isDefine) {
+            const args = decl.arguments;
+            const valueArg = args[2];
+            if (valueArg.type === "Identifier") {
+              context.report({
+                node: valueArg,
+                message: "Val: third argument of c.define cannot be a variable",
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};

package/src/rules/noIllegalImports.js

@@ -35,7 +35,7 @@ export default {
             "importKind" in node &&
             node["importKind"] !== "type" &&
             !node.specifiers.every(
-              (s) => "importKind" in s && s["importKind"] === "type"
+              (s) => "importKind" in s && s["importKind"] === "type",
             )
           ) {
             const message = `Val: can only 'import type' or import from source that is either: a .val.{j,t}s file, a @valbuild package, or val.config.{j,t}s.`;

package/src/rules/noIllegalModulePaths.js

@@ -35,7 +35,7 @@ export default {
               n.source.value.endsWith("val.config.ts") ||
               n.source.value.endsWith("val.config.js"))
               ? n.source.value
-              : false
+              : false,
           );
           if (
             maybeValConfigImportDeclaration?.type === "ImportDeclaration" &&
@@ -99,7 +99,7 @@ export default {
                   fix: (fixer) =>
                     fixer.replaceText(
                       firstArg,
-                      `${rawArg}${expectedValue}${rawArg}`
+                      `${rawArg}${expectedValue}${rawArg}`,
                     ),
                 });
               }

package/test/plugin.test.js

@@ -13,7 +13,7 @@ function initESLint(fixtureConfigName) {
     overrideConfigFile: path.resolve(
       __dirname,
       "../fixtures/",
-      fixtureConfigName
+      fixtureConfigName,
     ),
   });
 }
@@ -64,7 +64,7 @@ export default c.define(
     expect(results).toHaveLength(1);
     expect(results[0].messages).toHaveLength(1);
     expect(results[0].messages[0].fix?.text).toEqual(
-      '"/content/stuff/with/all/test.val.ts"'
+      '"/content/stuff/with/all/test.val.ts"',
     );
   });
   // TODO: we can't test this anymore because we do not know the root dir - perhaps the

package/test/rules/defaultExportValModule.test.js

@@ -0,0 +1,76 @@
+import { RuleTester } from "eslint";
+import { rules as valRules } from "@valbuild/eslint-plugin";
+import path from "path";
+
+const rule = valRules["default-export-val-module"];
+
+RuleTester.setDefaultConfig({
+  parserOptions: {
+    ecmaVersion: 2018,
+    sourceType: "module",
+    ecmaFeatures: {
+      jsx: true,
+    },
+  },
+});
+
+const ruleTester = new RuleTester();
+
+ruleTester.run("default-export-val-module", rule, {
+  valid: [
+    {
+      filename: path.join(process.cwd(), "./foo/test.val.ts"),
+      code: `import { c, s } from '../val.config.ts';
+      export const schema = s.string();
+      export default c.define('/foo/test.val.ts', schema, 'String')`,
+    },
+  ],
+  invalid: [
+    {
+      filename: path.join(process.cwd(), "./foo/test.val.ts"),
+      code: `import { c, s } from '../val.config.ts';
+      export const schema = s.string();
+      const a = c.define('/foo/test.val.ts', schema, 'String')`,
+      errors: [
+        {
+          message: "Val: c.define must be exported as default",
+        },
+      ],
+      output: `import { c, s } from '../val.config.ts';
+      export const schema = s.string();
+      export default c.define('/foo/test.val.ts', schema, 'String')`,
+    },
+    {
+      filename: path.join(process.cwd(), "./foo/test.val.ts"),
+      code: `import { c, s } from '../val.config.ts';
+      export const schema = s.string();
+      {
+        c.define('/foo/test.val.ts', schema, 'String')
+      }`,
+      errors: [
+        {
+          message: "Val: c.define must be exported as default",
+        },
+      ],
+      output: `import { c, s } from '../val.config.ts';
+      export const schema = s.string();
+      {
+        c.define('/foo/test.val.ts', schema, 'String')
+      }`,
+    },
+    {
+      filename: path.join(process.cwd(), "./foo/test.val.ts"),
+      code: `import { c, s } from '../val.config.ts';
+      export const schema = s.string();
+      c.define('/foo/test.val.ts', schema, 'String')`,
+      errors: [
+        {
+          message: "Val: c.define must be exported as default",
+        },
+      ],
+      output: `import { c, s } from '../val.config.ts';
+      export const schema = s.string();
+      export default c.define('/foo/test.val.ts', schema, 'String')`,
+    },
+  ],
+});

package/test/rules/noDefineWithVariable.test.js

@@ -0,0 +1,42 @@
+import { RuleTester } from "eslint";
+import { rules as valRules } from "@valbuild/eslint-plugin";
+import path from "path";
+
+const rule = valRules["no-define-with-variable"];
+
+RuleTester.setDefaultConfig({
+  parserOptions: {
+    ecmaVersion: 2018,
+    sourceType: "module",
+    ecmaFeatures: {
+      jsx: true,
+    },
+  },
+});
+
+const ruleTester = new RuleTester();
+
+ruleTester.run("no-define-with-variable", rule, {
+  valid: [
+    {
+      filename: path.join(process.cwd(), "./foo/test.val.ts"),
+      code: `import { c, s } from '../val.config.ts';
+      export const schema = s.string();
+      export default c.define('/foo/test.val.ts', schema, 'String')`,
+    },
+  ],
+  invalid: [
+    {
+      filename: path.join(process.cwd(), "./foo/test.val.ts"),
+      code: `import { c, s } from '../val.config.ts';
+      export const schema = s.string();
+      const str = 'String'
+      export default c.define('/foo/test.val.ts', schema, str)`,
+      errors: [
+        {
+          message: "Val: third argument of c.define cannot be a variable",
+        },
+      ],
+    },
+  ],
+});