@lumiose/eslint-plugin 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Javi Aguilar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,86 @@
+import { type Diagnostic } from "@lumiose/compiler";
+/** The parts of ESLint's rule context the rules use (oxlint implements the same API). */
+interface RuleContext {
+    filename: string;
+    physicalFilename?: string;
+    sourceCode: {
+        text: string;
+    };
+    report(descriptor: {
+        loc: {
+            start: Position;
+            end: Position;
+        };
+        message: string;
+        fix?: (fixer: Fixer) => unknown;
+    }): void;
+}
+interface Position {
+    /** 1-based. */
+    line: number;
+    /** 0-based. */
+    column: number;
+}
+interface Fixer {
+    replaceTextRange(range: [number, number], text: string): unknown;
+}
+interface Message {
+    ruleId: string | null;
+    [key: string]: unknown;
+}
+/** The compiler's diagnostics for a `.stsx` or `.tsx` file (none for other files). */
+export declare function lumioseDiagnostics(text: string, filename: string): Diagnostic[];
+declare const plugin: {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        /** The compiler's errors (reactivity, styles, islands, …). */
+        compiler: {
+            meta: {
+                type: "problem";
+                docs: {
+                    description: string;
+                    url: string;
+                };
+                fixable: "code";
+                schema: never[];
+            };
+            create(context: RuleContext): {
+                Program(): void;
+            };
+        };
+        /** The compiler's warnings and hints. */
+        "compiler-warnings": {
+            meta: {
+                type: "problem";
+                docs: {
+                    description: string;
+                    url: string;
+                };
+                fixable: "code";
+                schema: never[];
+            };
+            create(context: RuleContext): {
+                Program(): void;
+            };
+        };
+    };
+    processors: {
+        stsx: {
+            meta: {
+                name: string;
+                version: string;
+            };
+            supportsAutofix: boolean;
+            preprocess(text: string, filename: string): {
+                text: string;
+                filename: string;
+            }[];
+            postprocess(messages: Message[][], filename: string): Message[];
+        };
+    };
+    configs: Record<string, unknown>;
+};
+export default plugin;

package/dist/index.js

