eslint-plugin-svg 0.0.0 → 0.0.2

package/README.md

@@ -8,8 +8,8 @@
 
 > Rules for consistent, readable and valid SVG files.
 
-> [!WARNING]
-> This plugin is Work In Progress. API may change at every release. Please use with caution.
+> [!CAUTION]
+> Status: Work In Progress. Not ready for use.
 
 ## Install
 
@@ -36,8 +36,8 @@ import pluginSvg from 'eslint-plugin-svg'
  * @type {import('eslint').Linter.Config[]}
  */
 export default [
-  ...pluginSvg.configs.recommended,
   // Other configs...
+  ...pluginSvg.configs.recommended,
 ]
 ```
 
@@ -50,8 +50,15 @@ export default [
 🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).\
 💡 Manually fixable by [editor suggestions](https://eslint.org/docs/developer-guide/working-with-rules#providing-suggestions).
 
-| Name | Description | 💼  | 🔧  | 💡  |
-| :--- | :---------- | :-: | :-: | :-: |
+| Name                                                                               | Description                      | 💼  | 🔧  | 💡  |
+| :--------------------------------------------------------------------------------- | :------------------------------- | :-: | :-: | :-: |
+| [no-empty-title](https://eslint-plugin-svg.ntnyq.com/rules/no-empty-title)         | Disallow empty title element     | ✅  |     |     |
+| [no-empty-desc](https://eslint-plugin-svg.ntnyq.com/rules/no-empty-desc)           | Disallow empty desc element      | ✅  |     |     |
+| [no-empty-text](https://eslint-plugin-svg.ntnyq.com/rules/no-empty-text)           | Disallow empty text element      | ✅  |     |     |
+| [no-empty-container](https://eslint-plugin-svg.ntnyq.com/rules/no-empty-container) | Disallow empty container element | ✅  |     |     |
+| [no-deprecated](https://eslint-plugin-svg.ntnyq.com/rules/no-deprecated)           | Disallow deprecated elements     | ✅  |     |     |
+| [no-elements](https://eslint-plugin-svg.ntnyq.com/rules/no-elements)               | Disallow elements by name        |     |     |     |
+| [no-doctype](https://eslint-plugin-svg.ntnyq.com/rules/no-doctype)                 | Disallow doctype                 | ✅  | 🔧  |     |
 
 ## License
 

package/dist/index.cjs

@@ -1,11 +1,13 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -15,30 +17,35 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   configs: () => configs,
-  createRecommendedConfig: () => createRecommendedConfig,
-  default: () => src_default,
+  createConfig: () => createConfig,
+  default: () => index_default,
   meta: () => meta,
   plugin: () => plugin,
   recommended: () => recommended,
   rules: () => rules
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
 // src/configs/index.ts
-function createRecommendedConfig(options = {}) {
+var parserSVG = __toESM(require("svg-eslint-parser"), 1);
+function createConfig(options = {}) {
   const config = {
     ...options,
-    // Overrides
-    name: options.name || "svg/recommended",
     files: options.files || ["**/*.svg"],
-    ignores: options.ignores || [],
-    languageOptions: options.languageOptions,
     plugins: {
       ...options.plugins || {},
       /* v8 ignore start */
@@ -47,28 +54,507 @@ function createRecommendedConfig(options = {}) {
       }
       /* v8 ignore stop */
     },
+    languageOptions: {
+      ...options.languageOptions || {},
+      parser: parserSVG
+    },
     rules: {
-      ...options.overridesRules || {}
+      ...options.rules
     }
   };
   return config;
 }
 var recommended = [
-  // flat recommended config
-  createRecommendedConfig()
+  createConfig({
+    name: "svg/recommended",
+    // @keep-sorted
+    rules: {
+      "svg/no-deprecated": "error",
+      "svg/no-doctype": "error",
+      "svg/no-empty-container": "error",
+      "svg/no-empty-desc": "error",
+      "svg/no-empty-text": "error",
+      "svg/no-empty-title": "error"
+    }
+  })
 ];
 var configs = {
   recommended
 };
 
+// package.json
+var name = "eslint-plugin-svg";
+var version = "0.0.2";
+
 // src/meta.ts
 var meta = {
-  name: "eslint-plugin-svg",
-  version: "0.0.0"
+  name,
+  version
 };
 
+// src/constants/index.ts
+var CONTAINER_ELEMENTS = [
+  "a",
+  "defs",
+  "g",
+  "marker",
+  "mask",
+  "missing-glyph",
+  "pattern",
+  "svg",
+  "switch",
+  "symbol"
+];
+var DEPRECATED_ELEMENTS = [
+  "altGlyph",
+  "altGlyphDef",
+  "altGlyphItem",
+  "animateColor",
+  "cursor",
+  "font",
+  "font-face",
+  "font-face-format",
+  "font-face-name",
+  "font-face-src",
+  "font-face-uri",
+  "glyph",
+  "glyphRef",
+  "hkern",
+  "missing-glyph",
+  "tref",
+  "vkern"
+];
+
+// src/utils/merge.ts
+function isObjectNotArray(obj) {
+  return typeof obj === "object" && obj != null && !Array.isArray(obj);
+}
+function deepMerge(first = {}, second = {}) {
+  const keys = new Set(Object.keys(first).concat(Object.keys(second)));
+  return Array.from(keys).reduce((acc, key) => {
+    const firstHasKey = key in first;
+    const secondHasKey = key in second;
+    const firstValue = first[key];
+    const secondValue = second[key];
+    if (firstHasKey && secondHasKey) {
+      if (isObjectNotArray(firstValue) && isObjectNotArray(secondValue)) {
+        acc[key] = deepMerge(firstValue, secondValue);
+      } else {
+        acc[key] = secondValue;
+      }
+    } else if (firstHasKey) {
+      acc[key] = firstValue;
+    } else {
+      acc[key] = secondValue;
+    }
+    return acc;
+  }, {});
+}
+
+// src/utils/casing.ts
+var import_utils = require("@ntnyq/utils");
+
+// src/utils/createRule.ts
+var docsUrl = "https://eslint-plugin-svg.ntnyq.com/rules/";
+function createRule({
+  create,
+  defaultOptions: defaultOptions4,
+  meta: meta2
+}) {
+  return {
+    create: (context) => {
+      const optionsCount = Math.max(context.options.length, defaultOptions4.length);
+      const optionsWithDefault = Array.from({ length: optionsCount }, (_, i) => {
+        if (isObjectNotArray(context.options[i]) && isObjectNotArray(defaultOptions4[i])) {
+          return deepMerge(defaultOptions4[i], context.options[i]);
+        }
+        return context.options[i] ?? defaultOptions4[i];
+      });
+      return create(context, optionsWithDefault);
+    },
+    defaultOptions: defaultOptions4,
+    meta: {
+      ...meta2,
+      defaultOptions: defaultOptions4
+    }
+  };
+}
+function RuleCreator(urlCreator) {
+  return function createNamedRule({
+    name: name2,
+    meta: meta2,
+    ...rule
+  }) {
+    return createRule({
+      meta: {
+        ...meta2,
+        docs: {
+          ...meta2.docs,
+          url: urlCreator(name2)
+        }
+      },
+      ...rule
+    });
+  };
+}
+var createESLintRule = RuleCreator((ruleName) => `${docsUrl}${ruleName}.html`);
+
+// src/utils/resolveOptions.ts
+function resolveOptions(options) {
+  return options?.[0] || {};
+}
+
+// src/rules/no-deprecated.ts
+var RULE_NAME = "no-deprecated";
+var defaultOptions = {};
+var no_deprecated_default = createESLintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "disallow deprecated elements",
+      recommended: true
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowElements: {
+            type: "array",
+            description: "Allowed deprecated elements",
+            items: {
+              type: "string"
+            }
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      deprecatedElement: `Element '{{name}}' is deprecated`
+    }
+  },
+  defaultOptions: [defaultOptions],
+  create(context) {
+    const { allowElements = [] } = resolveOptions(context.options);
+    const deprecatedElements = new Set(
+      DEPRECATED_ELEMENTS.filter((element) => !allowElements.includes(element))
+    );
+    return {
+      Tag(node) {
+        if (deprecatedElements.has(node.name)) {
+          context.report({
+            node,
+            messageId: "deprecatedElement",
+            data: {
+              name: node.name
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-doctype.ts
+var RULE_NAME2 = "no-doctype";
+var no_doctype_default = createESLintRule({
+  name: RULE_NAME2,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "disallow doctype",
+      recommended: true
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      invalid: "Doctype is not allowed"
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      Doctype(node) {
+        context.report({
+          node,
+          messageId: "invalid",
+          fix: (fixer) => fixer.remove(node)
+        });
+      }
+    };
+  }
+});
+
+// src/rules/no-elements.ts
+var RULE_NAME3 = "no-elements";
+var defaultOptions2 = {};
+var no_elements_default = createESLintRule({
+  name: RULE_NAME3,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "disallow elements by name",
+      recommended: true
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          elements: {
+            type: "array",
+            description: "elements to be disallowed",
+            items: {
+              type: "string"
+            }
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      invalid: `Element '{{name}}' is not allowed`
+    }
+  },
+  defaultOptions: [defaultOptions2],
+  create(context) {
+    const { elements = [] } = resolveOptions(context.options);
+    if (!elements.length) {
+      return {};
+    }
+    return {
+      Tag(node) {
+        if (elements.includes(node.name)) {
+          context.report({
+            node,
+            messageId: "invalid",
+            data: {
+              name: node.name
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-empty-container.ts
+var import_utils5 = require("@ntnyq/utils");
+var RULE_NAME4 = "no-empty-container";
+var defaultOptions3 = {};
+var no_empty_container_default = createESLintRule({
+  name: RULE_NAME4,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "disallow empty container element",
+      recommended: true
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          elements: {
+            type: "array",
+            description: "container elements to be checked",
+            items: {
+              type: "string"
+            },
+            uniqueItems: true
+          },
+          ignores: {
+            type: "array",
+            description: "container elements to be ignored",
+            items: {
+              type: "string"
+            },
+            uniqueItems: true
+          },
+          ignoreComments: {
+            type: "boolean",
+            description: "whether ignore comments nodes"
+          },
+          ignoreWhitespace: {
+            type: "boolean",
+            description: "whether ignore whitespace nodes"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      invalid: `Container element '{{name}}' must not be empty`
+    }
+  },
+  defaultOptions: [defaultOptions3],
+  create(context) {
+    const {
+      elements = [],
+      ignores = [],
+      ignoreComments = true,
+      ignoreWhitespace = true
+    } = resolveOptions(context.options);
+    const containerElements = new Set(
+      [
+        // built-in container elements
+        ...CONTAINER_ELEMENTS,
+        // user defined container elements
+        ...elements
+      ].filter((v) => !ignores.includes(v))
+    );
+    return {
+      Tag(node) {
+        if (!containerElements.has(node.name)) {
+          return;
+        }
+        const children = node.children.filter((n) => !ignoreComments || n.type !== "Comment").filter((n) => !ignoreWhitespace || n.type !== "Text" || (0, import_utils5.isNonEmptyString)(n.value.trim()));
+        if (children.length === 0) {
+          context.report({
+            node,
+            messageId: "invalid",
+            data: {
+              name: node.name
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-empty-desc.ts
+var RULE_NAME5 = "no-empty-desc";
+var no_empty_desc_default = createESLintRule({
+  name: RULE_NAME5,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "disallow empty desc element",
+      recommended: true
+    },
+    schema: [],
+    messages: {
+      invalid: "Element desc must not be empty"
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      Tag(node) {
+        if (node.name !== "desc") {
+          return;
+        }
+        const textNode = node.children.find((n) => n.type === "Text");
+        if (textNode) {
+          if (!textNode.value.trim()) {
+            return context.report({
+              node,
+              messageId: "invalid"
+            });
+          }
+        } else {
+          return context.report({
+            node,
+            messageId: "invalid"
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-empty-text.ts
+var RULE_NAME6 = "no-empty-text";
+var no_empty_text_default = createESLintRule({
+  name: RULE_NAME6,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "disallow empty text element",
+      recommended: true
+    },
+    schema: [],
+    messages: {
+      invalid: "Element text must not be empty"
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      Tag(node) {
+        if (node.name !== "text") {
+          return;
+        }
+        const textNode = node.children.find((n) => n.type === "Text");
+        if (textNode) {
+          if (!textNode.value.trim()) {
+            return context.report({
+              node,
+              messageId: "invalid"
+            });
+          }
+        } else {
+          return context.report({
+            node,
+            messageId: "invalid"
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-empty-title.ts
+var RULE_NAME7 = "no-empty-title";
+var no_empty_title_default = createESLintRule({
+  name: RULE_NAME7,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "disallow empty title element",
+      recommended: true
+    },
+    schema: [],
+    messages: {
+      invalid: "Element title must not be empty"
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      Tag(node) {
+        if (node.name !== "title") {
+          return;
+        }
+        const textNode = node.children.find((n) => n.type === "Text");
+        if (textNode) {
+          if (!textNode.value.trim()) {
+            return context.report({
+              node,
+              messageId: "invalid"
+            });
+          }
+        } else {
+          return context.report({
+            node,
+            messageId: "invalid"
+          });
+        }
+      }
+    };
+  }
+});
+
 // src/rules/index.ts
-var rules = {};
+var rules = {
+  "no-deprecated": no_deprecated_default,
+  "no-doctype": no_doctype_default,
+  "no-elements": no_elements_default,
+  "no-empty-container": no_empty_container_default,
+  "no-empty-desc": no_empty_desc_default,
+  "no-empty-text": no_empty_text_default,
+  "no-empty-title": no_empty_title_default
+};
 
 // src/index.ts
 var plugin = {
@@ -77,11 +563,11 @@ var plugin = {
   rules,
   configs
 };
-var src_default = plugin;
+var index_default = plugin;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   configs,
-  createRecommendedConfig,
+  createConfig,
   meta,
   plugin,
   recommended,