@lvce-editor/eslint-plugin-virtual-dom 18.10.0 → 18.12.0

package/dist/index.js

@@ -1,3 +1,6 @@
+import json from '@eslint/json';
+import { validRange, subset } from 'semver';
+
 const isPropertyNode = node => {
   return typeof node === 'object' && node !== null && 'type' in node && node.type === 'Property' && 'key' in node && 'value' in node && 'computed' in node;
 };
@@ -93,7 +96,7 @@ const controlsAllowingChildren = new Set(['A', 'Button']);
 const hasDirectName = node => {
   return Boolean(getProperty(node, 'ariaLabel') || getProperty(node, 'ariaLabelledBy') || getProperty(node, 'title'));
 };
-const meta$u = {
+const meta$w = {
   docs: {
     description: 'Require a statically determinable accessible name for virtual-dom controls'
   },
@@ -102,7 +105,7 @@ const meta$u = {
   },
   type: 'problem'
 };
-const create$u = context => {
+const create$w = context => {
   return {
     ObjectExpression(node) {
       if (!isVirtualDomNode(node) || hasDirectName(node)) {
@@ -144,11 +147,11 @@ const create$u = context => {
 
 const accessibleControlName = {
   __proto__: null,
-  create: create$u,
-  meta: meta$u
+  create: create$w,
+  meta: meta$w
 };
 
-const meta$t = {
+const meta$v = {
   docs: {
     description: 'Require an explicit role on clickable virtual-dom div nodes'
   },
@@ -157,7 +160,7 @@ const meta$t = {
   },
   type: 'problem'
 };
-const create$t = context => {
+const create$v = context => {
   return {
     ObjectExpression(node) {
       if (!isVirtualDomNode(node)) {
@@ -179,11 +182,113 @@ const create$t = context => {
 
 const clickableDivNeedsRole = {
   __proto__: null,
-  create: create$t,
-  meta: meta$t
+  create: create$v,
+  meta: meta$v
 };
 
-const meta$s = {
+const meta$u = {
+  docs: {
+    description: 'Require static mergeClassNames calls inside functions to be hoisted to module scope'
+  },
+  messages: {
+    hoistClassNames: 'Hoist this static mergeClassNames call to module scope.'
+  },
+  type: 'suggestion'
+};
+const findVariable$1 = (sourceCode, node) => {
+  let scope = sourceCode.getScope(node);
+  while (scope) {
+    const variable = scope.set.get(node.name);
+    if (variable) {
+      return variable;
+    }
+    scope = scope.upper;
+  }
+  return undefined;
+};
+const isMergeClassNames = (sourceCode, node) => {
+  if (node.type === 'Identifier') {
+    return Boolean(findVariable$1(sourceCode, node)?.defs.some(definition => {
+      return definition.type === 'ImportBinding' && definition.node.type === 'ImportSpecifier' && (definition.node.imported.type === 'Identifier' ? definition.node.imported.name : definition.node.imported.value) === 'mergeClassNames';
+    }));
+  }
+  if (node.type !== 'MemberExpression' || node.computed || node.optional || node.object.type !== 'Identifier' || node.property.type !== 'Identifier' || node.property.name !== 'mergeClassNames') {
+    return false;
+  }
+  return Boolean(findVariable$1(sourceCode, node.object)?.defs.some(definition => {
+    return definition.type === 'ImportBinding' && definition.node.type === 'ImportNamespaceSpecifier';
+  }));
+};
+const isStatic = (sourceCode, node, seen = new Set()) => {
+  switch (node.type) {
+    case 'BinaryExpression':
+      return node.operator === '+' && isStatic(sourceCode, node.left, seen) && isStatic(sourceCode, node.right, seen);
+    case 'Identifier':
+      {
+        const variable = findVariable$1(sourceCode, node);
+        if (!variable || variable.scope.type !== 'module' || seen.has(variable)) {
+          return false;
+        }
+        const definition = variable.defs[0];
+        if (definition?.type !== 'Variable' || definition.parent.kind !== 'const' || !definition.node.init) {
+          return false;
+        }
+        return isStatic(sourceCode, definition.node.init, new Set([...seen, variable]));
+      }
+    case 'Literal':
+      return typeof node.value === 'string';
+    case 'MemberExpression':
+      {
+        // Class-name modules export constants. Do not assume arbitrary object properties are immutable.
+        if (node.computed || node.optional || node.object.type !== 'Identifier') {
+          return false;
+        }
+        const variable = findVariable$1(sourceCode, node.object);
+        return Boolean(variable?.defs.some(definition => {
+          if (definition.type !== 'ImportBinding') {
+            return false;
+          }
+          if (definition.node.type === 'ImportNamespaceSpecifier') {
+            return /(?:^|\/)ClassNames\.(?:js|ts)$/.test(String(definition.parent.source.value));
+          }
+          return definition.node.type === 'ImportSpecifier' && definition.node.imported.type === 'Identifier' && definition.node.imported.name === 'ClassNames' && definition.parent.source.value === '@lvce-editor/virtual-dom-worker';
+        }));
+      }
+    case 'TemplateLiteral':
+      return node.expressions.every(expression => isStatic(sourceCode, expression, seen));
+    default:
+      return false;
+  }
+};
+const create$u = context => {
+  return {
+    CallExpression(node) {
+      if (node.type !== 'CallExpression' || node.optional || !isMergeClassNames(context.sourceCode, node.callee)) {
+        return;
+      }
+      if (context.sourceCode.getAncestors(node).every(ancestor => {
+        return !['ArrowFunctionExpression', 'FunctionDeclaration', 'FunctionExpression'].includes(ancestor.type);
+      })) {
+        return;
+      }
+      if (node.arguments.some(argument => !isStatic(context.sourceCode, argument))) {
+        return;
+      }
+      context.report({
+        messageId: 'hoistClassNames',
+        node
+      });
+    }
+  };
+};
+
+const hoistClassNames = {
+  __proto__: null,
+  create: create$u,
+  meta: meta$u
+};
+
+const meta$t = {
   docs: {
     description: 'Require static virtual-dom nodes created inside functions to be hoisted to module scope'
   },
@@ -318,7 +423,7 @@ const isStaticExpression = (sourceCode, node) => {
       return false;
   }
 };
-const create$s = context => {
+const create$t = context => {
   return {
     ObjectExpression(node) {
       if (!isVirtualDomElement(node)) {
@@ -343,11 +448,11 @@ const create$s = context => {
 
 const hoistStaticNodes = {
   __proto__: null,
-  create: create$s,
-  meta: meta$s
+  create: create$t,
+  meta: meta$t
 };
 
-const meta$r = {
+const meta$s = {
   docs: {
     description: 'Disallow conditional spreads in virtual-dom arrays'
   },
@@ -365,7 +470,7 @@ const isVirtualDomArray$1 = node => {
 const addsVirtualDomChildren = spread => {
   return isVirtualDomArray$1(spread.argument.consequent) || isVirtualDomArray$1(spread.argument.alternate);
 };
-const create$r = context => {
+const create$s = context => {
   return {
     ArrayExpression(node) {
       const conditionalSpreads = node.elements.filter(isConditionalSpread);
@@ -384,11 +489,11 @@ const create$r = context => {
 
 const noConditionalSpread = {
   __proto__: null,
-  create: create$r,
-  meta: meta$r
+  create: create$s,
+  meta: meta$s
 };
 
-const meta$q = {
+const meta$r = {
   docs: {
     description: 'Disallow element helpers for creating virtual DOM nodes'
   },
@@ -397,7 +502,7 @@ const meta$q = {
   },
   type: 'problem'
 };
-const create$q = context => {
+const create$r = context => {
   return {
     CallExpression(node) {
       if (!isIdentifierNode(node.callee) || node.callee.name !== 'element' || !getVirtualDomElementName(node.arguments[0])) {
@@ -413,11 +518,11 @@ const create$q = context => {
 
 const noElementHelper = {
   __proto__: null,
-  create: create$q,
-  meta: meta$q
+  create: create$r,
+  meta: meta$r
 };
 
-const meta$p = {
+const meta$q = {
   docs: {
     description: 'Disallow empty ARIA values in virtual-dom nodes'
   },
@@ -429,7 +534,7 @@ const meta$p = {
 const isAriaProperty = name => {
   return /^aria[A-Z]/.test(name);
 };
-const create$p = context => {
+const create$q = context => {
   return {
     ObjectExpression(node) {
       if (!isVirtualDomNode(node)) {
@@ -454,11 +559,11 @@ const create$p = context => {
 
 const noEmptyAria = {
   __proto__: null,
-  create: create$p,
-  meta: meta$p
+  create: create$q,
+  meta: meta$q
 };
 
-const meta$o = {
+const meta$p = {
   docs: {
     description: 'Disallow empty className values in virtual-dom nodes'
   },
@@ -467,7 +572,7 @@ const meta$o = {
   },
   type: 'problem'
 };
-const create$o = context => {
+const create$p = context => {
   return {
     ObjectExpression(node) {
       if (!isVirtualDomNode(node)) {
@@ -487,11 +592,11 @@ const create$o = context => {
 
 const noEmptyClassName = {
   __proto__: null,
-  create: create$o,
-  meta: meta$o
+  create: create$p,
+  meta: meta$p
 };
 
-const meta$n = {
+const meta$o = {
   docs: {
     description: 'Disallow inline event handlers in virtual-dom nodes'
   },
@@ -506,7 +611,7 @@ const isEventPropertyName = name => {
 const isInlineEventHandler = node => {
   return isStringLiteral(node) || isTemplateLiteralNode(node) || isArrowFunctionExpressionNode(node) || isFunctionExpressionNode(node);
 };
-const create$n = context => {
+const create$o = context => {
   return {
     ObjectExpression(node) {
       if (!isVirtualDomNode(node)) {
@@ -531,11 +636,11 @@ const create$n = context => {
 
 const noInlineEventHandlers = {
   __proto__: null,
-  create: create$n,
-  meta: meta$n
+  create: create$o,
+  meta: meta$o
 };
 
-const meta$m = {
+const meta$n = {
   docs: {
     description: 'Disallow inline style attributes in virtual-dom nodes'
   },
@@ -544,7 +649,7 @@ const meta$m = {
   },
   type: 'problem'
 };
-const create$m = context => {
+const create$n = context => {
   return {
     ObjectExpression(node) {
       if (!isVirtualDomNode(node)) {
@@ -564,8 +669,8 @@ const create$m = context => {
 
 const noInlineStyle = {
   __proto__: null,
-  create: create$m,
-  meta: meta$m
+  create: create$n,
+  meta: meta$n
 };
 
 const ignoredProperties$1 = new Set(['childCount', 'type']);
@@ -575,7 +680,7 @@ const isOptionalExpression = node => {
 const isNullish = node => {
   return isLiteralNode(node) && node.value === null || isIdentifierNode(node) && node.name === 'undefined' || isOptionalExpression(node);
 };
-const meta$l = {
+const meta$m = {
   docs: {
     description: 'Disallow nullish virtual-dom attribute values'
   },
@@ -584,7 +689,7 @@ const meta$l = {
   },
   type: 'problem'
 };
-const create$l = context => {
+const create$m = context => {
   return {
     ObjectExpression(node) {
       if (!isVirtualDomNode(node)) {
@@ -612,11 +717,11 @@ const create$l = context => {
 
 const noNullishAttributeValues = {
   __proto__: null,
-  create: create$l,
-  meta: meta$l
+  create: create$m,
+  meta: meta$m
 };
 
-const meta$k = {
+const meta$l = {
   docs: {
     description: 'Disallow object-like attribute values in virtual-dom nodes'
   },
@@ -629,7 +734,7 @@ const ignoredProperties = new Set(['childCount', 'type']);
 const isObjectLikeAttributeValue = node => {
   return isObjectExpressionNode(node) || isArrayExpressionNode(node) || isArrowFunctionExpressionNode(node) || isFunctionExpressionNode(node);
 };
-const create$k = context => {
+const create$l = context => {
   return {
     ObjectExpression(node) {
       if (!isVirtualDomNode(node)) {
@@ -654,11 +759,11 @@ const create$k = context => {
 
 const noObjectAttributeValues = {
   __proto__: null,
-  create: create$k,
-  meta: meta$k
+  create: create$l,
+  meta: meta$l
 };
 
-const meta$j = {
+const meta$k = {
   docs: {
     description: 'Disallow positive virtual-dom tabIndex values'
   },
@@ -667,7 +772,7 @@ const meta$j = {
   },
   type: 'problem'
 };
-const create$j = context => {
+const create$k = context => {
   return {
     ObjectExpression(node) {
       if (!isVirtualDomNode(node)) {
@@ -688,11 +793,11 @@ const create$j = context => {
 
 const noPositiveTabIndex = {
   __proto__: null,
-  create: create$j,
-  meta: meta$j
+  create: create$k,
+  meta: meta$k
 };
 
-const meta$i = {
+const meta$j = {
   docs: {
     description: 'Disallow raw string children in virtual-dom arrays'
   },
@@ -704,7 +809,7 @@ const meta$i = {
 const isVirtualDomArray = node => {
   return isArrayExpressionNode(node) && node.elements.some(element => isVirtualDomNode(element) || isTextCall(element));
 };
-const create$i = context => {
+const create$j = context => {
   return {
     ArrayExpression(node) {
       if (!isVirtualDomArray(node)) {
@@ -724,6 +829,98 @@ const create$i = context => {
 };
 
 const noRawTextChildren = {
+  __proto__: null,
+  create: create$j,
+  meta: meta$j
+};
+
+const defaultRestrictions = {
+  eslint: '<10.10.0-0',
+  typescript: '>=6.0.0-0 <7.0.0-0'
+};
+const dependencySections = new Set(['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies']);
+const meta$i = {
+  docs: {
+    description: 'Disallow dependencies and version ranges outside the supported versions'
+  },
+  messages: {
+    forbidden: 'Dependency "{{name}}" is not allowed.',
+    unsupported: 'Dependency "{{name}}" must use a version range within "{{allowed}}"; received "{{version}}".'
+  },
+  schema: [{
+    additionalProperties: false,
+    properties: {
+      restrictions: {
+        additionalProperties: {
+          anyOf: [{
+            minLength: 1,
+            type: 'string'
+          }, {
+            enum: [false]
+          }]
+        },
+        type: 'object'
+      }
+    },
+    type: 'object'
+  }],
+  type: 'problem'
+};
+const create$i = context => {
+  const restrictions = {
+    ...defaultRestrictions,
+    ...context.options[0]?.restrictions
+  };
+  for (const [name, allowed] of Object.entries(restrictions)) {
+    if (allowed !== false && !validRange(allowed)) {
+      throw new Error(`Invalid allowed version range for dependency "${name}": ${allowed}`);
+    }
+  }
+  return {
+    Document(node) {
+      if (node.body?.type !== 'Object') {
+        return;
+      }
+      for (const section of node.body.members) {
+        if (!dependencySections.has(section.name.value) || section.value.type !== 'Object') {
+          continue;
+        }
+        for (const dependency of section.value.members) {
+          const name = dependency.name.value;
+          if (Object.hasOwn(restrictions, name)) {
+            const allowed = restrictions[name];
+            if (allowed === false) {
+              context.report({
+                data: {
+                  name
+                },
+                loc: dependency.name.loc,
+                messageId: 'forbidden'
+              });
+            } else {
+              const version = dependency.value.value;
+              if (typeof version !== 'string' || !validRange(version) || !subset(version, allowed, {
+                includePrerelease: true
+              })) {
+                context.report({
+                  data: {
+                    allowed,
+                    name,
+                    version: String(version)
+                  },
+                  loc: dependency.value.loc,
+                  messageId: 'unsupported'
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+};
+
+const noRestrictedDependencies = {
   __proto__: null,
   create: create$i,
   meta: meta$i
@@ -1664,6 +1861,7 @@ const plugin = {
   rules: {
     'accessible-control-name': accessibleControlName,
     'clickable-div-needs-role': clickableDivNeedsRole,
+    'hoist-class-names': hoistClassNames,
     'hoist-static-nodes': hoistStaticNodes,
     'no-conditional-spread': noConditionalSpread,
     'no-element-helper': noElementHelper,
@@ -1675,6 +1873,7 @@ const plugin = {
     'no-object-attribute-values': noObjectAttributeValues,
     'no-positive-tab-index': noPositiveTabIndex,
     'no-raw-text-children': noRawTextChildren,
+    'no-restricted-dependencies': noRestrictedDependencies,
     'no-shared-event-listener-handlers': noSharedEventListenerHandlers,
     'no-text-helper': noTextHelper,
     'no-tree-helper': noTreeHelper,
@@ -1695,13 +1894,26 @@ const plugin = {
     'valid-node-shape': validNodeShape
   }
 };
-const recommended = [{
+const recommendedDependencies = [{
+  files: ['**/package.json'],
+  language: 'json/json',
+  plugins: {
+    // @ts-ignore
+    json,
+    'virtual-dom': plugin
+  },
+  rules: {
+    'virtual-dom/no-restricted-dependencies': 'error'
+  }
+}];
+const recommended = [...recommendedDependencies, {
   files: ['**/*.{js,mjs,cjs,ts,mts,cts}'],
   plugins: {
     'virtual-dom': plugin
   },
   rules: {
     'virtual-dom/clickable-div-needs-role': 'error',
+    'virtual-dom/hoist-class-names': 'error',
     'virtual-dom/hoist-static-nodes': 'error',
     'virtual-dom/no-conditional-spread': 'error',
     'virtual-dom/no-element-helper': 'error',
@@ -1727,6 +1939,7 @@ const recommended = [{
 }, {
   files: ['**/test/**/*.{js,mjs,cjs,ts,mts,cts}', '**/tests/**/*.{js,mjs,cjs,ts,mts,cts}', '**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts}'],
   rules: {
+    'virtual-dom/hoist-class-names': 'off',
     'virtual-dom/hoist-static-nodes': 'off',
     'virtual-dom/prefer-merge-class-names': 'off'
   }
@@ -1751,4 +1964,4 @@ const strict = [...recommended, {
   }
 }];
 
-export { recommended as default, strict };
+export { recommended as default, recommendedDependencies, strict };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/eslint-plugin-virtual-dom",
-  "version": "18.10.0",
+  "version": "18.12.0",
   "main": "dist/index.js",
   "repository": {
     "type": "git",
@@ -8,5 +8,8 @@
   },
   "type": "module",
   "license": "MIT",
-  "description": "ESLint rules for @lvce-editor/virtual-dom usage."
+  "description": "ESLint rules for @lvce-editor/virtual-dom usage.",
+  "dependencies": {
+    "semver": "^7.7.2"
+  }
 }