@@ -0,0 +1,117 @@
+// `@lumiose/eslint-plugin` (TASK-41): the Lumiose compiler's diagnostics as lint rules. The compiler is
+// the single source of truth: these rules only report what `compile()` reports (`LUMxxxx`, with
+// help and fixes), so oxlint, ESLint, `lumiose check` and the editor agree.
+//
+// - oxlint (JS plugins): `"jsPlugins": ["@lumiose/eslint-plugin"]` lints `.tsx` files. oxlint cannot
+//   parse `.stsx` (no custom file formats yet): `lumiose lint` covers those.
+// - ESLint 9 (flat config): `configs.recommended` also lints `.stsx` files through the `stsx`
+//   processor, which hands ESLint the scanner's masked TSX (offset-identical, so positions and
+//   fixes apply to the source). Parse `.tsx` with a TypeScript parser (typescript-eslint).
+//
+// Not covered: project-wide checks (LUM4003, LUM3012) and `$` constants imported from other
+// modules, whose style diagnostics need the module graph: `lumiose check` reports those.
+import { compile, scan } from "@lumiose/compiler";
+/** TypeScript (and ESLint's parser) report syntax errors themselves. */
+const REPORTED_BY_PARSERS = new Set(["LUM1001"]);
+/** The original text of `.stsx` files being linted through the processor, by physical path. */
+const stsxSources = new Map();
+/** The compiler's diagnostics for a `.stsx` or `.tsx` file (none for other files). */
+export function lumioseDiagnostics(text, filename) {
+    if (!/\.(?:stsx|tsx)$/.test(filename))
+        return [];
+    let diagnostics;
+    try {
+        diagnostics = compile(text, filename, { target: "client", sourceMap: false }).diagnostics;
+    }
+    catch {
+        return [];
+    }
+    return diagnostics.filter((diagnostic) => !REPORTED_BY_PARSERS.has(diagnostic.code));
+}
+/** 1-based line and 0-based column (UTF-16) of `offset` in `text`. */
+function position(text, offset) {
+    let line = 1;
+    let start = 0;
+    for (let at = text.indexOf("\n"); at !== -1 && at < offset; at = text.indexOf("\n", at + 1)) {
+        line++;
+        start = at + 1;
+    }
+    return { line, column: offset - start };
+}
+/** `LUM2001: message`, then the help and the docs topic on a line of their own. */
+function message(diagnostic) {
+    const help = diagnostic.help === undefined ? "" : `${diagnostic.help} `;
+    return `${diagnostic.code}: ${diagnostic.message}\n${help}(lumiose docs ${diagnostic.docs})`;
+}
+function compilerRule(severities, description) {
+    return {
+        meta: {
+            type: "problem",
+            docs: {
+                description,
+                url: "https://github.com/itsjavi/lumiose/tree/main/packages/lumiose/docs/errors",
+            },
+            fixable: "code",
+            schema: [],
+        },
+        create(context) {
+            const file = context.physicalFilename ?? context.filename;
+            const text = stsxSources.get(file) ?? context.sourceCode.text;
+            return {
+                Program() {
+                    for (const diagnostic of lumioseDiagnostics(text, file)) {
+                        if (!severities.has(diagnostic.severity))
+                            continue;
+                        const { fix } = diagnostic;
+                        context.report({
+                            loc: {
+                                start: position(text, diagnostic.span.start),
+                                end: position(text, Math.max(diagnostic.span.start, diagnostic.span.end)),
+                            },
+                            message: message(diagnostic),
+                            ...(fix === undefined
+                                ? {}
+                                : {
+                                    fix: (fixer) => fix.edits.map((edit) => fixer.replaceTextRange([edit.span.start, edit.span.end], edit.text)),
+                                }),
+                        });
+                    }
+                },
+            };
+        },
+    };
+}
+/** ESLint processor for `.stsx`: lint the masked TSX, which keeps every offset of the source. */
+const stsxProcessor = {
+    meta: { name: "lumiose/stsx", version: "0.0.0" },
+    supportsAutofix: true,
+    preprocess(text, filename) {
+        stsxSources.set(filename, text);
+        return [{ text: scan(text, filename).masked, filename: "component.tsx" }];
+    },
+    postprocess(messages, filename) {
+        stsxSources.delete(filename);
+        return messages.flat();
+    },
+};
+const plugin = {
+    meta: { name: "lumiose", version: "0.0.0" },
+    rules: {
+        /** The compiler's errors (reactivity, styles, islands, …). */
+        compiler: compilerRule(new Set(["error"]), "Lumiose compiler errors (LUMxxxx)"),
+        /** The compiler's warnings and hints. */
+        "compiler-warnings": compilerRule(new Set(["warning", "hint"]), "Lumiose compiler warnings and hints (LUMxxxx)"),
+    },
+    processors: { stsx: stsxProcessor },
+    configs: {},
+};
+/** ESLint 9 flat config: `.stsx` through the processor, compiler rules on `.tsx` and `.stsx`. */
+plugin.configs["recommended"] = [
+    { files: ["**/*.stsx"], plugins: { lumiose: plugin }, processor: "lumiose/stsx" },
+    {
+        files: ["**/*.tsx", "**/*.stsx/*.tsx"],
+        plugins: { lumiose: plugin },
+        rules: { "lumiose/compiler": "error", "lumiose/compiler-warnings": "warn" },
+    },
+];
+export default plugin;

package/package.json

@@ -1,6 +1,30 @@
 {
   "name": "@lumiose/eslint-plugin",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Lumiose's compiler diagnostics (LUMxxxx) as lint rules for oxlint (JS plugins) and ESLint, plus a .stsx processor for ESLint.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/itsjavi/lumiose.git",
+    "directory": "packages/eslint-plugin"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@lumiose/compiler": "0.1.0"
+  },
+  "scripts": {
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "build": "node ../../scripts/build-package.ts"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.