@wix/origami-lint 1.34.34 → 1.34.36

package/README.md

@@ -2,7 +2,7 @@
 
 Offline lint for an exported Origami site. Each run lints only the pages whose files changed since the last passing
 run (every page when `theme.css` changed), and runs every rule on every component of those pages.
-The rules run as plain oxlint rules.
+The rules run as plain ESLint rules, in the lint's own process.
 
 Published to the Wix registry (public npm later). How the lint works, its parts and how to write a rule:
 [lint/README.md](lint/README.md).
@@ -35,8 +35,8 @@ pnpm --filter @wix/origami-lint run lint
 ```
 lint/        the source (lint.ts is the entry point and the origami-lint bin)
 dist/        lint/ built to JavaScript: what the package publishes (Node won't run .ts inside node_modules)
-test/        rules on in-memory pages, CSS, the pages to lint, the oxlint adapter; history, the site root and a whole run on temporary repositories
+test/        rules on in-memory pages, CSS, the pages to lint, the ESLint adapter; history, the site root and a whole run on temporary repositories
 ```
 
-The oxlint config is `lint/rules-adapter/oxlint/origami-rules.config.ts`, passed to oxlint with `-c`. It is not named
-`oxlint.config.ts`, so `oxlint .` in this repo doesn't load it as a nested config.
+The ESLint config is built in `lint/rules-adapter/eslint/run-rules.ts` and passed to ESLint's Node API, so a site's
+own `eslint.config.js` is never loaded. `pnpm run lint` (this package's own source) still runs oxlint.

package/dist/bi/stats.js

@@ -1,11 +1,14 @@
-// The oxlint process collects only ids, counts and timings. No BI sender runs in the plugin.
-import { writeFileSync } from 'node:fs';
 import { GLOBAL_COMPONENTS_FOLDER } from "../shared/site-files-tree-mapping.js";
 import { readStructure } from "../page-model/read-structure.js";
 const rules = [];
 export const models = [];
 const pages = new Map();
-let registered = false;
+let collecting = false;
+/** BI is on: from now on, the rules and the page models collect their stats. */
+export function collectStats() {
+    collecting = true;
+}
+export const isCollectingStats = () => collecting;
 /** Resolve the same root component id the page model reads; never use its path as a BI id. */
 export function pageId(filename, text, program) {
     let page = pages.get(filename);
@@ -19,19 +22,9 @@ export function pageId(filename, text, program) {
 }
 /** Called once per rule and file by the adapter. Passing rules retain their zero count. */
 export function startRuleStats(rule, checks, filename, text, program) {
-    const destination = process.env.ORIGAMI_LINT_STATS;
-    if (!destination)
+    if (!collecting)
         return;
     try {
-        if (!registered) {
-            registered = true;
-            process.once('exit', () => {
-                try {
-                    writeFileSync(destination, JSON.stringify({ rules, models }), { mode: 0o600 });
-                }
-                catch { /* Stats must never fail lint. */ }
-            });
-        }
         const kind = filename.startsWith(`${GLOBAL_COMPONENTS_FOLDER}/`) ? 'component' : 'page';
         const page = pageId(filename, text, program);
         const stats = { rule, checks: Object.fromEntries(checks.map(check => [check, 0])), kind, page, violations: 0, duration_ms: 0 };
@@ -42,3 +35,24 @@ export function startRuleStats(rule, checks, filename, text, program) {
         return undefined;
     }
 }
+/** The collected stats as rows: a page model's build, then each rule on each file and its checks that found problems. Only ids, counts and timings, never a message or a path. */
+export function recordStats(run) {
+    try {
+        for (const model of models) {
+            run.recordRow('step', 'build_page_model', { item_type: model.kind, item_id: model.page,
+                step_details: { components: model.components, css_files: model.css_files } }, {
+                success: !model.error_name, failure: model.error_name ? { error_name: model.error_name } : undefined, duration_ms: model.duration_ms,
+            });
+        }
+        for (const statsRow of rules) {
+            const row = run.recordRow('lint_rule', statsRow.rule, { item_type: statsRow.kind, item_id: statsRow.page, step_details: { violations: statsRow.violations } }, {
+                success: statsRow.violations === 0, duration_ms: statsRow.duration_ms,
+            });
+            for (const [check, violations] of Object.entries(statsRow.checks)) {
+                if (violations > 0)
+                    run.recordRow('lint_rule', statsRow.rule, { item_type: statsRow.kind, item_id: statsRow.page, step_details: { check, violations } }, { success: false, duration_ms: 0 }, row);
+            }
+        }
+    }
+    catch { /* Stats must never fail lint. */ }
+}

package/dist/lint.js

@@ -1,8 +1,6 @@
 #!/usr/bin/env node
 import { createWorkspaceRun, sendAndExit } from '@wix/origami-bi';
-import { readFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
+import { readFileSync } from 'node:fs';
 // Origami lint: runs the project rules on the site's own files, then lints the pages whose files changed since the last
 // passing run. See lint/README.md.
 import { getChangedFiles, markPassing } from "./history/index.js";
@@ -12,7 +10,7 @@ import { runProjectRules } from "./project-rules-runner/index.js";
 import { checkStartedAtSiteRoot, LINT_PACKAGE_FILE } from "./shared/paths.js";
 import { GLOBAL_COMPONENTS_FOLDER, THEME_FILE } from "./shared/site-files-tree-mapping.js";
 import { track, trackSync } from "./bi/names.js";
-import { readStats } from "./bi/read-stats.js";
+import { collectStats, recordStats } from "./bi/stats.js";
 const run = createWorkspaceRun({ command: 'yarn lint', toolVersion: JSON.parse(readFileSync(LINT_PACKAGE_FILE, 'utf8')).version });
 await run.trackCommand(async () => {
     run.commandRow.update({ step_details: { is_full: process.argv.includes('--full'), has_base: Boolean(process.env.ORIGAMI_LINT_BASE) } });
@@ -35,24 +33,15 @@ await run.trackCommand(async () => {
         row?.update({ step_details: { pages: pages.length - globals, global_components: globals, theme_changed: changedFiles.changed === null || changedFiles.changed.includes(THEME_FILE) } });
         return pages;
     });
-    const statsFile = run.enabled ? path.join(tmpdir(), `origami-lint-${run.id}.json`) : undefined;
-    const pagesPassed = trackSync('step', 'run_rules', { items_total: pagesToLint.length }, row => {
-        try {
-            const result = runRules(pagesToLint, statsFile);
-            if (statsFile)
-                readStats(statsFile, run);
-            row?.update({ step_details: { exit_code: result.exitCode, signal: result.signal, outcome: result.outcome } });
-            row?.end(result.passed);
-            return result.passed;
-        }
-        finally {
-            if (statsFile) {
-                try {
-                    rmSync(statsFile, { force: true });
-                }
-                catch { /* Stats must never fail lint. */ }
-            }
-        }
+    if (run.enabled)
+        collectStats();
+    const pagesPassed = await track('step', 'run_rules', { items_total: pagesToLint.length }, async (row) => {
+        const result = await runRules(pagesToLint);
+        if (run.enabled)
+            recordStats(run);
+        row?.update({ step_details: { outcome: result.outcome } });
+        row?.end(result.passed);
+        return result.passed;
     });
     const passed = projectPassed && pagesPassed;
     if (passed)

package/dist/page-model/read-structure.js

@@ -1,9 +1,9 @@
 // structure.jsx (or .tsx) → components. Every JSX element inside Structure is a component.
 // Only what the lint tool can't give a rule: each component's key and parentKey, to connect its CSS. The rest is in the tool's syntax tree.
-import { parseSync } from 'oxc-parser';
+import { parse } from '@typescript-eslint/parser';
 import { findDeclaration, isIdAttribute, getLiteralClassNames, getLiteralId, getNestingContext, createSourceReader, walk, emptyComponentCss } from "./utils.js";
-/** program: the same text's oxc syntax tree, when the lint tool already has it (oxlint's is the same shape); otherwise parsed here. */
-export function readStructure(jsxFile, text, program = parseSync(jsxFile, text).program) {
+/** program: the same text's syntax tree, when the lint tool already has it (ESLint's, from the same parser); otherwise parsed here. */
+export function readStructure(jsxFile, text, program = parse(text, { filePath: jsxFile, ecmaFeatures: { jsx: true }, range: true })) {
     const source = createSourceReader(text);
     const elements = findElements(program);
     return { components: toComponents(elements, assignKeys(elements, source), source) };
@@ -19,7 +19,7 @@ function findElements(program) {
         if (node.type !== 'JSXElement')
             return;
         const { parent, slot } = getNestingContext(ancestors);
-        const siblings = `${parent?.start}|${slot}`;
+        const siblings = `${parent?.range[0]}|${slot}`;
         const index = siblingCounts.get(siblings) ?? 0;
         siblingCounts.set(siblings, index + 1);
         elements.push({ node: node, parent, slot, index });
@@ -46,7 +46,7 @@ function toComponents(elements, keys, source) {
         const key = keys.get(node);
         components[key] = {
             key,
-            sourceStart: node.start,
+            sourceStart: node.range[0],
             id: getLiteralId(node),
             classNames: getLiteralClassNames(node),
             parentKey: parent ? keys.get(parent) : null,

package/dist/page-model/utils.js

@@ -1,6 +1,7 @@
 import { CSS_KINDS } from "./model.js";
 // ── syntax tree ──
-/** Calls visit(node, ancestors) for every node. Skips `parent`, which oxlint's syntax tree has (oxc-parser's doesn't). */
+const isAstNode = (value) => typeof value?.type === 'string';
+/** Calls visit(node, ancestors) for every node. Skips `parent`, which ESLint's syntax tree has (the parser's alone doesn't). */
 export function walk(node, ancestors, visit) {
     visit(node, ancestors);
     ancestors.push(node);
@@ -8,7 +9,7 @@ export function walk(node, ancestors, visit) {
         if (key === 'parent')
             continue;
         for (const child of Array.isArray(value) ? value : [value])
-            if (typeof child?.type === 'string')
+            if (isAstNode(child))
                 walk(child, ancestors, visit);
     }
     ancestors.pop();
@@ -68,8 +69,8 @@ export function createSourceReader(text) {
         return { line: line + 1, column: offset - lineStarts[line] };
     };
     return {
-        code: (node) => text.slice(node.start, node.end).replace(/\s+/g, ' ').trim(),
-        loc: (node) => ({ start: position(node.start), end: position(node.end) }),
+        code: (node) => text.slice(...node.range).replace(/\s+/g, ' ').trim(),
+        loc: (node) => ({ start: position(node.range[0]), end: position(node.range[1]) }),
     };
 }
 // ── CSS ──

package/dist/project-rules-runner/run-project-rules.js

@@ -1,7 +1,7 @@
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import { projectRuleRegistry } from "../rules/project/index.js";
-import { log } from "../shared/log.js";
+import { formatProblemLine, log } from "../shared/log.js";
 import { ROOT } from "../shared/paths.js";
 import { createProjectModel } from "../project-model/index.js";
 /** true when no error rule reported a problem, on the site of these files. Logs how many rules run, and whether they passed. */
@@ -38,9 +38,9 @@ export function runProjectRules(files, { rules = projectRuleRegistry, readFile =
     log(passed ? 'project rules passed' : 'project rules failed');
     return passed;
 }
-/** `file:line:1: error origami(name): message`, the shape oxlint prints the page rules' problems in. */
+/** `file:line:1: error origami(name): message`, the shape the page rules' problems print in. */
 export function formatProblem({ name, severity = 'error' }, { file, line = 1, message }) {
-    return `${file}:${line}:1: ${severity === 'error' ? 'error' : 'warning'} origami(${name}): ${message}`;
+    return formatProblemLine({ file, line, column: 1, severity: severity === 'error' ? 'error' : 'warning', rule: name, message });
 }
 function readFromSite(file) {
     try {

package/dist/rules/site-app/breakpoints.js

@@ -1,6 +1,6 @@
 import { describeAtRule, reportCssProblem } from "../../rules-api/index.js";
 import { defineRule } from "./define-rule.js";
-const CHECKS = ['malformed_custom_media', 'duplicate_breakpoint', 'unknown_breakpoint_name', 'changed_breakpoint_range', 'undeclared_breakpoint', 'unknown_breakpoint_range'];
+const CHECKS = ['malformed_custom_media', 'duplicate_breakpoint', 'unknown_breakpoint_name', 'changed_breakpoint_range', 'unknown_breakpoint_range'];
 /** The converter's shape for a declaration's name: a dashed identifier. */
 const DASHED_NAME = /^--[A-Za-z0-9_-]+$/;
 export default defineRule({
@@ -63,27 +63,27 @@ function keepsSiteRange(file, declaration, site, report) {
     reportCssProblem(report, file.name, declaration.line, 'changed_breakpoint_range', `\`@custom-media ${declaration.name} ${declaration.query}\` changes the site's range for ${declaration.name}, which is \`${exported}\`. Restore it; a breakpoint's width is changed in the editor, not in CSS.`);
     return false;
 }
-/** Reports a `@media (--name)` with no declaration of that name in the same file (CONV-breakpoints.ts:57). A malformed declaration of the name (its own line) counts as the declaration, so the use gets no second line. */
+/** Reports a `@media (--name)` whose name isn't one of the site's breakpoints (CONV-breakpoints.ts:150): the import reads the name from the site's
+ * breakpoints, so the file needs no `@custom-media` of its own. Nothing without a theme to compare with. A name the file declares is reported on its
+ * declaration (checkDeclarations), so the use gets no second line. */
 function checkNamedUses(file, site, report) {
+    if (!site.hasTheme)
+        return;
     const declared = new Set(file.declared.flatMap(({ name }) => [name, `--${name}`]));
     for (const { name, line } of file.used) {
-        if (!name || declared.has(name))
+        if (!name || declared.has(name) || getSiteRange(name, site) !== undefined)
             continue;
-        const range = getSiteRange(name, site);
-        const fix = range
-            ? `add \`@custom-media ${name} ${range};\` at the top of ${file.name}, or write the range itself, \`@media ${range}\``
-            : `add \`@custom-media ${name} (<its range>);\` at the top of ${file.name} (the range the site gives it), or write the range itself`;
-        reportCssProblem(report, file.name, line, 'undeclared_breakpoint', `\`@media (${name})\` uses a name the file doesn't declare: ${fix}.`);
+        reportCssProblem(report, file.name, line, 'unknown_breakpoint_name', `\`@media (${name})\` names a breakpoint the site doesn't have. Use one of the theme's breakpoints: ${describe(site.breakpoints)}.`);
     }
 }
-/** Reports each `@media` of a file whose range is none of the site's (P4-R01, CONV-breakpoints.ts:75); nothing without a theme to compare with. A name is read through the file's declaration when that declaration is the site's; otherwise the steps above report it. A component's own breakpoint (inside `@scope`) is compared once unmapped.json is read. */
+/** Reports each `@media` of a file whose range is none of the site's (P4-R01, CONV-breakpoints.ts:75); nothing without a theme to compare with. A name is read as the site's range for it; an unknown name is checkNamedUses'. A component's own breakpoint (inside `@scope`) is compared once unmapped.json is read. */
 function checkRanges(file, site, report) {
     if (!site.hasTheme)
         return;
     for (const media of file.used) {
         if (media.scope !== null)
             continue;
-        const query = resolve(media, file.declared, site);
+        const query = resolve(media, site);
         if (query === null || site.breakpoints.some((breakpoint) => canonical(breakpoint.query) === canonical(query)))
             continue;
         reportCssProblem(report, file.name, media.line, 'unknown_breakpoint_range', `\`${describeAtRule({ name: 'media', params: media.query })}\` is a breakpoint the site doesn't have. Write one of the theme's breakpoints: ${describe(site.breakpoints)}. The import refuses a value for a breakpoint the site doesn't have.`);
@@ -112,13 +112,11 @@ function getMedia(file, isPage, rulesApi) {
 const hasShape = ({ name, query }) => DASHED_NAME.test(name) && query !== '';
 /** The site's range for a name; undefined when the theme has no well-formed declaration of it. */
 const getSiteRange = (name, site) => site.breakpoints.find((breakpoint) => breakpoint.name === name)?.query;
-/** The range to compare: the @media's own; for `(--name)`, the range the file declares for it, when that declaration is the site's name with the site's range (otherwise the steps above report it); null when there is nothing to compare. */
-function resolve(media, declarations, site) {
+/** The range to compare: the @media's own; for `(--name)`, the site's range for that name, as the import reads it (an unknown name is checkNamedUses'); null when there is nothing to compare. */
+function resolve(media, site) {
     if (!media.name)
         return media.query;
-    const declaration = declarations.find((entry) => entry.name === media.name && hasShape(entry));
-    const exported = getSiteRange(media.name, site);
-    return declaration && exported !== undefined && exported.trim() === declaration.query.trim() ? declaration.query : null;
+    return getSiteRange(media.name, site) ?? null;
 }
 /** How the import reads a range: `(max-width:1023px)` and `(max-width: 1023px)` are the same; anything else, a different case or other spaces included, is another query. */
 const canonical = (query) => query.trim().replace(/:\s+/g, ':');

package/dist/rules/site-app/no-free-code.js

@@ -59,7 +59,7 @@ function isAllowedStatement({ node, rulesApi, report, context }) {
 }
 /** Skips a file with no root element (page-structure reports it) and a body that is TypeScript (hasNoTypeScript reports it). */
 function returnsElement({ node, rulesApi, report }) {
-    const body = unwrap(node.body);
+    const { body } = node;
     if (body.type === 'JSXElement' || rulesApi.isTypeScript(body) || !rulesApi.getRoot())
         return;
     report({ check: 'invalid_structure_declaration', loc: node.body.loc, message: STRUCTURE_SHAPE });
@@ -107,7 +107,6 @@ function isStructureArrow(node) {
     const statement = node.parent.parent?.parent;
     return statement?.type === 'ExportNamedDeclaration' && isAtTop(statement) && structureArrowOf(statement) === node;
 }
-const unwrap = (node) => (node.type === 'ParenthesizedExpression' ? node.expression : node);
 function shortCode(code) {
     const [line] = code.trim().split('\n');
     return line.length > 40 ? `${line.slice(0, 40)}…` : line;

package/dist/rules/site-app/page-structure.js

@@ -148,7 +148,7 @@ function isOutsideInternalContainers({ node, rulesApi, report }) {
         return;
     report({ check: 'landmark_inside_container', loc: getLoc(node, rulesApi), message: `The ${kind} ${describeElement(node, rulesApi)} is inside the internal container ${describeElement(container, rulesApi)}. Move it out of every internal container: the header and footer sit directly in the page or the master page.` });
 }
-/** Reports a wrapper that doesn't hold exactly one element: none, two, text, or a {…} (a comment too) beside it (CONV-parseJsx.ts:1028). */
+/** Reports a wrapper that doesn't hold exactly one element: none, two, text, or a {…} beside it; a comment is fine (CONV-parseJsx.ts:1028). */
 function holdsOneElement({ node, rulesApi, report }) {
     if (holdsOne(node))
         return;
@@ -161,13 +161,13 @@ function checkNoRemoveInRemove({ node, rulesApi, report }) {
         return;
     report({ check: 'nested_remove', loc: node.openingElement.name.loc, message: `<${rulesApi.getTagName(node)}> is inside another <Remove>. <Remove> wraps the component itself: merge the two conditions into one <Remove>.` });
 }
-/** Reports text, a {…} (a comment too), a fragment or a spread between a component's tags (CONV-parseJsx.ts:1668). The root steps report those in <Page> and its sections, except comments, which they don't see. */
+/** Reports text, a {…}, a fragment or a spread between a component's tags (CONV-parseJsx.ts:1668). A comment is fine, as whitespace is: the import
+ * skips both (it reads a `@name` comment as the component's name). The root steps report the rest in <Page> and its sections. */
 function hasOnlyElements({ node, rulesApi, report }) {
-    const commentsOnly = isRootTreeHolder(node, rulesApi);
+    if (isRootTreeHolder(node, rulesApi))
+        return;
     for (const child of node.children) {
-        if (child.type === 'JSXElement' || (child.type === 'JSXText' && child.value.trim() === ''))
-            continue;
-        if (commentsOnly && !isComment(child))
+        if (child.type === 'JSXElement' || isFiller(child))
             continue;
         report({ check: 'non_element_child', loc: child.type === 'JSXText' ? getTextLoc(child) : child.loc, message: `${describeElement(node, rulesApi)} has text or {…} as a child. Put the value in an attribute: only elements go between the tags.` });
     }
@@ -283,13 +283,13 @@ function isRootTreeHolder(holder, rulesApi) {
 }
 /** Whether the element is one of the holder's children (through wrappers), not something passed in one of its attributes. */
 const isStructuralChild = (holder, element, rulesApi) => getStructuralChildren(holder, rulesApi).includes(element);
-/** A wrapper holds exactly one element: non-blank text, a {…} (a comment too), a fragment count as what it holds. */
+/** A wrapper holds exactly one element: non-blank text, a {…} and a fragment count as what it holds; whitespace and comments don't. */
 const holdsOne = (wrapper) => {
-    const inside = wrapper.children.filter((child) => child.type !== 'JSXText' || child.value.trim() !== '');
+    const inside = wrapper.children.filter((child) => !isFiller(child));
     return inside.length === 1 && inside[0].type === 'JSXElement';
 };
-/** A JSX comment: an expression container with nothing in it. */
-const isComment = (child) => child.type === 'JSXExpressionContainer' && child.expression.type === 'JSXEmptyExpression';
+/** What the import skips between tags: whitespace, and a JSX comment (an expression container with nothing in it). */
+const isFiller = (child) => (child.type === 'JSXText' && child.value.trim() === '') || (child.type === 'JSXExpressionContainer' && child.expression.type === 'JSXEmptyExpression');
 /** `backgroundLayer={[<Background … />]}`: an array literal whose every entry is an element. */
 function isArrayOfElements(attribute) {
     const { value } = attribute;

package/dist/rules/site-app/theme-font-ids.js

@@ -2,7 +2,7 @@
 // from the Wix font catalog in @wix/origami-fonts: no quotes, commas or fallbacks, the same case. The editor reads that
 // family as one Wix font id. The import keeps any family as written (an unknown id, a quoted one, a list, another case),
 // so this is a warning. A legacy font is in the catalog, and the import takes it. A `var(…)` token is left alone.
-// theme.css isn't a file oxlint lints, so the rule runs on each linted page (a theme change lints every page) and
+// theme.css isn't a file ESLint lints, so the rule runs on each linted page (a theme change lints every page) and
 // marks the page's start; the message names the token's line in theme.css.
 import { CATALOG_FONTS, readFontShorthand, reportCssProblem } from "../../rules-api/index.js";
 import { defineRule } from "./define-rule.js";

package/dist/rules-adapter/{oxlint → eslint}/adapt-rule.js

@@ -1,21 +1,22 @@
-// An origami rule as an oxlint rule: its callbacks are oxlint's, so the adapter only adds what every callback gets.
+// An origami rule as an ESLint rule: its callbacks are ESLint's, so the adapter only adds what every callback gets.
 import path from 'node:path';
 import { startRuleStats } from "../../bi/stats.js";
 import { getOrCreateRulesApi } from "../../rules-api/index.js";
 import { createReport, createToolCallbacks } from "../utils.js";
-export function toOxlintRule(rule) {
+export function toEslintRule(rule) {
     return {
-        meta: { type: 'problem' },
-        // oxlint calls this once per rule per file. The file's rules API is shared by every rule (getOrCreateRulesApi caches it).
+        // ESLint reports by message id: one message, the rule's own text as its data.
+        meta: { type: 'problem', schema: [], messages: { problem: '{{message}}' } },
+        defaultOptions: [],
+        // ESLint calls this once per rule per file. The file's rules API is shared by every rule (getOrCreateRulesApi caches it).
         create: (context) => {
             const stats = startRuleStats(rule.name, rule.checks, path.relative(context.cwd, context.filename), context.sourceCode.text, context.sourceCode.ast);
-            const report = createReport((problem) => context.report(problem), stats);
+            const report = createReport((problem) => context.report({ messageId: 'problem', data: { message: problem.message }, loc: problem.loc }), stats);
             return createToolCallbacks(rule, { rulesApi: () => getOrCreateRulesApi(toLintedFile(context)), report, context, stats });
         },
     };
 }
-/** oxlint already parsed the file: its syntax tree is reused instead of parsing it again. */
+/** ESLint already parsed the file: its syntax tree is reused instead of parsing it again. */
 function toLintedFile({ cwd, filename, sourceCode }) {
-    // oxlint's tree is oxc-parser's (oxlint runs on oxc), plus `parent`, `range` and `loc`. Their types are declared apart.
     return { cwd, filename, text: sourceCode.text, program: sourceCode.ast };
 }

package/dist/rules-adapter/{oxlint/oxlint-plugin.js → eslint/eslint-plugin.js}

@@ -1,7 +1,7 @@
-// The plugin oxlint loads when it starts: every rule as an oxlint rule.
+// The plugin run-rules.ts gives ESLint: every rule as an ESLint rule.
 import { ruleRegistry } from "../../rules/index.js";
-import { toOxlintRule } from "./adapt-rule.js";
+import { toEslintRule } from "./adapt-rule.js";
 export default {
     meta: { name: 'origami' },
-    rules: Object.fromEntries(ruleRegistry.map((rule) => [rule.name, toOxlintRule(rule)])),
+    rules: Object.fromEntries(ruleRegistry.map((rule) => [rule.name, toEslintRule(rule)])),
 };

package/dist/rules-adapter/eslint/run-rules.js

@@ -0,0 +1,60 @@
+// Runs the rules with ESLint, in this process, on the pages' structure files: the plugin (eslint-plugin.ts) on a config
+// built here, never the site's own ESLint config.
+import path from 'node:path';
+import * as parser from '@typescript-eslint/parser';
+import { ESLint } from 'eslint';
+import { ruleRegistry } from "../../rules/index.js";
+import { formatProblemLine, log } from "../../shared/log.js";
+import { ROOT } from "../../shared/paths.js";
+import plugin from "./eslint-plugin.js";
+/** Each rule on at its own severity. Warnings don't fail the lint. */
+export const ruleSeverities = (rules) => Object.fromEntries(rules.map(({ name, severity = 'error' }) => [`origami/${name}`, severity]));
+/** How ESLint reads a structure file: typescript-eslint's parser reads .jsx and .tsx alike; its tree is the one the rules' types are. */
+export const STRUCTURE_FILES = {
+    files: ['**/*.jsx', '**/*.tsx'],
+    languageOptions: { parser, parserOptions: { ecmaFeatures: { jsx: true } } },
+    // An `eslint-disable` comment the site has for its own tools isn't a problem of the page.
+    linterOptions: { reportUnusedDisableDirectives: 'off' },
+};
+/** Every rule, on the structure files. */
+export const CONFIG = [{
+        ...STRUCTURE_FILES,
+        plugins: { origami: plugin },
+        rules: ruleSeverities(ruleRegistry),
+    }];
+/** jsxFiles: the pages' structure files, from the site root. Each problem printed as one line; passed when there was nothing to lint, or no error. */
+export async function runRules(jsxFiles) {
+    const result = await runEslint(jsxFiles);
+    log(result.passed ? 'rules passed' : 'rules failed');
+    return result;
+}
+async function runEslint(files) {
+    if (files.length === 0)
+        return { passed: true, outcome: 'no_files' };
+    let results;
+    try {
+        results = await lintStructureFiles(files);
+    }
+    catch (error) {
+        // A rule that couldn't finish fails the run, like a project rule.
+        console.log(formatProblemLine({ file: '.', line: 1, column: 1, severity: 'error', message: `the page rules couldn't finish, so this run can't pass: ${error instanceof Error ? error.message : String(error)}` }));
+        return { passed: false, outcome: 'plugin_crash' };
+    }
+    for (const line of results.flatMap((result) => toProblemLines(result)))
+        console.log(line);
+    const passed = results.every((result) => result.errorCount === 0);
+    return { passed, outcome: passed ? 'passed' : 'violations' };
+}
+/** Every rule on these structure files (paths from cwd, the site root): ESLint's results, nothing printed. */
+export function lintStructureFiles(files, cwd = ROOT) {
+    // ignore: false, so a page in a folder ESLint skips by default is linted too: these are the files to lint.
+    return new ESLint({ cwd, overrideConfigFile: true, overrideConfig: CONFIG, ignore: false }).lintFiles(files);
+}
+/** A file's problems as lines, from the site root. A parse error has no rule, and only its own text. */
+export function toProblemLines({ filePath, messages }, cwd = ROOT) {
+    const file = path.relative(cwd, filePath).split(path.sep).join('/');
+    return messages.map(({ line, column, severity, ruleId, message }) => formatProblemLine({
+        file, line, column, severity: severity === 2 ? 'error' : 'warning',
+        rule: ruleId?.replace(/^origami\//, ''), message: ruleId ? message : message.replace(/^Parsing error: /, ''),
+    }));
+}

package/dist/rules-adapter/index.js

@@ -1,3 +1,3 @@
-// Part 5 — rules adapter: runs the rules inside a lint tool (oxlint today). Everything that knows oxlint is in oxlint/.
-export { runRules } from "./oxlint/run-rules.js";
+// Part 5 — rules adapter: runs the rules inside a lint tool (ESLint today). Everything that knows ESLint is in eslint/.
+export { runRules } from "./eslint/run-rules.js";
 export { createReport, createToolCallbacks } from "./utils.js";

package/dist/rules-adapter/utils.js

@@ -1,4 +1,4 @@
-/** The report a rule gets on a file: a violation found from both sides (parent and child) is reported once. Neither oxlint nor ESLint does that. */
+/** The report a rule gets on a file: a violation found from both sides (parent and child) is reported once. ESLint doesn't do that. */
 export function createReport(send, stats) {
     const reported = new Set();
     return (problem) => {

package/dist/rules-api/rules-api.js

@@ -3,7 +3,7 @@
 // One per file, shared by every rule on it. Only building its page reads from disk, once per file.
 import path from 'node:path';
 import { GLOBAL_COMPONENTS_FOLDER } from "../shared/site-files-tree-mapping.js";
-import { models, pageId } from "../bi/stats.js";
+import { isCollectingStats, models, pageId } from "../bi/stats.js";
 import { readPage } from "../page-model/index.js";
 import { getAttributeElements as getHeldElements, getAttributeValue, getChildren, getId, getImport, getImportKind, getImportedName, getPropNames, getSlot, getTagName, getType, hasDataAttributes, isTypeScript } from "../shared/utils.js";
 import { CONTENT_TARGET, readBreakpointName, readCustomMedia, readThemeFontTokens, readThemeTokens } from "../shared/css.js";
@@ -78,7 +78,7 @@ export function getOrCreateRulesApi(file) {
             throw error;
         }
         finally {
-            if (process.env.ORIGAMI_LINT_STATS) {
+            if (isCollectingStats()) {
                 try {
                     const kind = getRelativeJsxPath(file).startsWith(`${GLOBAL_COMPONENTS_FOLDER}/`) ? 'component' : 'page';
                     models.push({ kind, page: pageId(getRelativeJsxPath(file), file.text, file.program), duration_ms: performance.now() - started,

package/dist/shared/log.js

@@ -2,3 +2,7 @@
 export function log(message) {
     console.log(`origami-lint [${Math.round(performance.now())} ms]: ${message}`);
 }
+/** `file:line:column: error origami(rule): message`, or `file:line:column: error: message` without a rule: one line per problem, the shape agents read. */
+export function formatProblemLine({ file, line, column, severity, rule, message }) {
+    return `${file}:${line}:${column}: ${severity}${rule ? ` origami(${rule})` : ''}: ${message}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/origami-lint",
-  "version": "1.34.34",
+  "version": "1.34.36",
   "description": "Offline lint for an exported Origami site: lints the pages that changed since the last passing run",
   "type": "module",
   "bin": {
@@ -12,7 +12,7 @@
     "!**/*.tsbuildinfo"
   ],
   "engines": {
-    "node": "^20.19.0 || >=22.12.0"
+    "node": "^20.19.0 || ^22.13.0 || >=24"
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p . && tsc -p tsconfig.build.json",
@@ -21,15 +21,17 @@
     "test": "node --test 'test/*.test.ts'"
   },
   "dependencies": {
+    "@typescript-eslint/parser": "^8.71.2",
     "@wix/origami-fonts": "1.0.4",
-    "oxc-parser": "^0.151.0",
-    "oxlint": "^1.39.0",
+    "eslint": "^10.12.0",
     "postcss": "^8.5.3",
+    "typescript": "^5.8.3 || ~6.0.3",
     "@wix/origami-bi": "0.14.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
-    "typescript": "^6.0.3"
+    "@typescript-eslint/utils": "^8.71.2",
+    "oxlint": "^1.39.0"
   },
   "publishUnscoped": false,
   "publishConfig": {
@@ -52,5 +54,5 @@
       ]
     }
   },
-  "falconPackageHash": "d2fc846c66230255172ea8b452324a680831c63bbcceadf13d577ad9"
+  "falconPackageHash": "5ed1f78b0c887661ab15c42ac1bb33758bdc0b4f1afd67d94b64c989"
 }

package/dist/bi/read-stats.js

@@ -1,34 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { ruleRegistry } from "../rules/index.js";
-/** Best-effort transport, explicitly projecting the plugin's data so messages and paths cannot ride along. */
-export function readStats(file, run) {
-    try {
-        const stats = JSON.parse(readFileSync(file, 'utf8'));
-        const validPage = (page) => page === undefined || typeof page === 'string' && /^[\w-]+$/.test(page);
-        const validKind = (kind) => kind === 'page' || kind === 'component';
-        const count = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0;
-        if (!Array.isArray(stats.rules) || !Array.isArray(stats.models)
-            || !stats.rules.every(s => s && ruleRegistry.some(rule => rule.name === s.rule && s.checks && typeof s.checks === 'object' && !Array.isArray(s.checks)
-                && Object.keys(s.checks).length === rule.checks.length && rule.checks.every(check => Object.hasOwn(s.checks, check))
-                && Object.values(s.checks).every(value => Number.isSafeInteger(value) && value >= 0)
-                && Object.values(s.checks).reduce((total, value) => total + value, 0) === s.violations) && validPage(s.page) && validKind(s.kind) && Number.isSafeInteger(s.violations) && s.violations >= 0 && count(s.duration_ms))
-            || !stats.models.every(s => s && validPage(s.page) && validKind(s.kind) && count(s.duration_ms) && count(s.components) && count(s.css_files) && (s.error_name === undefined || s.error_name === 'css_syntax_error' || s.error_name === 'unknown_error')))
-            return;
-        for (const model of stats.models) {
-            run.recordRow('step', 'build_page_model', { item_type: model.kind, item_id: model.page,
-                step_details: { components: model.components, css_files: model.css_files } }, {
-                success: !model.error_name, failure: model.error_name ? { error_name: model.error_name } : undefined, duration_ms: model.duration_ms,
-            });
-        }
-        for (const statsRow of stats.rules) {
-            const row = run.recordRow('lint_rule', statsRow.rule, { item_type: statsRow.kind, item_id: statsRow.page, step_details: { violations: statsRow.violations } }, {
-                success: statsRow.violations === 0, duration_ms: statsRow.duration_ms,
-            });
-            for (const [check, violations] of Object.entries(statsRow.checks)) {
-                if (violations > 0)
-                    run.recordRow('lint_rule', statsRow.rule, { item_type: statsRow.kind, item_id: statsRow.page, step_details: { check, violations } }, { success: false, duration_ms: 0 }, row);
-            }
-        }
-    }
-    catch { /* Missing, truncated or malformed stats never affect lint. */ }
-}

package/dist/rules-adapter/oxlint/origami-rules.config.js

@@ -1,12 +0,0 @@
-// Passed to oxlint with -c by run-rules.ts. Not named oxlint.config.ts, so `oxlint .` in the origami repo does not load it as a nested config.
-import path from 'node:path';
-import { defineConfig } from 'oxlint';
-import { ruleRegistry } from "../../rules/index.js";
-/** Each rule on at its own severity. oxlint exits 0 when it finds only warnings, so warnings don't fail the lint. */
-export const ruleSeverities = (rules) => Object.fromEntries(rules.map(({ name, severity = 'error' }) => [`origami/${name}`, severity]));
-export default defineConfig({
-    // .ts in the origami repo, .js once built: the build rewrites imports, not this path.
-    jsPlugins: [path.join(import.meta.dirname, `oxlint-plugin${path.extname(import.meta.filename)}`)],
-    categories: { correctness: 'off' },
-    rules: ruleSeverities(ruleRegistry),
-});

package/dist/rules-adapter/oxlint/run-rules.js

@@ -1,28 +0,0 @@
-// Runs the rules with oxlint on the pages' structure files. Its config loads the rules (through oxlint-plugin.ts).
-import { spawnSync } from 'node:child_process';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { log } from "../../shared/log.js";
-import { ROOT } from "../../shared/paths.js";
-// oxlint is the lint's own dependency: found from here, wherever the package manager installed it.
-const OXLINT_BIN = path.join(path.dirname(createRequire(import.meta.url).resolve('oxlint/package.json')), 'bin/oxlint');
-// .ts in the origami repo, .js once built.
-const OXLINT_CONFIG = path.join(import.meta.dirname, `origami-rules.config${path.extname(import.meta.filename)}`);
-/** jsxFiles: the pages' structure files, from the site root. true when there was nothing to lint, or oxlint found no errors. */
-export function runRules(jsxFiles, statsFile) {
-    const result = runOxlint(jsxFiles, statsFile);
-    log(result.passed ? 'rules passed' : 'rules failed');
-    return result;
-}
-function runOxlint(files, statsFile) {
-    if (files.length === 0) {
-        return { passed: true, exitCode: null, signal: null, outcome: 'no_files' };
-    }
-    const env = { ...process.env };
-    delete env.ORIGAMI_LINT_STATS;
-    if (statsFile)
-        env.ORIGAMI_LINT_STATS = statsFile;
-    const result = spawnSync(process.execPath, [OXLINT_BIN, '-c', OXLINT_CONFIG, ...files], { cwd: ROOT, stdio: 'inherit', env });
-    return { passed: result.status === 0, exitCode: result.status, signal: result.signal,
-        outcome: result.status === 0 ? 'passed' : result.status === 1 ? 'violations' : 'plugin_crash' };
-}