@wix/origami-lint 1.34.19 → 1.34.20

package/dist/rules/site-app/css-layout-properties.js

@@ -1,5 +1,6 @@
 import { CONTENT_TARGET, createCssFileReporter, getName, LAYER_ATTRIBUTES, OVERFLOW_TARGET } from "../../rules-api/index.js";
 import { defineRule } from "./define-rule.js";
+const CHECKS = ['duplicate_property', 'non_layout_property', 'property_outside_target', 'property_in_wrong_target', 'non_container_target_property', 'missing_property_value', 'incompatible_container_property', 'invalid_layout_value', 'missing_container_display', 'missing_grid_column', 'invalid_spx_context', 'unsupported_flex_wrap', 'child_without_container_layout'];
 // ── the tables (propSpecs.ts) ──
 const keywords = (...values) => ({ values, allowed: values.join(', ') });
 const ANY = { allowed: 'any value' };
@@ -88,6 +89,7 @@ const isLayoutProperty = (prop) => isRootProperty(prop) || prop in CONTAINER_PRO
 const ROW = (line) => `(tracker CONV-layoutParser.ts:${line})`;
 export default defineRule({
     name: 'css-layout-properties',
+    checks: CHECKS,
     editors: ['studio2'],
     callbacks: {
         Program: checkLayoutFile,
@@ -127,14 +129,14 @@ function checkPropertiesOnce(declarations, where, reportAt) {
     const seen = new Set();
     for (const decl of declarations) {
         if (seen.has(decl.prop))
-            reportAt(decl, `\`${decl.prop}\` is declared twice in ${where}: keep one ${ROW(498)}.`);
+            reportAt(decl, 'duplicate_property', `\`${decl.prop}\` is declared twice in ${where}: keep one ${ROW(498)}.`);
         seen.add(decl.prop);
     }
 }
 function checkLayoutPropertiesOnly({ element, declarations }, reportAt) {
     for (const decl of declarations) {
         if (!isLayoutProperty(decl.prop))
-            reportAt(decl, `${describeNonLayoutProperty(decl.prop, element)} ${ROW(505)}.`);
+            reportAt(decl, 'non_layout_property', `${describeNonLayoutProperty(decl.prop, element)} ${ROW(505)}.`);
     }
 }
 /** A property the layout tables don't have: in capitals, the import doesn't know it (it reads names as written), else it is paint for style.css. */
@@ -150,9 +152,9 @@ function checkRootPropertiesAtTop({ element, declarations }, reportAt) {
             continue;
         const container = CONTAINER_PROPS[decl.prop];
         if (container)
-            reportAt(decl, `${element}'s \`${decl.prop}\` goes inside \`@origami-target ${container.target} { … }\`, not at the top of its rule ${ROW(512)}.`);
+            reportAt(decl, 'property_outside_target', `${element}'s \`${decl.prop}\` goes inside \`@origami-target ${container.target} { … }\`, not at the top of its rule ${ROW(512)}.`);
         else
-            reportAt(decl, `${describeNonLayoutProperty(decl.prop, element)} ${ROW(512)}.`);
+            reportAt(decl, 'non_layout_property', `${describeNonLayoutProperty(decl.prop, element)} ${ROW(512)}.`);
     }
 }
 /** Each declaration of a target block is a container property of that target; the content block also takes `position: relative` (targetContract.ts). */
@@ -165,11 +167,11 @@ function checkTargetProperties(element, target, declarations, reportAt) {
             continue;
         if (container) {
             const place = container.target === 'root' ? `at the top of ${element}'s rule` : `in \`@origami-target ${container.target}\``;
-            reportAt(decl, `${element}'s \`${decl.prop}\` goes ${place}, not in ${target} ${ROW(524)}.`);
+            reportAt(decl, 'property_in_wrong_target', `${element}'s \`${decl.prop}\` goes ${place}, not in ${target} ${ROW(524)}.`);
         }
         else {
             const fix = isLayoutProperty(decl.prop) ? `move it to the top of ${element}'s rule` : `move it to ${element}'s rule in style.css`;
-            reportAt(decl, `\`${decl.prop}\` in ${element}'s \`@origami-target ${target}\` block is not a container property: ${fix} ${ROW(524)}.`);
+            reportAt(decl, 'non_container_target_property', `\`${decl.prop}\` in ${element}'s \`@origami-target ${target}\` block is not a container property: ${fix} ${ROW(524)}.`);
         }
     }
 }
@@ -182,7 +184,7 @@ function checkScope(scope, inherited, reportAt) {
     for (const [prop, decl] of values) {
         const value = decl.value.trim();
         if (value === '') {
-            reportAt(decl, `${element}'s \`${prop}\` has no value: write a value or remove the declaration ${ROW(430)}.`);
+            reportAt(decl, 'missing_property_value', `${element}'s \`${prop}\` has no value: write a value or remove the declaration ${ROW(430)}.`);
             continue;
         }
         if (SPX_PROPS.includes(prop))
@@ -190,21 +192,21 @@ function checkScope(scope, inherited, reportAt) {
         const container = CONTAINER_PROPS[prop];
         if (container && type && !container[type]) {
             const [own, other] = type === 'grid' ? ['grid', 'flex'] : ['flex', 'grid'];
-            reportAt(decl, `${element} is a ${own} container (\`display: ${own}\`), and \`${prop}\` is a ${other} property: remove it, or use \`display: ${other}\` ${ROW(447)}.`);
+            reportAt(decl, 'incompatible_container_property', `${element} is a ${own} container (\`display: ${own}\`), and \`${prop}\` is a ${other} property: remove it, or use \`display: ${other}\` ${ROW(447)}.`);
             continue;
         }
         if (prop === 'flex-wrap' && ownType === 'stack')
             continue; // :218 reported it; an inherited flex reads it as a value (:437)
         const spec = ELEMENT_PROPS[prop] ?? ITEM_PROPS[prop] ?? container?.spec;
         if (spec && !isReadable(spec, value))
-            reportAt(decl, `${element}'s \`${prop}: ${value}\` is not a layout value. Allowed: ${spec.allowed} ${ROW(437)}.`);
+            reportAt(decl, 'invalid_layout_value', `${element}'s \`${prop}: ${value}\` is not a layout value. Allowed: ${spec.allowed} ${ROW(437)}.`);
     }
     if (scope.rulesWithTargets.length && !type) {
-        reportAt(scope.rulesWithTargets[0], `${element} has \`@origami-target\` blocks but no display: add \`display: grid\` or \`display: flex\` in its \`@origami-target ${CONTENT_TARGET}\` block ${ROW(451)}.`);
+        reportAt(scope.rulesWithTargets[0], 'missing_container_display', `${element} has \`@origami-target\` blocks but no display: add \`display: grid\` or \`display: flex\` in its \`@origami-target ${CONTENT_TARGET}\` block ${ROW(451)}.`);
     }
     const gridRow = values.get('grid-row');
     if (gridRow && !values.has('grid-column')) {
-        reportAt(gridRow, `${element} has \`grid-row\` but no \`grid-column\`: add \`grid-column: <start> / <end>\` (in the same @media, if the grid-row is in one) ${ROW(264)}.`);
+        reportAt(gridRow, 'missing_grid_column', `${element} has \`grid-row\` but no \`grid-column\`: add \`grid-column: <start> / <end>\` (in the same @media, if the grid-row is in one) ${ROW(264)}.`);
     }
     return type;
 }
@@ -220,7 +222,7 @@ function checkSpxReference({ element, values }, reportAt) {
         return; // :430 reports the empty one
     if ((refWidthValue === undefined || Number.isFinite(Number(refWidthValue))) && (resolverTypeValue === undefined || SPX_RESOLVER_TYPES.includes(resolverTypeValue)))
         return;
-    reportAt(first, `${element}'s spx context is invalid: \`--spx-ref-width\` takes a plain number (1280, no px) and \`--spx-resolver-type\` takes scale or fixed ${ROW(417)}.`);
+    reportAt(first, 'invalid_spx_context', `${element}'s spx context is invalid: \`--spx-ref-width\` takes a plain number (1280, no px) and \`--spx-resolver-type\` takes scale or fixed ${ROW(417)}.`);
 }
 /** The container type the scope's own display gives (resolveContainerType): grid, or flex with no flex-wrap other than nowrap (:218). */
 function checkContainerType({ element, values }, reportAt) {
@@ -232,7 +234,7 @@ function checkContainerType({ element, values }, reportAt) {
     const wrap = values.get('flex-wrap');
     const wrapValue = wrap?.value.trim();
     if (wrap && wrapValue !== '' && wrapValue !== 'nowrap') {
-        reportAt(wrap, `${element} has \`flex-wrap: ${wrapValue}\`, which isn't supported: remove it (or write \`nowrap\`), or use \`display: grid\` for items that wrap ${ROW(218)}.`);
+        reportAt(wrap, 'unsupported_flex_wrap', `${element} has \`flex-wrap: ${wrapValue}\`, which isn't supported: remove it (or write \`nowrap\`), or use \`display: grid\` for items that wrap ${ROW(218)}.`);
     }
     return 'stack';
 }
@@ -268,7 +270,7 @@ function checkContainerParent(child, parent, { report }) {
         const parentName = nameOf(parent);
         const props = [...new Set(declarations.map(({ prop }) => prop))].join(', ');
         const line = Math.min(...declarations.map(({ decl }) => decl.line));
-        report({ loc: child.loc, message: `layout.css:${line}: ${childName} sets item properties (${props}), but its parent ${parentName} has no container layout${media ? ` at @media ${media}` : ''}: give ${parentName} \`display: grid\` or \`display: flex\`, or remove ${childName}'s item properties ${ROW(359)}.` });
+        report({ check: 'child_without_container_layout', loc: child.loc, message: `layout.css:${line}: ${childName} sets item properties (${props}), but its parent ${parentName} has no container layout${media ? ` at @media ${media}` : ''}: give ${parentName} \`display: grid\` or \`display: flex\`, or remove ${childName}'s item properties ${ROW(359)}.` });
     }
 }
 /** The parent's container type at this breakpoint, as the import derives it: its last `display` there (on itself or in its content-wrapper block) when it is grid or flex, else the default's. */

package/dist/rules/site-app/css-selectors.js

@@ -1,5 +1,6 @@
 import { BREAKPOINT_AT_RULES, createCssFileReporter, getSelectorSegments, isCssIdentifier, isSafeCssIdentifier, PREAMBLE_LAYER, readSegment } from "../../rules-api/index.js";
 import { defineRule } from "./define-rule.js";
+const CHECKS = ['invalid_scope_owner', 'empty_selector', 'missing_element_selector', 'global_style_as_rule', 'invalid_selector_segment', 'multiple_layout_elements', 'layout_by_state', 'too_many_ancestor_elements', 'ancestor_without_state', 'inner_part_has_id', 'parent_selector_outside_mixin', 'multiple_state_owners', 'state_without_class', 'missing_selector_element', 'selector_list', 'unclosed_selector_token', 'unsupported_selector_syntax'];
 /** The at-rules whose rules the import reads: breakpoint blocks, and a `@mixin`'s `@result`. */
 const READ_AT_RULES = [...BREAKPOINT_AT_RULES, 'result'];
 const SCOPE_OWNER = /^\(\.([^:[\]"\s]+)\)$/;
@@ -7,6 +8,7 @@ const SCOPE_OWNER = /^\(\.([^:[\]"\s]+)\)$/;
 const CLASSES_ONLY = /^[^:[\]"]+$/;
 export default defineRule({
     name: 'css-selectors',
+    checks: CHECKS,
     editors: ['studio2'],
     callbacks: {
         Program: checkCssFilesSelectors,
@@ -50,7 +52,7 @@ function checkScopeOwner(node, file) {
     const owner = SCOPE_OWNER.exec(params)?.[1];
     if (owner !== undefined && isSafeCssIdentifier(owner))
         return;
-    file.reportAt(node, `\`@scope ${params}\` must name its owner as \`(.<class>)\`, one element's class. Write \`@scope (.${ownClassOf(owner ?? params.replace(/^[(.#\s]+/, ''))})\` (tracker CONV-utils.ts:70).`);
+    file.reportAt(node, 'invalid_scope_owner', `\`@scope ${params}\` must name its owner as \`(.<class>)\`, one element's class. Write \`@scope (.${ownClassOf(owner ?? params.replace(/^[(.#\s]+/, ''))})\` (tracker CONV-utils.ts:70).`);
 }
 /** One rule's selector, in the import's order: the flat global style, the split, the parts, the first part, then the chain. */
 function checkSelector(rule, file) {
@@ -64,13 +66,13 @@ function checkSelector(rule, file) {
         return;
     const [first, ...rest] = parts;
     if (first === undefined)
-        return file.reportAt(rule, 'the rule has an empty selector. Start it with the element\'s class: `.comp-a { … }` (tracker CONV-cssSelectors.ts:370).');
+        return file.reportAt(rule, 'empty_selector', 'the rule has an empty selector. Start it with the element\'s class: `.comp-a { … }` (tracker CONV-cssSelectors.ts:370).');
     if (first.isAmpersand)
         return checkGlobalStyleChain(first, rest, selector, rule, file);
     if (file.inMixin)
         return;
     if (first.className === undefined)
-        return file.reportAt(rule, `selector \`${selector}\` doesn't start with an element. Start it with the element's class: \`.comp-a${first.text}\` (tracker CONV-cssSelectors.ts:370).`);
+        return file.reportAt(rule, 'missing_element_selector', `selector \`${selector}\` doesn't start with an element. Start it with the element's class: \`.comp-a${first.text}\` (tracker CONV-cssSelectors.ts:370).`);
     const element = splitStateClasses(first);
     if (!checkElementClass(element.className, first.className, selector, rule, file))
         return;
@@ -82,7 +84,7 @@ function checkSelector(rule, file) {
 function checkFlatGlobalStyle(selector, rule, file) {
     if (file.name === 'layout.css' || file.inMixin || !selector.startsWith('--'))
         return true;
-    file.reportAt(rule, `\`${selector} { … }\` is not a valid rule. Declare the global style as \`@mixin ${selector} { @result { … } }\` (tracker CONV-astParser.ts:88).`);
+    file.reportAt(rule, 'global_style_as_rule', `\`${selector} { … }\` is not a valid rule. Declare the global style as \`@mixin ${selector} { @result { … } }\` (tracker CONV-astParser.ts:88).`);
     return false;
 }
 /** Reports an element class that isn't a plain identifier or is a reserved name (CONV-cssSelectors.ts:54), naming the class as written. */
@@ -90,7 +92,7 @@ function checkElementClass(className, written, selector, rule, file) {
     if (isSafeCssIdentifier(className))
         return true;
     const problem = isCssIdentifier(className) ? `\`${className}\` is a reserved name, not an element class. Give the element another className` : `\`${written}\` is not an element class. ${howToWrite(written, ownClassOf(className))}`;
-    file.reportAt(rule, `in \`${selector}\`, ${problem} (tracker CONV-cssSelectors.ts:54).`);
+    file.reportAt(rule, 'invalid_selector_segment', `in \`${selector}\`, ${problem} (tracker CONV-cssSelectors.ts:54).`);
     return false;
 }
 /** A layout.css rule: one element's class (CONV-layoutParser.ts:105), no state (:108); a part with no class is refused first (CONV-cssSelectors.ts:213). */
@@ -100,10 +102,10 @@ function checkLayoutChain(first, rest, selector, rule, file) {
     const state = [first, ...rest].flatMap((part) => part.states)[0];
     if (rest.length) {
         const element = rest.findLast((part) => file.elementClassNames.has(baseClassOf(part))) ?? first;
-        return file.reportAt(rule, `\`${selector}\` names more than one element; a layout rule takes one element's class: write \`.${baseClassOf(element)} { … }\` (layout can't be set on an inner part or through an ancestor) (tracker CONV-layoutParser.ts:105).`);
+        return file.reportAt(rule, 'multiple_layout_elements', `\`${selector}\` names more than one element; a layout rule takes one element's class: write \`.${baseClassOf(element)} { … }\` (layout can't be set on an inner part or through an ancestor) (tracker CONV-layoutParser.ts:105).`);
     }
     if (state !== undefined)
-        return file.reportAt(rule, `\`${selector}\` sets layout by state, which isn't supported: remove \`${state}\` from the selector (state changes go in style.css) (tracker CONV-layoutParser.ts:108).`);
+        return file.reportAt(rule, 'layout_by_state', `\`${selector}\` sets layout by state, which isn't supported: remove \`${state}\` from the selector (state changes go in style.css) (tracker CONV-layoutParser.ts:108).`);
     checkElementExists(first, rule, file);
 }
 /** A style or theme rule on an element (cssSelectors.ts parseComponentChain): a second element needs a state on the first (:321), carries
@@ -116,9 +118,9 @@ function checkElementChain(first, rest, selector, rule, file) {
         const second = splitStateClasses(rest[0]);
         const third = rest.slice(1).find((part) => isAnotherElement(part, file));
         if (third)
-            return file.reportAt(rule, `\`${selector}\` chains three elements. Keep one ancestor: \`.${first.className}${first.states.join('')} .${baseClassOf(third)}\` (tracker CONV-cssSelectors.ts:318).`);
+            return file.reportAt(rule, 'too_many_ancestor_elements', `\`${selector}\` chains three elements. Keep one ancestor: \`.${first.className}${first.states.join('')} .${baseClassOf(third)}\` (tracker CONV-cssSelectors.ts:318).`);
         if (!first.states.length)
-            return file.reportAt(rule, `\`${selector}\` puts one element under another without a state. Address the element by its own class (\`.${ownClassOf(second.className)}\`), or condition it on the ancestor's state (\`.${first.className}:hover .${ownClassOf(second.className)}\`) (tracker CONV-cssSelectors.ts:321).`);
+            return file.reportAt(rule, 'ancestor_without_state', `\`${selector}\` puts one element under another without a state. Address the element by its own class (\`.${ownClassOf(second.className)}\`), or condition it on the ancestor's state (\`.${first.className}:hover .${ownClassOf(second.className)}\`) (tracker CONV-cssSelectors.ts:321).`);
         if (second.states.length)
             return reportTwoOwners(first, second, selector, rule, file);
         if (!checkElementClass(second.className, rest[0].className, selector, rule, file))
@@ -147,14 +149,14 @@ function checkInnerPartsHaveNoId(inner, selector, rule, file) {
     const part = inner.find(hasId);
     if (part === undefined)
         return true;
-    file.reportAt(rule, `in \`${selector}\`, \`.${part.className}\` is not an inner part: an inner part's selector has no \`#\` id. Use an inner part's selector from the element's contract, without the id (\`.${ownClassOf(part.className)}\`) (tracker CONV-cssSelectors.ts:222).`);
+    file.reportAt(rule, 'inner_part_has_id', `in \`${selector}\`, \`.${part.className}\` is not an inner part: an inner part's selector has no \`#\` id. Use an inner part's selector from the element's contract, without the id (\`.${ownClassOf(part.className)}\`) (tracker CONV-cssSelectors.ts:222).`);
     return false;
 }
 /** A `@mixin`'s rule, `&…` (cssSelectors.ts parseGlobalStyleChain): outside a `@mixin` it's refused (:377); a later `&` or `:root` is the
  * global-styles rows'; then the inner parts, read as an element's (parseIeChain), with no id (:222). */
 function checkGlobalStyleChain(first, rest, selector, rule, file) {
     if (!file.inMixin)
-        return file.reportAt(rule, `\`${selector}\` is outside a \`@mixin\`. Replace \`&\` with the element's class (\`.comp-a${selector.slice(1)}\`), or move the rule into the global style's \`@mixin\` (tracker CONV-cssSelectors.ts:377).`);
+        return file.reportAt(rule, 'parent_selector_outside_mixin', `\`${selector}\` is outside a \`@mixin\`. Replace \`&\` with the element's class (\`.comp-a${selector.slice(1)}\`), or move the rule into the global style's \`@mixin\` (tracker CONV-cssSelectors.ts:377).`);
     if (rest.some((part) => part.isAmpersand || part.text === ':root'))
         return;
     if (!checkInnerParts(rest, first, selector, rule, file))
@@ -169,7 +171,7 @@ function checkInnerParts(inner, owner, selector, rule, file) {
         return false;
     const stated = inner.filter((part) => part.states.length);
     if (stated.length > 1) {
-        file.reportAt(rule, `in \`${selector}\`, states sit on \`${stated[0].text}\` and \`${stated[1].text}\`. Attach the states to the one part that owns them (tracker CONV-cssSelectors.ts:213).`);
+        file.reportAt(rule, 'multiple_state_owners', `in \`${selector}\`, states sit on \`${stated[0].text}\` and \`${stated[1].text}\`. Attach the states to the one part that owns them (tracker CONV-cssSelectors.ts:213).`);
         return false;
     }
     if (stated.length && owner.states.length) {
@@ -183,19 +185,19 @@ function checkPartsHaveClass(parts, selector, rule, file) {
     const bare = parts.find((part) => part.className === undefined);
     if (!bare)
         return true;
-    file.reportAt(rule, `in \`${selector}\`, \`${bare.text}\` has no class. Attach the state to the part that owns it (\`.comp-a:hover\`, \`.comp-a .label:hover\`) and write every later part as a class (tracker CONV-cssSelectors.ts:213).`);
+    file.reportAt(rule, 'state_without_class', `in \`${selector}\`, \`${bare.text}\` has no class. Attach the state to the part that owns it (\`.comp-a:hover\`, \`.comp-a .label:hover\`) and write every later part as a class (tracker CONV-cssSelectors.ts:213).`);
     return false;
 }
 /** Reports states on two owners (CONV-cssSelectors.ts:216). */
 function reportTwoOwners(owner, other, selector, rule, file) {
     const name = (part) => (part.isAmpersand ? '&' : `.${baseClassOf(part)}`);
-    file.reportAt(rule, `\`${selector}\` puts states on two owners (\`${name(owner)}\` and \`${name(other)}\`). Condition the rule on one owner's states only (tracker CONV-cssSelectors.ts:216).`);
+    file.reportAt(rule, 'multiple_state_owners', `\`${selector}\` puts states on two owners (\`${name(owner)}\` and \`${name(other)}\`). Condition the rule on one owner's states only (tracker CONV-cssSelectors.ts:216).`);
 }
 /** Reports a rule for an element that structure.jsx doesn't have (CONV-fromBundle.ts:855). */
 function checkElementExists(element, rule, file) {
     if (file.inMixin || file.elementClassNames.has(element.className))
         return;
-    file.reportAt(rule, `\`.${element.className}\` styles no element: no element in structure.jsx has className="${element.className}". Remove the rule, or write the className of an element (tracker CONV-fromBundle.ts:855).`);
+    file.reportAt(rule, 'missing_selector_element', `\`.${element.className}\` styles no element: no element in structure.jsx has className="${element.className}". Remove the rule, or write the className of an element (tracker CONV-fromBundle.ts:855).`);
 }
 // ── reading a selector ──
 /** The selector's parts, split as the import splits them (getSelectorSegments, cssSelectors.ts splitSegments), each read as the import
@@ -227,14 +229,14 @@ function reportUnsplittable(selector, rule, file) {
         else if ((char === ']' || char === ')') && !openers.pop())
             return reportUnbalanced(`has a \`${char}\` with no \`${char === ']' ? '[' : '('}\` before it`, selector, rule, file);
         else if (char === ',' && !openers.length) {
-            file.reportAt(rule, `\`${selector}\` is a selector list. Split it into one rule per selector (tracker CONV-cssSelectors.ts:92).`);
+            file.reportAt(rule, 'selector_list', `\`${selector}\` is a selector list. Split it into one rule per selector (tracker CONV-cssSelectors.ts:92).`);
             return null;
         }
     }
     return reportUnbalanced(inQuotes ? 'has an unclosed `"`' : `has an unclosed \`${openers.at(-1)}\``, selector, rule, file);
 }
 function reportUnbalanced(what, selector, rule, file) {
-    file.reportAt(rule, `selector \`${selector}\` ${what}. Close the bracket or quote (tracker CONV-cssSelectors.ts:87).`);
+    file.reportAt(rule, 'unclosed_selector_token', `selector \`${selector}\` ${what}. Close the bracket or quote (tracker CONV-cssSelectors.ts:87).`);
     return null;
 }
 /** One part as the import reads it: `:root`, or `&` or a class, then states (`:hover`, `.state-class`); an attribute or functional
@@ -244,7 +246,7 @@ function readPart(text, selector, rule, file) {
         return { text, isAmpersand: false, states: [] };
     const { base, states, unread } = readSegment(text);
     if (unread) {
-        file.reportAt(rule, `in \`${selector}\`, the format can't read \`${unread}\`. ${howToWrite(unread, 'comp-a')} (tracker CONV-cssSelectors.ts:169).`);
+        file.reportAt(rule, 'unsupported_selector_syntax', `in \`${selector}\`, the format can't read \`${unread}\`. ${howToWrite(unread, 'comp-a')} (tracker CONV-cssSelectors.ts:169).`);
         return null;
     }
     return { text, isAmpersand: base === '&', className: base === '&' ? undefined : base?.slice(1), states };

package/dist/rules/site-app/data-values.js

@@ -4,6 +4,7 @@
 import { isDeepStrictEqual } from 'node:util';
 import { DATA_KEY, EVENT_ATTRIBUTE, RESERVED_ATTRIBUTES, RESERVED_ENTRY_KEYS, bare, getAttribute, getExpression, getKey, getName, getObject, getProperties, getCallbackKind, getProperty, isBound, isOneEditAway, isReservedAttribute, isStructure, ownerOf, } from "../../rules-api/index.js";
 import { defineRule } from "./define-rule.js";
+const CHECKS = ['attribute_without_braces', 'non_literal_data', 'duplicate_element_prop', 'invalid_element_props_object', 'invalid_element_props_entry', 'invalid_data_object', 'invalid_element_props_key', 'unsupported_element_props_key', 'mixed_data_wrapper', 'duplicate_data_key', 'bare_document_href', 'missing_document_id', 'inconsistent_image_url', 'misplaced_image_url_call'];
 /** The names the import never reads as data (dataKeys.ts). The React name is joined as the converter does: Wix Standards fails the build on it in any file. */
 const EXCLUDED_DATA_KEYS = [
     '_slotsId', '_mapId', 'hidden', 'class', 'title', 'role', 'tabindex', 'draggable', 'lang', 'dir', 'accesskey', 'contenteditable', 'spellcheck',
@@ -33,6 +34,7 @@ const WRAPPER_KEYS = ['type', 'id', 'data'];
 const LITERAL_HINT = 'The import reads it as data: write the value itself, a string, a number, true / false, null, or an object or array of these.';
 export default defineRule({
     name: 'data-values',
+    checks: CHECKS,
     editors: ['studio2'],
     callbacks: {
         JSXElement: checkJSXElementDataValues,
@@ -54,7 +56,7 @@ function checkJSXElementDataValues(input) {
     checkImageUrls(input, read);
 }
 // ── the steps ──
-const say = ({ report }, node, message) => report({ loc: node.loc, message });
+const say = ({ report }, node, check, message) => report({ check, loc: node.loc, message });
 const textOf = ({ context }) => (node) => context.sourceCode.getText(node);
 const owner = ({ node }) => ownerOf(node);
 function checkValuesAreLiterals(input, skip) {
@@ -62,7 +64,7 @@ function checkValuesAreLiterals(input, skip) {
     for (const attribute of getAttributes(input.node)) {
         const name = getName(attribute);
         if (READ_AS_DATA.includes(name) && attribute.value?.type !== 'JSXExpressionContainer') {
-            say(input, attribute, `\`${name}\` on ${owner(input)} isn't in braces. The import reads it only from braces: write \`${name}={…}\`.`);
+            say(input, attribute, 'attribute_without_braces', `\`${name}\` on ${owner(input)} isn't in braces. The import reads it only from braces: write \`${name}={…}\`.`);
             continue;
         }
         const value = getExpression(attribute);
@@ -73,7 +75,7 @@ function checkValuesAreLiterals(input, skip) {
         const mode = name === 'props' ? PROPS : FULL;
         const found = name === 'elementProps' ? nonLiteralInElementProps(value, mode, input.rulesApi, textOf(input)) : nonLiteralIn(value, mode, input.rulesApi, textOf(input));
         if (found)
-            say(input, found.node, `\`${name}\` on ${owner(input)} holds ${found.what}. ${LITERAL_HINT}`);
+            say(input, found.node, 'non_literal_data', `\`${name}\` on ${owner(input)} holds ${found.what}. ${LITERAL_HINT}`);
         else
             read.add(name);
     }
@@ -87,7 +89,7 @@ function checkEntryKeysOnce(input, attribute) {
             if (key === null)
                 continue;
             if (seen.has(key)) {
-                say(input, property, `${owner(input)}'s elementProps entry \`${path.join('.')}\` has the key \`${key}\` twice. Keep one.`);
+                say(input, property, 'duplicate_element_prop', `${owner(input)}'s elementProps entry \`${path.join('.')}\` has the key \`${key}\` twice. Keep one.`);
                 return false;
             }
             seen.add(key);
@@ -100,7 +102,7 @@ function checkElementPropsShape(input, attribute) {
     // an object written out: a media call decodes to an object, but its keys aren't inner parts
     const map = getObject(value);
     if (!map)
-        return say(input, value, `\`elementProps\` on ${owner(input)} isn't an object. Write an object of inner parts: \`elementProps={{ name: {…} }}\`.`);
+        return say(input, value, 'invalid_element_props_object', `\`elementProps\` on ${owner(input)} isn't an object. Write an object of inner parts: \`elementProps={{ name: {…} }}\`.`);
     checkElementPropsEntries(input, map, []);
 }
 function checkElementPropsEntries(input, map, path) {
@@ -112,19 +114,19 @@ function checkElementPropsEntries(input, map, path) {
         // an object written out: a media call decodes to an object, but not to an inner part's settings
         const entry = getObject(property.value);
         if (!entry) {
-            say(input, property.value, `${owner(input)}'s elementProps entry \`${at}\` isn't an object. Write the inner part's settings as an object: \`${name}: {…}\`.`);
+            say(input, property.value, 'invalid_element_props_entry', `${owner(input)}'s elementProps entry \`${at}\` isn't an object. Write the inner part's settings as an object: \`${name}: {…}\`.`);
             continue;
         }
         checkEntryKeysAreKnown(input, entry, at);
         const data = getProperty(entry, 'data');
         if (data && !isObjectValue(data.value, input.rulesApi))
-            say(input, data.value, `${owner(input)}'s elementProps entry \`${at}\` has \`data\` that isn't an object. Write \`data: {…}\`.`);
+            say(input, data.value, 'invalid_data_object', `${owner(input)}'s elementProps entry \`${at}\` has \`data\` that isn't an object. Write \`data: {…}\`.`);
         const nested = getProperty(entry, 'elementProps');
         if (!nested)
             continue;
         const nestedMap = getObject(nested.value);
         if (!nestedMap)
-            say(input, nested.value, `${owner(input)}'s elementProps entry \`${at}\` has \`elementProps\` that isn't an object. Write \`elementProps: { name: {…} }\`.`);
+            say(input, nested.value, 'invalid_element_props_object', `${owner(input)}'s elementProps entry \`${at}\` has \`elementProps\` that isn't an object. Write \`elementProps: { name: {…} }\`.`);
         else
             checkElementPropsEntries(input, nestedMap, [...path, name]);
     }
@@ -132,7 +134,7 @@ function checkElementPropsEntries(input, map, path) {
 function checkEntryName(input, property, name) {
     const what = name === '' ? 'an empty name' : name.includes('|') ? `the name \`${name}\`, which has a \`|\`` : !CSS_IDENTIFIER.test(name) || RESERVED_OBJECT_KEYS.includes(name) ? `the name \`${name}\`, which isn't a CSS identifier` : null;
     if (what)
-        say(input, property.key, `${owner(input)} has an elementProps entry with ${what}. Name it as the inner part is named, like \`navbar\`.`);
+        say(input, property.key, 'invalid_element_props_key', `${owner(input)} has an elementProps entry with ${what}. Name it as the inner part is named, like \`navbar\`.`);
     return what === null;
 }
 function checkEntryKeysAreKnown(input, entry, at) {
@@ -143,7 +145,7 @@ function checkEntryKeysAreKnown(input, entry, at) {
         const typo = nearMissOf(key);
         if (!isReservedAttribute(key) && !isExcluded(key) && !typo)
             continue;
-        say(input, property.key, `${owner(input)}'s elementProps entry \`${at}\` has the key \`${key}\`, which an inner part doesn't take. Use its data keys, or \`data: {…}\`${typo ? ` (did you mean \`${typo}\`?)` : ''}.`);
+        say(input, property.key, 'unsupported_element_props_key', `${owner(input)}'s elementProps entry \`${at}\` has the key \`${key}\`, which an inner part doesn't take. Use its data keys, or \`data: {…}\`${typo ? ` (did you mean \`${typo}\`?)` : ''}.`);
     }
 }
 function checkDataCarrier(input) {
@@ -155,12 +157,12 @@ function checkDataCarrier(input) {
     if (!merges)
         return null;
     if (!isObjectValue(value, input.rulesApi)) {
-        say(input, value, `${owner(input)} has data attributes, so its \`data\` must be an object: \`data={{…}}\`, not \`data={${textOf(input)(value)}}\`.`);
+        say(input, value, 'invalid_data_object', `${owner(input)} has data attributes, so its \`data\` must be an object: \`data={{…}}\`, not \`data={${textOf(input)(value)}}\`.`);
         return null;
     }
     const carrier = getObject(value);
     if (carrier && isWrapper(input, carrier)) {
-        say(input, data, `${owner(input)} mixes data attributes with the \`{ type, data }\` wrapper in \`data={…}\`. Move the wrapper's keys to attributes.`);
+        say(input, data, 'mixed_data_wrapper', `${owner(input)} mixes data attributes with the \`{ type, data }\` wrapper in \`data={…}\`. Move the wrapper's keys to attributes.`);
         return null;
     }
     return carrier;
@@ -182,7 +184,7 @@ function checkDataKeyOnce(input, carrier) {
         for (const attribute of attributes) {
             const name = getName(attribute);
             if (keys.has(name))
-                say(input, attribute, `${owner(input)} has \`${name}\` both as an attribute and inside \`data={{…}}\`. Keep only one.`);
+                say(input, attribute, 'duplicate_data_key', `${owner(input)} has \`${name}\` both as an attribute and inside \`data={{…}}\`. Keep only one.`);
         }
     }
     for (const { entry, path } of getEntries(getObject(getExpression(getAttribute(input.node, 'elementProps'))))) {
@@ -193,7 +195,7 @@ function checkDataKeyOnce(input, carrier) {
         for (const property of entryDataKeys(entry)) {
             const key = getKey(property);
             if (keys.has(key))
-                say(input, property, `${owner(input)}'s elementProps entry \`${path.join('.')}\` has \`${key}\` both as a key and inside its \`data\`. Keep only one.`);
+                say(input, property, 'duplicate_data_key', `${owner(input)}'s elementProps entry \`${path.join('.')}\` has \`${key}\` both as a key and inside its \`data\`. Keep only one.`);
         }
     }
 }
@@ -230,12 +232,12 @@ function checkDocumentHref(input, link) {
     const bareHref = valueOf(href.value);
     if (typeof bareHref === 'string') {
         if (bareHref.startsWith(DOCUMENT_PREFIX))
-            say(input, href, `${owner(input)}'s link href is a bare 'wix:document://' string. Write \`href: media.getDocumentUrl('wix:document://…').url\`, with media imported from '@wix/sdk'.`);
+            say(input, href, 'bare_document_href', `${owner(input)}'s link href is a bare 'wix:document://' string. Write \`href: media.getDocumentUrl('wix:document://…').url\`, with media imported from '@wix/sdk'.`);
         return;
     }
     const identifier = documentIdentifierOf(bare(href.value), input.rulesApi);
     if (!hasDocumentId(identifier))
-        say(input, href, `${owner(input)}'s document link has no document id in '${identifier}'. Use the identifier the export wrote: \`media.getDocumentUrl('wix:document://v1/ugd/<file>/<name>').url\`.`);
+        say(input, href, 'missing_document_id', `${owner(input)}'s document link has no document id in '${identifier}'. Use the identifier the export wrote: \`media.getDocumentUrl('wix:document://v1/ugd/<file>/<name>').url\`.`);
 }
 /** documentLink.ts rebuildDocumentLink: the first `/ugd/` or `/archives/` goes, then `<id>/<name>`; the name is URI-decoded. */
 function hasDocumentId(identifier) {
@@ -265,12 +267,12 @@ function checkImageUrls(input, read) {
             const call = bare(url.value);
             if (isImageCall(call, input.rulesApi) && sameArguments(call, derivedImageArguments(fields)))
                 continue;
-            say(input, url, `${owner(input)}'s \`${at}.url\` isn't the url the image's fields give. It is derived: change the image's uri, width, height, name or crop, and drop \`url\`.`);
+            say(input, url, 'inconsistent_image_url', `${owner(input)}'s \`${at}.url\` isn't the url the image's fields give. It is derived: change the image's uri, width, height, name or crop, and drop \`url\`.`);
         }
     }
     const stray = imageCallsIn(input, values, read).find((call) => !urls.has(call));
     if (stray)
-        say(input, stray, `${owner(input)} has \`media.getCroppedImageUrl(…)\` outside an image's url. Write it only as the \`url\` of a \`{ type: 'Builder.Image', … }\` object.`);
+        say(input, stray, 'misplaced_image_url_call', `${owner(input)} has \`media.getCroppedImageUrl(…)\` outside an image's url. Write it only as the \`url\` of a \`{ type: 'Builder.Image', … }\` object.`);
 }
 function imageCallsIn(input, dataValuesRead, read) {
     const values = dataValuesRead.map(([value]) => value);

package/dist/rules/site-app/global-styles.js

@@ -1,7 +1,9 @@
 import { BREAKPOINT_AT_RULES, createCssFileReporter, describeAtRule, getCssChildren, getDashedId, getMixinId, getSegmentClass, getSelectorSegments, isCssIdentifier, isSafeCssIdentifier } from "../../rules-api/index.js";
 import { defineRule } from "./define-rule.js";
+const CHECKS = ['invalid_mixin_id', 'invalid_mixin_result', 'missing_parent_selector', 'bare_parent_selector', 'nested_style_rule', 'apply_at_result_root', 'nested_mixin', 'invalid_result_at_rule', 'invalid_parent_selector', 'conditional_global_style_link', 'invalid_linked_style_id', 'missing_linked_style', 'duplicate_global_style_link', 'link_with_values', 'missing_global_style_link'];
 export default defineRule({
     name: 'global-styles',
+    checks: CHECKS,
     editors: ['studio2'],
     callbacks: {
         Program: ({ rulesApi, report }) => {
@@ -28,12 +30,12 @@ function checkMixinsAndLinks(root, file, report) {
 function checkMixin(mixin, reportInFile) {
     const id = getMixinId(mixin);
     if (id === null) {
-        reportInFile(mixin, getMixinIdMessage(mixin.params.trim()));
+        reportInFile(mixin, 'invalid_mixin_id', getMixinIdMessage(mixin.params.trim()));
         return [];
     }
     const result = getResult(mixin);
     if (!result) {
-        reportInFile(mixin, `\`@mixin --${id}\` must be \`@mixin --${id} { @result { … } }\`. Put everything inside one \`@result { }\` (tracker CONV-astParser.ts:293).`);
+        reportInFile(mixin, 'invalid_mixin_result', `\`@mixin --${id}\` must be \`@mixin --${id} { @result { … } }\`. Put everything inside one \`@result { }\` (tracker CONV-astParser.ts:293).`);
         return [];
     }
     const rules = [];
@@ -54,12 +56,12 @@ function checkMixinRule(node, id, breakpoint, rules, reportInFile) {
     const selector = node.selector.trim();
     const inner = getCssChildren(node);
     if (!selector.startsWith('&'))
-        return reportInFile(node, `\`@mixin --${id}\`: selector \`${selector}\` must start with \`&\`. Write \`& ${selector}\` (or \`&:hover\`) (tracker CONV-astParser.ts:195).`);
+        return reportInFile(node, 'missing_parent_selector', `\`@mixin --${id}\`: selector \`${selector}\` must start with \`&\`. Write \`& ${selector}\` (or \`&:hover\`) (tracker CONV-astParser.ts:195).`);
     if (selector === '&')
-        return reportInFile(node, getBareAmpersandMessage(id, inner));
+        return reportInFile(node, 'bare_parent_selector', getBareAmpersandMessage(id, inner));
     const nested = inner.find((child) => child.type === 'rule');
     if (nested)
-        return reportInFile(nested, `\`@mixin --${id}\`: a rule is nested in \`${selector}\`. Write the whole selector on one rule: \`${joinSelectors(selector, nested.selector.trim())} { … }\` (tracker CONV-astParser.ts:204).`);
+        return reportInFile(nested, 'nested_style_rule', `\`@mixin --${id}\`: a rule is nested in \`${selector}\`. Write the whole selector on one rule: \`${joinSelectors(selector, nested.selector.trim())} { … }\` (tracker CONV-astParser.ts:204).`);
     const atRules = inner.filter((child) => child.type === 'atrule');
     const applies = atRules.filter((child) => child.name === 'apply');
     // another at-rule (CONV-astParser.ts:211) is css-file-nesting's; two `@apply`s, one beside declarations, or one that isn't
@@ -71,12 +73,12 @@ function checkMixinRule(node, id, breakpoint, rules, reportInFile) {
 /** An at-rule in `@result`: no `@apply` (:246), no `@mixin` (:251); only `@media` / `@scope` at its top, none inside them (:254). */
 function checkResultAtRule(node, id, breakpoint, rules, reportInFile) {
     if (node.name === 'apply')
-        return reportInFile(node, `\`@mixin --${id}\`: \`@apply\` can't sit at the root of \`@result\`. Remove it, or move it into an inner part's rule: \`& .label { @apply ${node.params.trim()}; }\` (tracker CONV-astParser.ts:246).`);
+        return reportInFile(node, 'apply_at_result_root', `\`@mixin --${id}\`: \`@apply\` can't sit at the root of \`@result\`. Remove it, or move it into an inner part's rule: \`& .label { @apply ${node.params.trim()}; }\` (tracker CONV-astParser.ts:246).`);
     if (node.name === 'mixin')
-        return reportInFile(node, `\`@mixin --${id}\`: \`@mixin ${node.params.trim()}\` is declared inside it. Declare each \`@mixin\` at the top level of the file (tracker CONV-astParser.ts:251).`);
+        return reportInFile(node, 'nested_mixin', `\`@mixin --${id}\`: \`@mixin ${node.params.trim()}\` is declared inside it. Declare each \`@mixin\` at the top level of the file (tracker CONV-astParser.ts:251).`);
     if (breakpoint || !BREAKPOINT_AT_RULES.includes(node.name)) {
         const where = breakpoint ? `\`${describeAtRule(breakpoint)}\` in \`@result\`` : '`@result`';
-        return reportInFile(node, `\`@mixin --${id}\`: \`@${node.name}\` is not allowed in ${where}. Use only \`@media\` / \`@scope\` directly inside \`@result\`, one level deep (tracker CONV-astParser.ts:254).`);
+        return reportInFile(node, 'invalid_result_at_rule', `\`@mixin --${id}\`: \`@${node.name}\` is not allowed in ${where}. Use only \`@media\` / \`@scope\` directly inside \`@result\`, one level deep (tracker CONV-astParser.ts:254).`);
     }
     const media = getBreakpointBody(node);
     if (media)
@@ -98,7 +100,7 @@ function checkSelector(rule, reportInFile) {
     if (repeated === undefined)
         return true;
     const problem = repeated === ':root' ? 'has `:root` after `&`' : 'repeats `&`';
-    reportInFile(rule.node, `\`@mixin --${rule.mixin}\`: selector \`${rule.selector}\` ${problem}. Write \`&\` once, at the start of the selector (tracker CONV-cssSelectors.ts:351).`);
+    reportInFile(rule.node, 'invalid_parent_selector', `\`@mixin --${rule.mixin}\`: selector \`${rule.selector}\` ${problem}. Write \`&\` once, at the start of the selector (tracker CONV-cssSelectors.ts:351).`);
     return false;
 }
 /** Each link, in the import's order (collectGlobalStyleLinks): no state (:655), no breakpoint (:664), a dashed id (:670) the file declares (:673), once per part (:677). Returns the parts a link names, by mixin. */
@@ -110,26 +112,26 @@ function checkLinks(links, declaredIds, reportInFile) {
         const linkDescription = `\`@mixin --${link.mixin}\`'s link \`@apply ${child}\``;
         const fix = `write it as \`${getSelectorWithoutStates(link.selector)} { @apply ${child} }\``;
         if (hasState(link.selector)) {
-            reportInFile(link.apply, `${linkDescription} can't be under a state or a breakpoint: ${fix} and put the state / breakpoint values in @mixin ${child} (tracker CONV-styleParser.ts:655).`);
+            reportInFile(link.apply, 'conditional_global_style_link', `${linkDescription} can't be under a state or a breakpoint: ${fix} and put the state / breakpoint values in @mixin ${child} (tracker CONV-styleParser.ts:655).`);
             continue;
         }
         if (link.breakpoint) {
-            reportInFile(link.apply, `${linkDescription} can't be under a state or a breakpoint: ${fix} outside \`${describeAtRule(link.breakpoint)}\`, and put the breakpoint values in @mixin ${child} (tracker CONV-styleParser.ts:655).`);
+            reportInFile(link.apply, 'conditional_global_style_link', `${linkDescription} can't be under a state or a breakpoint: ${fix} outside \`${describeAtRule(link.breakpoint)}\`, and put the breakpoint values in @mixin ${child} (tracker CONV-styleParser.ts:655).`);
             continue;
         }
         const part = getPartKey(link);
         linkedParts.add(part);
         const id = getDashedId(child);
         if (!isSafeCssIdentifier(id)) {
-            reportInFile(link.apply, `\`@mixin --${link.mixin}\` links \`${child}\`, which is not a valid global style name: use letters, digits, - and _ (tracker CONV-styleParser.ts:670).`);
+            reportInFile(link.apply, 'invalid_linked_style_id', `\`@mixin --${link.mixin}\` links \`${child}\`, which is not a valid global style name: use letters, digits, - and _ (tracker CONV-styleParser.ts:670).`);
             continue;
         }
         if (!declaredIds.has(id)) {
-            reportInFile(link.apply, `\`@mixin --${link.mixin}\` links \`${child}\`, but the file has no \`@mixin ${child}\`: add it (tracker CONV-styleParser.ts:673).`);
+            reportInFile(link.apply, 'missing_linked_style', `\`@mixin --${link.mixin}\` links \`${child}\`, but the file has no \`@mixin ${child}\`: add it (tracker CONV-styleParser.ts:673).`);
             continue;
         }
         if (validLinkParts.has(part)) {
-            reportInFile(link.apply, `\`@mixin --${link.mixin}\` links two global styles at \`${getPart(link.selector)}\`: keep one (tracker CONV-styleParser.ts:677).`);
+            reportInFile(link.apply, 'duplicate_global_style_link', `\`@mixin --${link.mixin}\` links two global styles at \`${getPart(link.selector)}\`: keep one (tracker CONV-styleParser.ts:677).`);
             continue;
         }
         validLinkParts.add(part);
@@ -142,12 +144,12 @@ function checkLinkOrValues(group, linkedParts, reportInFile) {
     const values = group.filter((rule) => !rule.apply);
     const [first] = group;
     if (link && values.length > 0) {
-        return reportInFile(values[0].node, `\`${first.selector}\` of \`@mixin --${first.mixin}\` has both \`@apply ${link.apply.params.trim()}\` and values: move the values into @mixin ${link.apply.params.trim()} (tracker CONV-styleParser.ts:803).`);
+        return reportInFile(values[0].node, 'link_with_values', `\`${first.selector}\` of \`@mixin --${first.mixin}\` has both \`@apply ${link.apply.params.trim()}\` and values: move the values into @mixin ${link.apply.params.trim()} (tracker CONV-styleParser.ts:803).`);
     }
     const part = getPart(first.selector);
     if (link || part === '' || linkedParts.has(getPartKey(first)))
         return;
-    reportInFile(first.node, `\`@mixin --${first.mixin}\` styles \`${part}\` but links no global style there: add \`& ${part} { @apply --<child> }\` and move the values to that child's @mixin (tracker CONV-styleParser.ts:698).`);
+    reportInFile(first.node, 'missing_global_style_link', `\`@mixin --${first.mixin}\` styles \`${part}\` but links no global style there: add \`& ${part} { @apply --<child> }\` and move the values to that child's @mixin (tracker CONV-styleParser.ts:698).`);
 }
 // ── reading a mixin ──
 /** The mixin's one `@result` with no params and a block, beside nothing; undefined otherwise. */

package/dist/rules/site-app/no-absolute-section.js

@@ -1,7 +1,9 @@
 import { SECTIONS } from "../../rules-api/index.js";
 import { defineRule } from "./define-rule.js";
+const CHECKS = ['absolute_section'];
 export default defineRule({
     name: 'no-absolute-section',
+    checks: CHECKS,
     editors: 'all',
     callbacks: {
         JSXElement: (input) => {
@@ -20,7 +22,7 @@ function getSection({ node, rulesApi }) {
 /** Reports each `position: absolute` the section has, in any CSS, on any part of it, at any @media or @origami-target. */
 function hasNoAbsolutePosition(section, { rulesApi, report }) {
     for (const decl of rulesApi.getCss(section, 'position').filter(isAbsolute)) {
-        report({ loc: section.loc, message: `Section ${section.key} has \`position: absolute\`${describeWhere(decl)}. Sections can't be absolutely positioned.` });
+        report({ check: 'absolute_section', loc: section.loc, message: `Section ${section.key} has \`position: absolute\`${describeWhere(decl)}. Sections can't be absolutely positioned.` });
     }
 }
 // ── reporting ──