nuxt-skill-hub 0.0.6 → 0.0.8

package/dist/runtime/eslint/no-redundant-import.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from 'eslint';
+export declare const noRedundantImport: Rule.RuleModule;

package/dist/runtime/eslint/no-redundant-import.js

@@ -0,0 +1,114 @@
+const SETTINGS_KEY = "skill-hub/autoImports";
+export const noRedundantImport = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow explicit imports of auto-imported identifiers in Nuxt"
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      redundant: "'{{ name }}' is auto-imported by Nuxt. Remove this explicit import."
+    }
+  },
+  create(context) {
+    const entries = context.settings[SETTINGS_KEY];
+    if (!entries?.length)
+      return {};
+    const lookup = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const localName = entry.as || entry.name;
+      const existing = lookup.get(entry.from) || { type: /* @__PURE__ */ new Map(), value: /* @__PURE__ */ new Map() };
+      addAutoImportName(existing[entry.type ? "type" : "value"], localName, entry.name);
+      lookup.set(entry.from, existing);
+    }
+    return {
+      ImportDeclaration(node) {
+        const importNode = node;
+        if (!importNode.specifiers.length) return;
+        const source = typeof importNode.source.value === "string" ? importNode.source.value : void 0;
+        if (!source) return;
+        const autoImported = lookup.get(source);
+        if (!autoImported) return;
+        if (isDeclarationFile(context.filename)) return;
+        const specInfos = [];
+        for (const spec of importNode.specifiers) {
+          if (spec.type !== "ImportSpecifier") {
+            specInfos.push({ spec, localName: "", isRedundant: false });
+            continue;
+          }
+          const localName = spec.local.name;
+          const names = isTypeOnlyImport(importNode, spec) ? autoImported.type : autoImported.value;
+          const importedName = getImportedName(spec);
+          specInfos.push({ spec, localName, isRedundant: importedName ? names.get(localName)?.has(importedName) === true : false });
+        }
+        const redundant = specInfos.filter((s) => s.isRedundant);
+        if (!redundant.length) return;
+        const kept = specInfos.filter((s) => !s.isRedundant);
+        const sourceText = context.sourceCode.getText();
+        if (!kept.length) {
+          context.report({
+            node: importNode,
+            messageId: "redundant",
+            data: { name: redundant.map((s) => s.localName).join(", ") },
+            fix: (fixer) => fixer.removeRange(importRemovalRange(sourceText, importNode.range))
+          });
+          return;
+        }
+        context.report({
+          node: importNode,
+          messageId: "redundant",
+          data: { name: redundant.map((s) => s.localName).join(", ") },
+          fix: (fixer) => fixer.replaceText(importNode, rebuildImportDeclaration(context, importNode, kept))
+        });
+      }
+    };
+  }
+};
+function isDeclarationFile(filename) {
+  return /\.d\.(?:cts|mts|ts)$/.test(filename);
+}
+function importRemovalRange(text, range) {
+  let end = range[1];
+  while (text[end] === " " || text[end] === "	") {
+    end++;
+  }
+  if (text.startsWith("\r\n", end)) {
+    return [range[0], end + 2];
+  }
+  if (text[end] === "\n") {
+    return [range[0], end + 1];
+  }
+  return [range[0], end];
+}
+function isTypeOnlyImport(node, spec) {
+  return node.importKind === "type" || spec.importKind === "type";
+}
+function addAutoImportName(lookup, localName, importedName) {
+  const importedNames = lookup.get(localName) || /* @__PURE__ */ new Set();
+  importedNames.add(importedName);
+  lookup.set(localName, importedNames);
+}
+function getImportedName(spec) {
+  return typeof spec.imported.name === "string" ? spec.imported.name : typeof spec.imported.value === "string" ? spec.imported.value : void 0;
+}
+function rebuildImportDeclaration(context, node, kept) {
+  const defaultSpecifiers = kept.filter(({ spec }) => spec.type === "ImportDefaultSpecifier");
+  const namespaceSpecifiers = kept.filter(({ spec }) => spec.type === "ImportNamespaceSpecifier");
+  const namedSpecifiers = kept.filter(({ spec }) => spec.type === "ImportSpecifier").map(({ spec }) => spec);
+  const useTypeKeyword = node.importKind !== "type" && !defaultSpecifiers.length && !namespaceSpecifiers.length && namedSpecifiers.length > 0 && namedSpecifiers.every((spec) => spec.importKind === "type");
+  const specifierTexts = [
+    ...defaultSpecifiers.map(({ spec }) => context.sourceCode.getText(spec)),
+    ...namespaceSpecifiers.map(({ spec }) => context.sourceCode.getText(spec))
+  ];
+  if (namedSpecifiers.length) {
+    const namedTexts = namedSpecifiers.map((spec) => {
+      const text = context.sourceCode.getText(spec);
+      return useTypeKeyword ? text.replace(/^type\s+/, "") : text;
+    });
+    specifierTexts.push(`{ ${namedTexts.join(", ")} }`);
+  }
+  const sourceRange = node.source.range;
+  const suffix = context.sourceCode.text.slice(sourceRange[1], node.range[1]);
+  return `import${node.importKind === "type" || useTypeKeyword ? " type" : ""} ${specifierTexts.join(", ")} from ${context.sourceCode.getText(node.source)}${suffix}`;
+}

package/dist/runtime/eslint/plugin.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        'no-redundant-import': import("eslint").Rule.RuleModule;
+    };
+};
+export default _default;

package/dist/runtime/eslint/plugin.js

@@ -0,0 +1,5 @@
+import { noRedundantImport } from "./no-redundant-import.js";
+export default {
+  meta: { name: "skill-hub" },
+  rules: { "no-redundant-import": noRedundantImport }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-skill-hub",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Teach your AI agent the Nuxt way with best practices and module guidance.",
   "repository": {
     "type": "git",
@@ -13,6 +13,9 @@
       "types": "./dist/types.d.mts",
       "import": "./dist/module.mjs",
       "default": "./dist/module.mjs"
+    },
+    "./eslint-plugin": {
+      "import": "./dist/runtime/eslint/plugin.js"
     }
   },
   "main": "./dist/module.mjs",
@@ -58,11 +61,13 @@
     "dev:build": "nuxt-module-build build --stub --watch",
     "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare",
     "release": "bumpp --push --no-push-all",
+    "release:check-version": "node ./scripts/check-npm-version.mjs",
     "lint": "eslint .",
-    "test": "pnpm run dev:prepare && vitest run && pnpm run test:pack",
+    "test": "pnpm run dev:prepare && pnpm run docs:prepare && vitest run && pnpm run test:pack",
     "test:pack": "node ./scripts/check-packlist.mjs",
     "test:watch": "vitest watch",
     "test:types": "pnpm run dev:prepare && vue-tsc --noEmit",
+    "docs:prepare": "pnpm --dir docs exec nuxt prepare",
     "docs:typecheck": "pnpm --dir docs typecheck",
     "typecheck": "pnpm run test:types && pnpm run docs:typecheck"
   }