zemdomu 1.2.0 → 1.3.2

package/README.md

@@ -1,224 +1,224 @@
-# ZemDomu Core
-
-Semantic HTML linting engine for clean, accessible and SEO-friendly markup. This package provides the shared core logic used by the ZemDomu VS Code extension and upcoming GitHub Action.
-
-## 🧠 What is ZemDomu?
-
-**ZemDomu** is a semantic-first linter that helps developers write better HTML and JSX by catching accessibility and structural issues. It parses `.html`, `.jsx` and `.tsx` files and exposes a simple `lint()` function that returns semantic violations.
-
-## 🚀 Installation
-
-```bash
-npm install zemdomu
-# or
-yarn add zemdomu
-```
-
-## ✨ Features
-
-- ✅ Lint semantic issues in HTML, JSX and TSX
-- 📦 Works in Node.js, CI or any JS runtime
-- ⚙️ Extensible rule system with simple custom rules
-- 🔀 Cross-component analysis for React/JSX projects
-- 🚀 Command line interface with `--custom` and `--cross`
-- ⚠️ Configurable rule severity (`error`, `warning`, `off`)
-- 📈 Performance diagnostics for profiling lint runs
-- 📚 Shared by the extension and GitHub Action
-- 🧪 Simple API: `lint(content, options)`
-
-## ⚙️ Usage Example
-
-```ts
-import { lint } from "zemdomu";
-
-const html = "<img>";
-const results = lint(html, { rules: { requireAltText: true } });
-
-console.log(results);
-// [
-//   {
-//     line: 0,
-//     column: 0,
-//     message: '<img> tag missing alt attribute',
-//     rule: 'requireAltText'
-//   }
-// ]
-
-// Custom rules can be supplied via the `customRules` option
-// const myRule = { name: 'demo', test: node => false, message: 'demo' };
-// lint(html, { customRules: [myRule] });
-```
-
-## 📖 API
-
-`lint(content: string, options?: LinterOptions): LintResult[]`
-
-**Parameters**
-
-- `content` — HTML, JSX or TSX string input
-- `options.rules` — severity settings for built-in rules
-- `options.customRules` — array of additional rules
-- `options.filePath` — optional source file path
-- `options.perf` — attach a `PerformanceRecorder` instance
-
-**Example `LinterOptions`**
-
-```ts
-interface LinterOptions {
-  rules?: Record<string, 'error' | 'warning' | 'off'>;
-  customRules?: Rule[];
-  filePath?: string;
-  perf?: PerformanceRecorder;
-}
-```
-
-Example enabling one rule as a warning:
-
-```ts
-const results = lint(html, {
-  rules: { requireAltText: 'warning', uniqueIds: 'error' }
-});
-```
-
-**Example `LintResult`**
-
-```ts
-interface LintResult {
-  line: number;
-  column: number;
-  message: string;
-  rule: string;
-}
-```
-
-## 🛠 CLI Usage
-
-Run the linter from the command line by installing the package globally or using
-`npx`. Provide one or more glob patterns to specify the files to lint. Patterns
-may be separated by spaces, commas or newlines:
-
-```bash
-npx zemdomu "src/**/*.{html,jsx,tsx}" --custom my-rule.js
-npx zemdomu "src/**/*.html,src/**/*.jsx"
-```
-
-Use `--custom` (or `-c`) to provide a path to a JavaScript or TypeScript module
-exporting a custom rule or array of rules. Use `--cross` to enable cross
-component analysis.
-
-### Cross-Component Analysis
-
-When analysing JSX projects you can track `<h1>` usage or similar patterns
-across component boundaries. Instantiate `ProjectLinter` with the
-`crossComponentAnalysis` option or pass `--cross` to the CLI. Use
-`crossComponentDepth` (or `--cross-depth`) to limit how deep component trees are
-traversed during analysis:
-
-```ts
-import { ProjectLinter } from 'zemdomu';
-const linter = new ProjectLinter({ crossComponentAnalysis: true, crossComponentDepth: 2 });
-await linter.lintFile('App.jsx');
-```
-
-```bash
-npx zemdomu "src/**/*.{jsx,tsx}" --cross --cross-depth 2
-```
-
-### Performance Diagnostics
-
-Attach a `PerformanceDiagnostics` recorder to gather timing information for each
-file and rule:
-
-```ts
-import { lint, PerformanceDiagnostics } from 'zemdomu';
-const perf = new PerformanceDiagnostics();
-lint(code, { perf });
-console.log(perf.getAsJSON());
-```
-
-## 📝 Writing Custom Rules
-
-Custom rules are simple objects implementing the `Rule` interface. At minimum
-provide a `name`, a `test` function that returns `true` when a node violates the
-rule and a `message` describing the problem:
-
-```ts
-interface Rule {
-  name: string;
-  test(node: any): boolean;
-  message: string;
-}
-```
-
-```js
-// my-rule.js
-module.exports = {
-  name: 'noFooDiv',
-  test: node => node.type === 'element' && node.tagName === 'foo',
-  message: '<foo> is not allowed'
-};
-```
-
-Use it programmatically:
-
-```ts
-import { lint } from 'zemdomu';
-const results = lint('<foo></foo>', { customRules: [require('./my-rule')] });
-```
-
-### Helper Utilities
-
-For more advanced rules you may need direct access to the parsed HTML or JSX
-AST. ZemDomu exposes a few helpers to make this easier:
-
-```ts
-import {
-  parseHtml,
-  visitHtml,
-  getAttr,
-  getJsxAttr,
-  getTag,
-  ElementNode,
-  HtmlVisitor,
-} from 'zemdomu';
-```
-
-`parseHtml` returns the root `ElementNode`. The `visitHtml` function performs a
-simple depth‑first traversal using an `HtmlVisitor` with optional `enter` and
-`exit` callbacks. Utility functions like `getAttr` and `getJsxAttr` help reading
-attributes, while `getTag` resolves JSX element names.
-
-Or via the CLI:
-
-```bash
-npx zemdomu file.html --custom my-rule.js
-```
-
-## 🔗 Related Tools
-
-- [ZemDomu VS Code Extension](https://marketplace.visualstudio.com/items?itemName=ZachariasErydBerlin.zemdomu)
-- ZemDomu GitHub Action (coming soon)
-
-## 🛠 Development
-
-```bash
-git clone https://github.com/Zemdomu/ZemDomu-core.git
-cd ZemDomu-core
-npm install
-npm run build
-```
-
-Tests and coverage support coming soon.
-
-## 🤝 Contributing
-
-We welcome contributions! If you'd like to add rules, improve parsing or integrate new consumers:
-
-1. Fork this repo
-2. Add your logic inside `src/rules` or `src/linter.ts`
-3. Write or update tests (if applicable)
-4. Submit a pull request!
-
-## 📄 License
-
-MIT © 2025 Zacharias Eryd Berlin
+# ZemDomu
+
+Semantic HTML linting engine for clean, accessible and SEO-friendly markup. This package provides the shared core logic used by the ZemDomu VS Code extension and upcoming GitHub Action.
+
+## 🧠 What is ZemDomu?
+
+**ZemDomu** is a semantic-first linter that helps developers write better HTML and JSX by catching accessibility and structural issues. It parses `.html`, `.jsx` and `.tsx` files and exposes a simple `lint()` function that returns semantic violations.
+
+## 🚀 Installation
+
+```bash
+npm install zemdomu
+# or
+yarn add zemdomu
+```
+
+## ✨ Features
+
+- ✅ Lint semantic issues in HTML, JSX and TSX
+- 📦 Works in Node.js, CI or any JS runtime
+- ⚙️ Extensible rule system with simple custom rules
+- 🔀 Cross-component analysis for React/JSX projects
+- 🚀 Command line interface with `--custom` and `--cross`
+- ⚠️ Configurable rule severity (`error`, `warning`, `off`)
+- 📈 Performance diagnostics for profiling lint runs
+- 📚 Shared by the extension and GitHub Action
+- 🧪 Simple API: `lint(content, options)`
+
+## ⚙️ Usage Example
+
+```ts
+import { lint } from "zemdomu";
+
+const html = "<img>";
+const results = lint(html, { rules: { requireAltText: true } });
+
+console.log(results);
+// [
+//   {
+//     line: 0,
+//     column: 0,
+//     message: '<img> tag missing alt attribute',
+//     rule: 'requireAltText'
+//   }
+// ]
+
+// Custom rules can be supplied via the `customRules` option
+// const myRule = { name: 'demo', test: node => false, message: 'demo' };
+// lint(html, { customRules: [myRule] });
+```
+
+## 📖 API
+
+`lint(content: string, options?: LinterOptions): LintResult[]`
+
+**Parameters**
+
+- `content` — HTML, JSX or TSX string input
+- `options.rules` — severity settings for built-in rules
+- `options.customRules` — array of additional rules
+- `options.filePath` — optional source file path
+- `options.perf` — attach a `PerformanceRecorder` instance
+
+**Example `LinterOptions`**
+
+```ts
+interface LinterOptions {
+  rules?: Record<string, 'error' | 'warning' | 'off'>;
+  customRules?: Rule[];
+  filePath?: string;
+  perf?: PerformanceRecorder;
+}
+```
+
+Example enabling one rule as a warning:
+
+```ts
+const results = lint(html, {
+  rules: { requireAltText: 'warning', uniqueIds: 'error' }
+});
+```
+
+**Example `LintResult`**
+
+```ts
+interface LintResult {
+  line: number;
+  column: number;
+  message: string;
+  rule: string;
+}
+```
+
+## 🛠 CLI Usage
+
+Run the linter from the command line by installing the package globally or using
+`npx`. Provide one or more glob patterns to specify the files to lint. Patterns
+may be separated by spaces, commas or newlines:
+
+```bash
+npx zemdomu "src/**/*.{html,jsx,tsx}" --custom my-rule.js
+npx zemdomu "src/**/*.html,src/**/*.jsx"
+```
+
+Use `--custom` (or `-c`) to provide a path to a JavaScript or TypeScript module
+exporting a custom rule or array of rules. Use `--cross` to enable cross
+component analysis.
+
+### Cross-Component Analysis
+
+When analysing JSX projects you can track `<h1>` usage or similar patterns
+across component boundaries. Instantiate `ProjectLinter` with the
+`crossComponentAnalysis` option or pass `--cross` to the CLI. Use
+`crossComponentDepth` (or `--cross-depth`) to limit how deep component trees are
+traversed during analysis:
+
+```ts
+import { ProjectLinter } from 'zemdomu';
+const linter = new ProjectLinter({ crossComponentAnalysis: true, crossComponentDepth: 2 });
+await linter.lintFile('App.jsx');
+```
+
+```bash
+npx zemdomu "src/**/*.{jsx,tsx}" --cross --cross-depth 2
+```
+
+### Performance Diagnostics
+
+Attach a `PerformanceDiagnostics` recorder to gather timing information for each
+file and rule:
+
+```ts
+import { lint, PerformanceDiagnostics } from 'zemdomu';
+const perf = new PerformanceDiagnostics();
+lint(code, { perf });
+console.log(perf.getAsJSON());
+```
+
+## 📝 Writing Custom Rules
+
+Custom rules are simple objects implementing the `Rule` interface. At minimum
+provide a `name`, a `test` function that returns `true` when a node violates the
+rule and a `message` describing the problem:
+
+```ts
+interface Rule {
+  name: string;
+  test(node: any): boolean;
+  message: string;
+}
+```
+
+```js
+// my-rule.js
+module.exports = {
+  name: 'noFooDiv',
+  test: node => node.type === 'element' && node.tagName === 'foo',
+  message: '<foo> is not allowed'
+};
+```
+
+Use it programmatically:
+
+```ts
+import { lint } from 'zemdomu';
+const results = lint('<foo></foo>', { customRules: [require('./my-rule')] });
+```
+
+### Helper Utilities
+
+For more advanced rules you may need direct access to the parsed HTML or JSX
+AST. ZemDomu exposes a few helpers to make this easier:
+
+```ts
+import {
+  parseHtml,
+  visitHtml,
+  getAttr,
+  getJsxAttr,
+  getTag,
+  ElementNode,
+  HtmlVisitor,
+} from 'zemdomu';
+```
+
+`parseHtml` returns the root `ElementNode`. The `visitHtml` function performs a
+simple depth‑first traversal using an `HtmlVisitor` with optional `enter` and
+`exit` callbacks. Utility functions like `getAttr` and `getJsxAttr` help reading
+attributes, while `getTag` resolves JSX element names.
+
+Or via the CLI:
+
+```bash
+npx zemdomu file.html --custom my-rule.js
+```
+
+## 🔗 Related Tools
+
+- [ZemDomu VS Code Extension](https://marketplace.visualstudio.com/items?itemName=ZachariasErydBerlin.zemdomu)
+- ZemDomu GitHub Action (coming soon)
+
+## 🛠 Development
+
+```bash
+git clone https://github.com/Zemdomu/ZemDomu-core.git
+cd ZemDomu-core
+npm install
+npm run build
+```
+
+Tests and coverage support coming soon.
+
+## 🤝 Contributing
+
+We welcome contributions! If you'd like to add rules, improve parsing or integrate new consumers:
+
+1. Fork this repo
+2. Add your logic inside `src/rules` or `src/linter.ts`
+3. Write or update tests (if applicable)
+4. Submit a pull request!
+
+## 📄 License
+
+MIT © 2025 Zacharias Eryd Berlin

package/out/src/cli.js

@@ -31,7 +31,13 @@ async function run() {
             const file = args[++i];
             if (!file)
                 throw new Error('Missing file for --custom');
-            const mod = require(path_1.default.resolve(file));
+            const resolved = path_1.default.resolve(file);
+            const customDir = path_1.default.resolve('custom-rules');
+            const relative = path_1.default.relative(customDir, resolved);
+            if (relative.startsWith('..') || path_1.default.isAbsolute(relative)) {
+                throw new Error('Custom rule file must be inside ./custom-rules');
+            }
+            const mod = require(resolved);
             const rules = (_a = mod.default) !== null && _a !== void 0 ? _a : mod;
             if (Array.isArray(rules))
                 customRules.push(...rules);

package/out/src/project-linter.js

@@ -32,11 +32,17 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectLinter = void 0;
 const fs = __importStar(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const ts = __importStar(require("typescript"));
 const linter_1 = require("./linter");
 const component_analyzer_1 = require("./component-analyzer");
+const collectLocalDeps_1 = require("./utils/collectLocalDeps");
 class ProjectLinter {
     constructor(options = {}) {
         this.opts = options;
@@ -47,7 +53,7 @@ class ProjectLinter {
     }
     async lintFile(filePath, content) {
         if (!content) {
-            content = await fs.readFile(filePath, 'utf8');
+            content = await fs.readFile(filePath, "utf8");
         }
         const results = (0, linter_1.lint)(content, { ...this.opts, filePath });
         const byFile = new Map();
@@ -55,9 +61,8 @@ class ProjectLinter {
         const xmlMode = /\.(jsx|tsx)$/.test(filePath);
         if (xmlMode) {
             const component = await this.analyzer.analyzeFile(filePath);
-            if (component) {
+            if (component)
                 this.analyzer.registerComponent(component, results);
-            }
             if (this.opts.crossComponentAnalysis) {
                 const cross = this.analyzer.analyzeComponentTree();
                 for (const r of cross) {
@@ -72,8 +77,30 @@ class ProjectLinter {
         return byFile;
     }
     async lintFiles(filePaths) {
+        var _a, _b, _c;
+        const root = (_a = this.opts.rootDir) !== null && _a !== void 0 ? _a : process.cwd();
+        const configPath = ts.findConfigFile(root, ts.sys.fileExists, "tsconfig.json");
+        let baseUrl;
+        let paths;
+        if (configPath) {
+            const cfg = ts.readConfigFile(configPath, ts.sys.readFile).config;
+            const cfgDir = path_1.default.dirname(configPath);
+            baseUrl = ((_b = cfg === null || cfg === void 0 ? void 0 : cfg.compilerOptions) === null || _b === void 0 ? void 0 : _b.baseUrl)
+                ? path_1.default.resolve(cfgDir, cfg.compilerOptions.baseUrl)
+                : undefined;
+            paths = (_c = cfg === null || cfg === void 0 ? void 0 : cfg.compilerOptions) === null || _c === void 0 ? void 0 : _c.paths;
+        }
+        const targets = this.opts.crossComponentAnalysis
+            ? (0, collectLocalDeps_1.collectLocalDeps)(filePaths, {
+                rootDir: root,
+                baseUrl,
+                paths,
+                maxDepth: this.opts.crossComponentDepth,
+            })
+            : filePaths;
+        const uniqueTargets = Array.from(new Set(targets.map((p) => path_1.default.resolve(p))));
         const aggregated = new Map();
-        for (const filePath of filePaths) {
+        for (const filePath of uniqueTargets) {
             const fileMap = await this.lintFile(filePath);
             for (const [fp, res] of fileMap.entries()) {
                 if (!aggregated.has(fp))

package/out/src/utils/collectLocalDeps.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectLocalDeps = collectLocalDeps;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ts = __importStar(require("typescript"));
+const EXTS = [".tsx", ".ts", ".jsx", ".js"];
+function resolveWithExtensions(base) {
+    if (fs_1.default.existsSync(base) && fs_1.default.statSync(base).isFile())
+        return base;
+    for (const ext of EXTS) {
+        const p = base + ext;
+        if (fs_1.default.existsSync(p) && fs_1.default.statSync(p).isFile())
+            return p;
+    }
+    for (const ext of EXTS) {
+        const p = path_1.default.join(base, "index" + ext);
+        if (fs_1.default.existsSync(p) && fs_1.default.statSync(p).isFile())
+            return p;
+    }
+    return null;
+}
+function resolveAlias(spec, fileDir, ctx) {
+    if (spec.startsWith(".") || spec.startsWith("/")) {
+        return resolveWithExtensions(path_1.default.resolve(fileDir, spec));
+    }
+    const { baseUrl, paths } = ctx;
+    if (baseUrl && paths) {
+        for (const [pattern, targets] of Object.entries(paths)) {
+            const starIdx = pattern.indexOf("*");
+            if (starIdx >= 0) {
+                const pre = pattern.slice(0, starIdx);
+                const post = pattern.slice(starIdx + 1);
+                if (spec.startsWith(pre) && spec.endsWith(post)) {
+                    const middle = spec.slice(pre.length, spec.length - post.length);
+                    for (const t of targets) {
+                        const candidate = t.replace("*", middle);
+                        const abs = path_1.default.resolve(baseUrl, candidate);
+                        const hit = resolveWithExtensions(abs);
+                        if (hit)
+                            return hit;
+                    }
+                }
+            }
+            else if (spec === pattern) {
+                for (const t of targets) {
+                    const abs = path_1.default.resolve(baseUrl, t);
+                    const hit = resolveWithExtensions(abs);
+                    if (hit)
+                        return hit;
+                }
+            }
+        }
+    }
+    return null;
+}
+function collectLocalDeps(entries, ctx) {
+    const root = path_1.default.resolve(ctx.rootDir);
+    const seen = new Set();
+    const q = entries.map((p) => ({
+        file: path_1.default.resolve(p),
+        depth: 0,
+    }));
+    while (q.length) {
+        const { file, depth } = q.pop();
+        if (seen.has(file))
+            continue;
+        seen.add(file);
+        if (ctx.maxDepth !== undefined && depth >= ctx.maxDepth)
+            continue;
+        let code = "";
+        try {
+            code = fs_1.default.readFileSync(file, "utf8");
+        }
+        catch {
+            continue;
+        }
+        const sf = ts.createSourceFile(file, code, ts.ScriptTarget.Latest, true);
+        sf.forEachChild((node) => {
+            let spec;
+            if (ts.isImportDeclaration(node) && node.moduleSpecifier) {
+                spec = node.moduleSpecifier.text;
+            }
+            else if (ts.isExportDeclaration(node) && node.moduleSpecifier) {
+                spec = node.moduleSpecifier.text;
+            }
+            if (!spec)
+                return;
+            const resolved = resolveAlias(spec, path_1.default.dirname(file), ctx);
+            if (resolved && resolved.startsWith(root)) {
+                q.push({ file: resolved, depth: depth + 1 });
+            }
+        });
+    }
+    return Array.from(seen);
+}

package/out/tests/cli-custom-rule.test.js

@@ -6,11 +6,14 @@ const { spawnSync } = require('child_process');
 const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'zd-cli-'));
 const htmlFile = path.join(tmp, 'test.html');
 fs.writeFileSync(htmlFile, '<foo></foo>');
-const ruleFile = path.join(tmp, 'my-rule.js');
+const customDir = path.join(tmp, 'custom-rules');
+fs.mkdirSync(customDir);
+const ruleFile = path.join(customDir, 'my-rule.js');
 fs.writeFileSync(ruleFile, `module.exports = {\n  name: 'noFoo',\n  test: n => (n.type === 'element' && n.tagName === 'foo') || (n.type === 'JSXElement' && n.openingElement && n.openingElement.name && n.openingElement.name.name === 'foo'),\n  message: 'Foo elements are not allowed'\n};\n`);
 const cli = path.join(__dirname, '..', 'src', 'cli.js');
 const result = spawnSync('node', [cli, htmlFile, '--custom', ruleFile], {
-    encoding: 'utf8'
+    encoding: 'utf8',
+    cwd: tmp,
 });
 if (result.status === 0) {
     console.error(result.stdout, result.stderr);
@@ -22,3 +25,18 @@ if (!output.includes('Foo elements are not allowed')) {
     throw new Error('Expected custom rule message');
 }
 console.log('CLI custom rule test passed');
+// Should error when rule file is outside the custom-rules directory
+const outsideRule = path.join(tmp, 'other-rule.js');
+fs.writeFileSync(outsideRule, 'module.exports = {};');
+const bad = spawnSync('node', [cli, htmlFile, '--custom', outsideRule], {
+    encoding: 'utf8',
+    cwd: tmp,
+});
+if (bad.status === 0) {
+    throw new Error('Expected CLI to fail for outside rule');
+}
+if (!bad.stderr.includes('Custom rule file must be inside ./custom-rules')) {
+    console.error(bad.stdout, bad.stderr);
+    throw new Error('Expected directory restriction error');
+}
+console.log('CLI custom rule path restriction test passed');

package/out/tests/crossComponent/Button.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Button;
+const jsx_runtime_1 = require("react/jsx-runtime");
+function Button() {
+    return ((0, jsx_runtime_1.jsxs)("div", { children: [(0, jsx_runtime_1.jsx)("h1", { children: "Button" }), (0, jsx_runtime_1.jsx)("h5", { children: "Subsection" })] }));
+}

package/out/tests/crossComponent/Page.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Page;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const Section_1 = __importDefault(require("@alias/Section"));
+function Page() {
+    return ((0, jsx_runtime_1.jsxs)("main", { children: [(0, jsx_runtime_1.jsx)("h1", { children: "Hello" }), (0, jsx_runtime_1.jsx)(Section_1.default, {})] }));
+}

package/out/tests/crossComponent/Section.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Section;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const SubSection_1 = __importDefault(require("@alias/SubSection"));
+function Section() {
+    return ((0, jsx_runtime_1.jsxs)("section", { children: [(0, jsx_runtime_1.jsx)("h2", { children: "Section Title" }), (0, jsx_runtime_1.jsx)(SubSection_1.default, {})] }));
+}

package/out/tests/crossComponent/SubSection.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = SubSection;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const Button_1 = __importDefault(require("@alias/Button"));
+function SubSection() {
+    return ((0, jsx_runtime_1.jsxs)("div", { children: [(0, jsx_runtime_1.jsx)("h3", { children: "SubSection" }), (0, jsx_runtime_1.jsx)(Button_1.default, {})] }));
+}

package/out/tests/crossComponent/cross-heading-order-alias.test.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const path_1 = __importDefault(require("path"));
+const index_1 = require("../../src/index");
+describe("cross component heading order (ts-path-alias)", () => {
+    it("follows @alias/* from PageAlias and finds violations", async () => {
+        var _a, _b;
+        const pagePath = path_1.default.resolve(__dirname, "../../../tests/crossComponent/Page.tsx");
+        const linter = new index_1.ProjectLinter({
+            crossComponentAnalysis: true,
+            rules: {
+                singleH1: "error",
+                enforceHeadingOrder: "error",
+                requireButtonText: "off",
+            },
+        });
+        const map = await linter.lintFiles([pagePath]);
+        const results = Array.from(map.values()).flat();
+        const byRule = results.reduce((a, r) => {
+            var _a;
+            a[r.rule] = ((_a = a[r.rule]) !== null && _a !== void 0 ? _a : 0) + 1;
+            return a;
+        }, {});
+        assert_1.default.ok(((_a = byRule["singleH1"]) !== null && _a !== void 0 ? _a : 0) >= 1);
+        assert_1.default.ok(((_b = byRule["enforceHeadingOrder"]) !== null && _b !== void 0 ? _b : 0) >= 1);
+    });
+});

package/out/tests/crossComponent/cross-heading-order-entry-only.test.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const path_1 = __importDefault(require("path"));
+const index_1 = require("../../src/index");
+describe("cross component heading order (entry-only)", () => {
+    it("follows imports from Page and finds violations", async () => {
+        var _a, _b;
+        const pagePath = path_1.default.resolve(__dirname, "../../../tests/crossComponent/Page.tsx");
+        const linter = new index_1.ProjectLinter({
+            crossComponentAnalysis: true,
+            rules: {
+                singleH1: "error",
+                enforceHeadingOrder: "error",
+                requireButtonText: "off",
+            },
+        });
+        const map = await linter.lintFiles([pagePath]);
+        const results = Array.from(map.values()).flat();
+        const byRule = results.reduce((a, r) => {
+            var _a;
+            a[r.rule] = ((_a = a[r.rule]) !== null && _a !== void 0 ? _a : 0) + 1;
+            return a;
+        }, {});
+        assert_1.default.ok(((_a = byRule["singleH1"]) !== null && _a !== void 0 ? _a : 0) >= 1);
+        assert_1.default.ok(((_b = byRule["enforceHeadingOrder"]) !== null && _b !== void 0 ? _b : 0) >= 1);
+    });
+});

package/out/tests/crossComponent/cross-heading-order.test.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// tests/crossComponent/cross-heading-order.test.ts
+const assert_1 = __importDefault(require("assert"));
+const path_1 = __importDefault(require("path"));
+const index_1 = require("../../src/index");
+describe("cross component heading order", () => {
+    it("detects heading order and h1 issues across components", async () => {
+        var _a, _b;
+        const buttonPath = path_1.default.resolve(__dirname, "../../../tests/crossComponent/Button.tsx");
+        const sectionPath = path_1.default.resolve(__dirname, "../../../tests/crossComponent/Section.tsx");
+        const subSectionPath = path_1.default.resolve(__dirname, "../../../tests/crossComponent/SubSection.tsx");
+        const pagePath = path_1.default.resolve(__dirname, "../../../tests/crossComponent/Page.tsx");
+        const linter = new index_1.ProjectLinter({
+            crossComponentAnalysis: true,
+            rules: {
+                singleH1: "error",
+                enforceHeadingOrder: "error",
+                requireButtonText: "off",
+            },
+        });
+        const map = await linter.lintFiles([
+            buttonPath,
+            sectionPath,
+            subSectionPath,
+            pagePath,
+        ]);
+        const results = Array.from(map.values()).flat();
+        // Presence checks
+        assert_1.default.ok(results.some((r) => r.rule === "singleH1"), "Expected cross-component singleH1 warning");
+        assert_1.default.ok(results.some((r) => r.rule === "enforceHeadingOrder"), "Expected cross-component heading order warning");
+        // Count checks (looser; tighten later if you want)
+        const byRule = results.reduce((acc, r) => {
+            var _a;
+            acc[r.rule] = ((_a = acc[r.rule]) !== null && _a !== void 0 ? _a : 0) + 1;
+            return acc;
+        }, {});
+        assert_1.default.ok(((_a = byRule["singleH1"]) !== null && _a !== void 0 ? _a : 0) >= 1, "Expected at least one singleH1");
+        assert_1.default.ok(((_b = byRule["enforceHeadingOrder"]) !== null && _b !== void 0 ? _b : 0) >= 1, // set to >=2 if you expect more
+        "Expected at least one enforceHeadingOrder");
+    });
+});

package/package.json

@@ -1,54 +1,60 @@
-{
-  "name": "zemdomu",
-  "version": "1.2.0",
-  "description": "Semantic HTML linter for HTML, JSX, and TSX. Detects accessibility, SEO, and structure issues before deployment.",
-  "main": "./out/index.js",
-  "bin": {
-    "zemdomu": "./out/cli.js"
-  },
-  "files": [
-    "out"
-  ],
-  "private": false,
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "compile": "tsc -p tsconfig.json",
-    "test": "npm run compile && mocha out/**/*.test.js"
-  },
-  "keywords": [
-    "html",
-    "jsx",
-    "tsx",
-    "linter",
-    "accessibility",
-    "semantic-html",
-    "seo",
-    "cli",
-    "vscode",
-    "github-action"
-  ],
-  "author": "Zacharias Eryd Berlin",
-  "license": "ISC",
-  "devDependencies": {
-    "@types/babel__traverse": "^7.20.7",
-    "@types/babel-traverse": "^6.25.10",
-    "@types/babel-types": "^7.0.16",
-    "@types/glob": "^8.1.0",
-    "@types/mocha": "^10.0.10",
-    "@types/node": "^22.15.17",
-    "esbuild": "^0.25.5",
-    "mocha": "^10.8.2",
-    "typescript": "^5.8.2"
-  },
-  "dependencies": {
-    "@babel/parser": "^7.27.0",
-    "@babel/traverse": "^7.27.0",
-    "@babel/types": "^7.27.0",
-    "glob": "^7.2.3"
-  },
-  "jest": {
-    "transform": {
-      "^.+\\.tsx?$": "ts-jest"
-    }
-  }
-}
+{
+  "name": "zemdomu",
+  "version": "1.3.2",
+  "description": "Semantic HTML linter for HTML, JSX, and TSX. Detects accessibility, SEO, and structure issues before deployment.",
+  "main": "./out/index.js",
+  "types": "./out/src/index.d.ts",
+  "bin": {
+    "zemdomu": "./out/src/cli.js"
+  },
+  "files": [
+    "out"
+  ],
+  "private": false,
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "compile": "tsc -p tsconfig.json",
+    "test": "npm run compile && mocha out/**/*.test.js",
+    "prepublishOnly": "npm run compile && npm test"
+  },
+  "keywords": [
+    "html",
+    "jsx",
+    "tsx",
+    "linter",
+    "accessibility",
+    "semantic-html",
+    "seo",
+    "cli",
+    "vscode",
+    "github-action"
+  ],
+  "author": "Zacharias Eryd Berlin",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/babel__traverse": "^7.20.7",
+    "@types/babel-traverse": "^6.25.10",
+    "@types/babel-types": "^7.0.16",
+    "@types/glob": "^8.1.0",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^22.15.17",
+    "@types/react": "^19.1.9",
+    "@types/react-dom": "^19.1.7",
+    "esbuild": "^0.25.5",
+    "mocha": "^10.8.2",
+    "typescript": "^5.8.2"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.27.0",
+    "@babel/traverse": "^7.27.0",
+    "@babel/types": "^7.27.0",
+    "glob": "^7.2.3",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1"
+  },
+  "jest": {
+    "transform": {
+      "^.+\\.tsx?$": "ts-jest"
+    }
+  }
+}