@wix/origami-lint 1.34.19 → 1.34.21

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

@@ -1,5 +1,6 @@
 import { STRUCTURE } from "../../rules-api/index.js";
 import { defineRule } from "./define-rule.js";
+const CHECKS = ['invalid_structure_declaration', 'free_code_outside_structure', 'typescript_syntax'];
 const FREE_CODE = 'The import refuses this statement: a structure file holds only imports, `const` / `let` / `var` declarations and `export const Structure = () => …` (tracker CONV-parseJsx.ts:287).';
 const STRUCTURE_SHAPE = 'Declare Structure once, as `export const Structure = () => ( <Page …/> )`: an exported const arrow that returns the root element directly, with no `{ return … }`, fragment or condition around it (tracker CONV-parseJsx.ts:335).';
 const typeScript = (code) => `\`${code}\` is TypeScript. The import reads a structure file as plain JavaScript and fails on it: remove it (tracker CONV-parseJsx.ts:1845).`;
@@ -21,6 +22,7 @@ const TYPESCRIPT = [
 ];
 export default defineRule({
     name: 'no-free-code',
+    checks: CHECKS,
     editors: 'all',
     callbacks: {
         ...on(STATEMENTS, isAllowedStatement),
@@ -48,19 +50,19 @@ function isAllowedStatement({ node, rulesApi, report, context }) {
         return;
     if (declaresStructure(node)) {
         if (!structureArrowOf(node))
-            report({ loc: node.loc, message: STRUCTURE_SHAPE });
+            report({ check: 'invalid_structure_declaration', loc: node.loc, message: STRUCTURE_SHAPE });
         return;
     }
     // The import drops every variable declaration before it checks the statements (parseJsx.ts rejectTopLevelStatements).
     if (declaration?.type !== 'VariableDeclaration')
-        report({ loc: node.loc, message: FREE_CODE });
+        report({ check: 'free_code_outside_structure', loc: node.loc, message: FREE_CODE });
 }
 /** 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);
     if (body.type === 'JSXElement' || rulesApi.isTypeScript(body) || !rulesApi.getRoot())
         return;
-    report({ loc: node.body.loc, message: STRUCTURE_SHAPE });
+    report({ check: 'invalid_structure_declaration', loc: node.body.loc, message: STRUCTURE_SHAPE });
 }
 /** In a structure.jsx it doesn't parse; this is for a structure.tsx, which the import parses as JavaScript too. */
 function hasNoTypeScript({ node, rulesApi, report, context }) {
@@ -68,7 +70,7 @@ function hasNoTypeScript({ node, rulesApi, report, context }) {
         reportTypeScript(node, report, context);
 }
 function reportTypeScript(node, report, context) {
-    report({ loc: node.loc, message: typeScript(shortCode(context.sourceCode.getText(node))) });
+    report({ check: 'typescript_syntax', loc: node.loc, message: typeScript(shortCode(context.sourceCode.getText(node))) });
 }
 // ── reading the code ──
 function on(names, check) {

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

@@ -22,8 +22,10 @@
 import { FILE_START } from "../../page-model/index.js";
 import { LAYER_ATTRIBUTES, SECTIONS, WRAPPERS } from "../../rules-api/index.js";
 import { defineRule } from "./define-rule.js";
+const CHECKS = ['missing_root', 'invalid_global_root', 'missing_root_id', 'invalid_page_root', 'non_element_child', 'invalid_section_container', 'nested_page', 'landmark_inside_container', 'invalid_wrapper_children', 'nested_remove', 'invalid_element_array', 'invalid_landmark_section'];
 export default defineRule({
     name: 'page-structure',
+    checks: CHECKS,
     editors: 'all',
     callbacks: {
         Program: (input) => hasRoot(input),
@@ -64,9 +66,9 @@ function hasRoot({ rulesApi, report }) {
     if (rulesApi.getRoot())
         return;
     if (rulesApi.page.kind === 'page')
-        report({ loc: FILE_START, message: 'A page must start with <Page>, found nothing.' });
+        report({ check: 'missing_root', loc: FILE_START, message: 'A page must start with <Page>, found nothing.' });
     else
-        report({ loc: FILE_START, message: 'A global component must start with a section (HeaderSection, FooterSection or Section), found nothing (tracker CONV-runValidation.ts:9).' });
+        report({ check: 'missing_root', loc: FILE_START, message: 'A global component must start with a section (HeaderSection, FooterSection or Section), found nothing (tracker CONV-runValidation.ts:9).' });
 }
 /** On a global component, reports a top element that isn't a section (P1-R13); the steps after it are for a section. */
 function isSectionAtTop({ node, rulesApi, report }) {
@@ -75,7 +77,7 @@ function isSectionAtTop({ node, rulesApi, report }) {
     const type = rulesApi.getType(node);
     if (isLandmark(node, rulesApi) || (type && SECTIONS.includes(type)))
         return true;
-    report({ loc: getLoc(node, rulesApi), message: `${describeElement(node, rulesApi)} sits directly in the master page. A global component's top element is a section (HeaderSection, FooterSection or Section); put it inside one (rule P1-R13).` });
+    report({ check: 'invalid_global_root', loc: getLoc(node, rulesApi), message: `${describeElement(node, rulesApi)} sits directly in the master page. A global component's top element is a section (HeaderSection, FooterSection or Section); put it inside one (rule P1-R13).` });
     return false;
 }
 /** Reports a root element with no string id (CONV-runValidation.ts:9). The tree steps go on: the import reports them all in one run. */
@@ -88,13 +90,13 @@ function rootHasId({ node, rulesApi, report }) {
         && attribute.value.expression.name === 'id') && receivesInstanceId(node))
         return;
     const tag = rulesApi.getTagName(node);
-    report({ loc: getLoc(node, rulesApi), message: `<${tag}> at the top has no id. Give the root element its id, like \`<${tag} id="c1dmp">\` (tracker CONV-runValidation.ts:9).` });
+    report({ check: 'missing_root_id', loc: getLoc(node, rulesApi), message: `<${tag}> at the top has no id. Give the root element its id, like \`<${tag} id="c1dmp">\` (tracker CONV-runValidation.ts:9).` });
 }
 /** Reports a page's root that isn't <Page>. */
 function startsWithPage({ node, rulesApi, report }) {
     if (rulesApi.getType(node) === 'page')
         return true;
-    report({ loc: getLoc(node, rulesApi), message: `A page must start with <Page>, found ${describe(node, rulesApi)}.` });
+    report({ check: 'invalid_page_root', loc: getLoc(node, rulesApi), message: `A page must start with <Page>, found ${describe(node, rulesApi)}.` });
     return false;
 }
 /** Reports text and {…} directly in <Page> (CONV-parseJsx.ts:1668). Any component is accepted there: a section, the page's <Background>, a pinned element, as the import accepts it. */
@@ -102,7 +104,7 @@ function checkPageChildren({ node: page, rulesApi, report }) {
     for (const child of getStructuralChildren(page, rulesApi)) {
         if (child.type === 'JSXElement')
             continue;
-        report({ loc: getLoc(page, rulesApi), message: `<Page> has ${describe(child, rulesApi)} as a child. Only elements go directly inside <Page>: a section, or a component pinned to the page (tracker CONV-parseJsx.ts:1668).` });
+        report({ check: 'non_element_child', loc: getLoc(page, rulesApi), message: `<Page> has ${describe(child, rulesApi)} as a child. Only elements go directly inside <Page>: a section, or a component pinned to the page (tracker CONV-parseJsx.ts:1668).` });
     }
 }
 /** Reports a section, anywhere in the file, that doesn't hold exactly one <InternalContainer>, and nothing else (S2-SECTION-001, OUR-001). A wrapper in it
@@ -115,7 +117,7 @@ function hasOneInternalContainer(section, { rulesApi, report }) {
     if (inside.length === 1 && inside[0].type === 'JSXElement' && rulesApi.getType(inside[0]) === 'innerElement')
         return;
     const name = rulesApi.getId(section) ?? `<${rulesApi.getTagName(section)}>`;
-    report({ loc: getLoc(section, rulesApi), message: `Section ${name} must contain exactly one <InternalContainer>, found: ${inside.map((child) => describe(child, rulesApi)).join(', ') || 'nothing'}. Put the section's content inside its one <InternalContainer> (rule S2-SECTION-001).` });
+    report({ check: 'invalid_section_container', loc: getLoc(section, rulesApi), message: `Section ${name} must contain exactly one <InternalContainer>, found: ${inside.map((child) => describe(child, rulesApi)).join(', ') || 'nothing'}. Put the section's content inside its one <InternalContainer> (rule S2-SECTION-001).` });
 }
 /** Reports a <Page> held by another element (P1-R16), unless the root steps above report that placement already (a section's children). */
 function isNotNestedPage({ node, rulesApi, report }) {
@@ -124,7 +126,7 @@ function isNotNestedPage({ node, rulesApi, report }) {
     const holder = getHolder(node, rulesApi);
     if (!holder || (rulesApi.getType(holder) !== 'page' && isRootTreeHolder(holder, rulesApi) && isStructuralChild(holder, node, rulesApi)))
         return;
-    report({ loc: getLoc(node, rulesApi), message: `${describeElement(node, rulesApi)} is inside ${describeElement(holder, rulesApi)}. A page is only the top element of its own page (rule P1-R16).` });
+    report({ check: 'nested_page', loc: getLoc(node, rulesApi), message: `${describeElement(node, rulesApi)} is inside ${describeElement(holder, rulesApi)}. A page is only the top element of its own page (rule P1-R16).` });
 }
 /** Reports a header or footer, or a page's reference to the global one, with an <InternalContainer> among its ancestors (P1-R03). */
 function isOutsideInternalContainers({ node, rulesApi, report }) {
@@ -134,20 +136,20 @@ function isOutsideInternalContainers({ node, rulesApi, report }) {
     const container = getAncestors(node).find((ancestor) => rulesApi.getType(ancestor) === 'innerElement');
     if (!container)
         return;
-    report({ 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 (rule P1-R03).` });
+    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 (rule P1-R03).` });
 }
 /** Reports a wrapper that doesn't hold exactly one element: none, two, text, or a {…} (a comment too) beside it (CONV-parseJsx.ts:1028). */
 function holdsOneElement({ node, rulesApi, report }) {
     if (holdsOne(node))
         return;
-    report({ loc: node.openingElement.name.loc, message: `<${rulesApi.getTagName(node)}> wraps exactly one component element: give each component its own wrapper (tracker CONV-parseJsx.ts:1028).` });
+    report({ check: 'invalid_wrapper_children', loc: node.openingElement.name.loc, message: `<${rulesApi.getTagName(node)}> wraps exactly one component element: give each component its own wrapper (tracker CONV-parseJsx.ts:1028).` });
 }
 /** Reports a <Remove> right inside another <Remove> (CONV-parseJsx.ts:1237): <Remove> wraps the component itself, so nothing nests in it. Compared with the element right around it, as the import does. */
 function checkNoRemoveInRemove({ node, rulesApi, report }) {
     const outer = getAncestors(node)[0];
     if (!outer || rulesApi.getType(outer) !== 'remove')
         return;
-    report({ 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> (tracker CONV-parseJsx.ts:1237).` });
+    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> (tracker CONV-parseJsx.ts:1237).` });
 }
 /** 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. */
 function hasOnlyElements({ node, rulesApi, report }) {
@@ -157,7 +159,7 @@ function hasOnlyElements({ node, rulesApi, report }) {
             continue;
         if (commentsOnly && !isComment(child))
             continue;
-        report({ 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 (tracker CONV-parseJsx.ts:1668).` });
+        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 (tracker CONV-parseJsx.ts:1668).` });
     }
 }
 /** Reports an <InternalContainer>'s backgroundLayer / pinnedLayer that isn't an array literal of elements (CONV-parseJsx.ts:1630). */
@@ -169,7 +171,7 @@ function hasLayerArrays({ node, rulesApi, report }) {
             continue;
         if (isArrayOfElements(attribute))
             continue;
-        report({ loc: attribute.loc, message: `${describeElement(node, rulesApi)}'s ${attribute.name.name} must be an array of elements: ${attribute.name.name}={[<… />]} (tracker CONV-parseJsx.ts:1630).` });
+        report({ check: 'invalid_element_array', loc: attribute.loc, message: `${describeElement(node, rulesApi)}'s ${attribute.name.name} must be an array of elements: ${attribute.name.name}={[<… />]} (tracker CONV-parseJsx.ts:1630).` });
     }
 }
 // ── reading the tree ──
@@ -265,7 +267,7 @@ function hasSectionInLandmark(input) {
     const children = getStructuralChildren(node, rulesApi);
     if (children.length === 1 && children[0].type === 'JSXElement' && rulesApi.getType(children[0]) === expected)
         return;
-    report({ loc: getLoc(node, rulesApi), message: `<${rulesApi.getTagName(node)}> must contain exactly one ${expected === 'header' ? 'HeaderSection' : 'FooterSection'}.` });
+    report({ check: 'invalid_landmark_section', loc: getLoc(node, rulesApi), message: `<${rulesApi.getTagName(node)}> must contain exactly one ${expected === 'header' ? 'HeaderSection' : 'FooterSection'}.` });
 }
 function receivesInstanceId(node) {
     for (let parent = node.parent; parent; parent = parent.parent) {

package/dist/rules/site-app/slot-attributes.js

@@ -7,8 +7,10 @@
 // Children are the element children and the layer elements (backgroundLayer, pinnedLayer); <Remove> and <Interaction> are transparent.
 import { LAYER_ATTRIBUTES, WRAPPERS } from "../../rules-api/index.js";
 import { defineRule } from "./define-rule.js";
+const CHECKS = ['root_has_slot', 'attribute_child_has_slot', 'mixed_slot_forms', 'duplicate_slot'];
 export default defineRule({
     name: 'slot-attributes',
+    checks: CHECKS,
     editors: ['studio2'],
     callbacks: {
         JSXElement: (input) => {
@@ -28,7 +30,7 @@ function rootHasNoSlot({ node, rulesApi, report }) {
     const slot = rulesApi.getSlot(node);
     if (slot === null || !isRoot(node, rulesApi))
         return;
-    report({ loc: getLoc(node, rulesApi), message: `The root ${describe(node, rulesApi)} can't have a slot attribute. Remove slot="${slot}" (tracker CONV-fromBundle.ts:1312).` });
+    report({ check: 'root_has_slot', loc: getLoc(node, rulesApi), message: `The root ${describe(node, rulesApi)} can't have a slot attribute. Remove slot="${slot}" (tracker CONV-fromBundle.ts:1312).` });
 }
 /** The root element: the top of Structure, or the element a <Remove> / <Interaction> at the top holds (the page model makes that wrapper the root). */
 function isRoot(node, rulesApi) {
@@ -46,7 +48,7 @@ function attributeElementHasNoSlot(element, attribute, { rulesApi, report }) {
     const name = getAttributeName(attribute);
     if (LAYER_ATTRIBUTES.includes(name) || rulesApi.getSlot(element) === null)
         return;
-    report({ loc: getLoc(element, rulesApi), message: `${describe(element, rulesApi)} is placed in the attribute '${name}' and also has slot="${rulesApi.getSlot(element)}". Remove slot=: its place is the attribute (tracker CONV-parseJsx.ts:1507).` });
+    report({ check: 'attribute_child_has_slot', loc: getLoc(element, rulesApi), message: `${describe(element, rulesApi)} is placed in the attribute '${name}' and also has slot="${rulesApi.getSlot(element)}". Remove slot=: its place is the attribute (tracker CONV-parseJsx.ts:1507).` });
 }
 /** Reports an owner that holds elements in its attributes and also has a child with slot=, or an elementProps entry with slots: {…} (CONV-parseJsx.ts:1693). */
 function usesSlotsOnlyOneWay({ node, rulesApi, report }) {
@@ -54,7 +56,7 @@ function usesSlotsOnlyOneWay({ node, rulesApi, report }) {
         return;
     if (!getSlottedChildren(node, rulesApi).length && !hasEntrySlots(node))
         return;
-    report({ loc: getLoc(node, rulesApi), message: `${describe(node, rulesApi)} places slotted children both in attributes and with slot= (or slots: {…}). Use one way: elements in attributes, or children with slot= (tracker CONV-parseJsx.ts:1693).` });
+    report({ check: 'mixed_slot_forms', loc: getLoc(node, rulesApi), message: `${describe(node, rulesApi)} places slotted children both in attributes and with slot= (or slots: {…}). Use one way: elements in attributes, or children with slot= (tracker CONV-parseJsx.ts:1693).` });
 }
 /** Reports a slot key that two children of the owner share (CONV-slots.ts:555), at the later one in the owner's list: children first, then layer elements. */
 function usesEachSlotKeyOnce({ node, rulesApi, report }) {
@@ -65,7 +67,7 @@ function usesEachSlotKeyOnce({ node, rulesApi, report }) {
         if (!other)
             first.set(slot, child);
         else
-            report({ loc: getLoc(child, rulesApi), message: `Slot "${slot}" of ${describe(node, rulesApi)} is used by both ${describe(other, rulesApi)} and ${describe(child, rulesApi)}. Give each slotted child its own slot key (tracker CONV-slots.ts:555).` });
+            report({ check: 'duplicate_slot', loc: getLoc(child, rulesApi), message: `Slot "${slot}" of ${describe(node, rulesApi)} is used by both ${describe(other, rulesApi)} and ${describe(child, rulesApi)}. Give each slotted child its own slot key (tracker CONV-slots.ts:555).` });
     }
 }
 // ── reading the owner ──

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

@@ -7,6 +7,7 @@
 import { fonts } from '@wix/origami-fonts';
 import { reportCssProblem } from "../../rules-api/index.js";
 import { defineRule } from "./define-rule.js";
+const CHECKS = ['invalid_font_id'];
 const FONT_TOKEN = /^--wst-[\w-]+-font$/;
 // The size in a `font` shorthand, with its optional line height: the family follows it. The number's quantifiers
 // never overlap, so a long run of digits that is not a size fails in linear time.
@@ -14,6 +15,7 @@ const SIZE = /^(?:--spx\(.*\)|calc\(.*\)|(?:\d+(?:\.\d*)?|\.\d+)(?:px|em|rem|%|v
 const FONT_IDS = new Set(fonts.filter((font) => font.permissions !== 'legacy').map((font) => font.id));
 export default defineRule({
     name: 'theme-font-ids',
+    checks: CHECKS,
     editors: 'all',
     callbacks: {
         Program: (input) => {
@@ -32,7 +34,7 @@ function hasCatalogFontId({ name, value, line }, { report }) {
     const family = getFontFamily(value);
     if (family === undefined || FONT_IDS.has(family))
         return;
-    reportCssProblem(report, 'theme.css', line, `${name} must name exactly one Wix font id from the catalog; found ${family}. Run \`wix origami search-font --font <name>\` for the id.`);
+    reportCssProblem(report, 'theme.css', line, 'invalid_font_id', `${name} must name exactly one Wix font id from the catalog; found ${family}. Run \`wix origami search-font --font <name>\` for the id.`);
 }
 // ── reading a font value ──
 /** A value split on top-level whitespace, so `--spx(16)/1.3em` stays one part. */

package/dist/rules/site-app/theme-root.js

@@ -1,10 +1,12 @@
 import { describeAtRule, isPresetProperty, PREAMBLE_LAYER, reportCssProblem } from "../../rules-api/index.js";
 import { defineRule } from "./define-rule.js";
+const CHECKS = ['root_selector_suffix', 'root_in_page_css', 'preset_on_root', 'non_token_root_property', 'mixed_spx_context', 'invalid_spx_context', 'invalid_spx_scope'];
 const SPX_PROPS = ['--spx-ref-width', '--spx-resolver-type'];
 const SPX_RESOLVERS = ['scale', 'fixed'];
 /** A named breakpoint: `(--tablet)`. */
 export default defineRule({
     name: 'theme-root',
+    checks: CHECKS,
     editors: ['studio2'],
     callbacks: {
         Program: (input) => {
@@ -32,13 +34,13 @@ export default defineRule({
 function isAlone(file, rule, { report }) {
     if (rule.selector === ':root')
         return true;
-    reportCssProblem(report, file, rule.line, `\`${rule.selector}\` puts a part after :root. Write \`:root { … }\` alone; style elements by their own class (\`.comp-a { … }\`) (tracker CONV-cssSelectors.ts:388).`);
+    reportCssProblem(report, file, rule.line, 'root_selector_suffix', `\`${rule.selector}\` puts a part after :root. Write \`:root { … }\` alone; style elements by their own class (\`.comp-a { … }\`) (tracker CONV-cssSelectors.ts:388).`);
     return false;
 }
 /** Reports a `:root` rule in a page's own CSS: in style.css (CONV-styleParser.ts:443); in layout.css too, which the import refuses as well (seen live, no tracker row yet). */
 function isNotInPage(file, rule, { report }) {
     const source = file === 'style' ? 'tracker CONV-styleParser.ts:443' : 'the import refuses it: seen live';
-    reportCssProblem(report, `${file}.css`, rule.line, `\`:root\` can't be used in a page's ${file}.css: set site variables in global/themes/theme.css (${source}).`);
+    reportCssProblem(report, `${file}.css`, rule.line, 'root_in_page_css', `\`:root\` can't be used in a page's ${file}.css: set site variables in global/themes/theme.css (${source}).`);
 }
 /** A theme `:root` rule: a preset (step 4), then only tokens or only the spx context (step 1); an spx context's values (step 2) and place (step 3). A `:root` inside a `@mixin` is the global-styles rows' (its selector must start with `&` there). */
 function checkThemeRoot(root, input) {
@@ -58,14 +60,14 @@ function hasNoPreset(root, { report }) {
     const preset = root.declarations.find(({ prop }) => isPresetProperty(prop));
     if (!preset)
         return true;
-    reportCssProblem(report, 'theme.css', root.line, `\`:root\` can't set ${preset.prop}; theme.css holds only :root tokens, the spx context and @mixin global styles. Set a preset on the element's rule in its page's style.css (tracker CONV-parseTheme.ts:224).`);
+    reportCssProblem(report, 'theme.css', root.line, 'preset_on_root', `\`:root\` can't set ${preset.prop}; theme.css holds only :root tokens, the spx context and @mixin global styles. Set a preset on the element's rule in its page's style.css (tracker CONV-parseTheme.ts:224).`);
     return false;
 }
 /** Reports a plain property, or tokens mixed with the spx context (CONV-parseTheme.ts:170). 'tokens' / 'spx' when the rule is one of the two. */
 function holdsTokensOrSpx(root, { report }) {
     const plain = root.declarations.find(({ prop }) => !prop.startsWith('--'));
     if (plain) {
-        reportCssProblem(report, 'theme.css', root.line, `this :root rule has \`${plain.prop}\`; a :root rule holds only tokens (--…), or only --spx-ref-width and --spx-resolver-type. Move other properties to an element's rule in style.css (tracker CONV-parseTheme.ts:170).`);
+        reportCssProblem(report, 'theme.css', root.line, 'non_token_root_property', `this :root rule has \`${plain.prop}\`; a :root rule holds only tokens (--…), or only --spx-ref-width and --spx-resolver-type. Move other properties to an element's rule in style.css (tracker CONV-parseTheme.ts:170).`);
         return null;
     }
     const spx = root.declarations.filter(isSpx);
@@ -73,7 +75,7 @@ function holdsTokensOrSpx(root, { report }) {
         return 'tokens';
     if (spx.length === root.declarations.length)
         return 'spx';
-    reportCssProblem(report, 'theme.css', root.line, `this :root rule mixes the spx context (--spx-ref-width, --spx-resolver-type) with other lines; write the spx context as its own :root rule (tracker CONV-parseTheme.ts:170).`);
+    reportCssProblem(report, 'theme.css', root.line, 'mixed_spx_context', `this :root rule mixes the spx context (--spx-ref-width, --spx-resolver-type) with other lines; write the spx context as its own :root rule (tracker CONV-parseTheme.ts:170).`);
     return null;
 }
 /** Reports an spx context missing one of its two properties, with a width that isn't a positive plain number, or a resolver that isn't scale / fixed (CONV-parseTheme.ts:177). */
@@ -82,7 +84,7 @@ function isValidSpxContext(root, { report }) {
     const resolver = lastValue(root, '--spx-resolver-type');
     if (width !== undefined && Number.isFinite(Number(width)) && Number(width) > 0 && resolver !== undefined && SPX_RESOLVERS.includes(resolver))
         return true;
-    reportCssProblem(report, 'theme.css', root.line, `this :root spx rule must set both --spx-ref-width (a positive number, like 1280) and --spx-resolver-type (scale or fixed) (tracker CONV-parseTheme.ts:177).`);
+    reportCssProblem(report, 'theme.css', root.line, 'invalid_spx_context', `this :root spx rule must set both --spx-ref-width (a positive number, like 1280) and --spx-resolver-type (scale or fixed) (tracker CONV-parseTheme.ts:177).`);
     return false;
 }
 /** Reports an spx context under anything but one `@media (--name)` the theme declares: two conditions, a plain range, another at-rule (CONV-parseTheme.ts:82). At the top level it is the default range's. */
@@ -92,7 +94,7 @@ function isSpxContextInPlace(root, { rulesApi, report }) {
     const name = root.enclosing.length === 1 && root.enclosing[0].startsWith('@media ') ? rulesApi.getBreakpointName(root.enclosing[0].slice('@media '.length)) : null;
     if (name && rulesApi.getCustomMedia('theme').some((breakpoint) => breakpoint.name === name))
         return;
-    reportCssProblem(report, 'theme.css', root.line, `set the spx context at the top level or under \`@media (--<named range>)\`, one of the theme's @custom-media names; not under ${root.enclosing.map((atRule) => `\`${atRule}\``).join(', ')} (tracker CONV-parseTheme.ts:82).`);
+    reportCssProblem(report, 'theme.css', root.line, 'invalid_spx_scope', `set the spx context at the top level or under \`@media (--<named range>)\`, one of the theme's @custom-media names; not under ${root.enclosing.map((atRule) => `\`${atRule}\``).join(', ')} (tracker CONV-parseTheme.ts:82).`);
 }
 // ── reading the CSS ──
 /** Every rule whose selector starts with `:root` in a parsed file, in order, with what's around it and its declarations. No file → none. */

package/dist/rules-adapter/oxlint/adapt-rule.js

@@ -8,7 +8,7 @@ export function toOxlintRule(rule) {
         meta: { type: 'problem' },
         // oxlint 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, path.relative(context.cwd, context.filename), context.sourceCode.text, context.sourceCode.ast);
+            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);
             return createToolCallbacks(rule, { rulesApi: () => getOrCreateRulesApi(toLintedFile(context)), report, context, stats });
         },

package/dist/rules-adapter/utils.js

@@ -7,8 +7,10 @@ export function createReport(send, stats) {
         if (reported.has(key))
             return;
         reported.add(key);
-        if (stats)
+        if (stats) {
             stats.violations++;
+            stats.checks[problem.check]++;
+        }
         send(problem);
     };
 }
@@ -23,8 +25,9 @@ export function createToolCallbacks(rule, { rulesApi, report, context, stats })
                     check({ node, get rulesApi() { return rulesApi(); }, report, context });
                 }
                 finally {
-                    if (stats)
+                    if (stats) {
                         stats.duration_ms += performance.now() - started;
+                    }
                 }
             }];
     }));

package/dist/rules-api/report.js

@@ -1,11 +1,11 @@
 import { FILE_START } from "../page-model/index.js";
 /** Reports a problem on a line of a CSS file: at the page's start (CSS isn't a file the lint tool lints), the message led by `file:line: `. */
-export function reportCssProblem(report, file, line, message) {
-    report({ loc: FILE_START, message: `${file}:${line}: ${message}` });
+export function reportCssProblem(report, file, line, check, message) {
+    report({ check, loc: FILE_START, message: `${file}:${line}: ${message}` });
 }
 /** A reporter for one CSS file: each problem at the page's start, led by `file:line: ` with the node's line (reportCssProblem). */
 export function createCssFileReporter(file, report) {
-    return (node, message) => reportCssProblem(report, file, node.source?.start?.line ?? 1, message);
+    return (node, check, message) => reportCssProblem(report, file, node.source?.start?.line ?? 1, check, message);
 }
 /** An at-rule as a message writes it: '@media (max-width: 1px)', or '@media' with no params. */
 export function describeAtRule({ name, params }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/origami-lint",
-  "version": "1.34.19",
+  "version": "1.34.21",
   "description": "Offline lint for an exported Origami site: lints the pages that changed since the last passing run",
   "type": "module",
   "bin": {
@@ -25,7 +25,7 @@
     "oxc-parser": "^0.151.0",
     "oxlint": "^1.39.0",
     "postcss": "^8.5.3",
-    "@wix/origami-bi": "0.8.0"
+    "@wix/origami-bi": "0.10.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
@@ -52,5 +52,5 @@
       ]
     }
   },
-  "falconPackageHash": "791d9d5c3c5c2e15912796c5bfa7def4c696084174385a57d767c143"
+  "falconPackageHash": "0f2527e40f513eb3405691ab2a073ba167b04043e3337b6d18056900"
 }