@geonosis/oxlint-plugin-biological-architecture 3.0.0 → 3.2.0

package/dist/rules/hermetic-e2e-no-wall-clock-waits.js

@@ -0,0 +1,100 @@
+// src/rules/hermetic-e2e-no-wall-clock-waits.ts
+import { calleeNameOf, propertyNameOf, walkNode } from "./lib/nodes.js";
+import { normalise } from "./lib/paths.js";
+import { bagOf, firstOf, pathMatching } from "./lib/probe.js";
+import { optionsBag, STRINGS } from "./lib/schema.js";
+var SPECS = [String.raw`(?:^|/)e2e[^/]*/.*\.(?:spec|test)\.[cm]?[jt]sx?$`];
+var CLOCK_WAITS = ["setTimeout", "waitForTimeout"];
+var NETWORK_WAITS = ["waitForResponse"];
+var calledName = (node) => {
+  const callee = node.callee;
+  return calleeNameOf(node) ?? (callee === undefined ? null : propertyNameOf(callee));
+};
+var textsIn = (nodes) => {
+  const found = [];
+  walkNode(nodes, (node) => {
+    if (node.type === "Literal") {
+      const regex = node.regex;
+      if (typeof regex?.pattern === "string")
+        found.push(regex.pattern);
+      else if (typeof node.value === "string")
+        found.push(node.value);
+    }
+    if (node.type === "TemplateLiteral") {
+      for (const quasi of node.quasis ?? []) {
+        found.push(quasi.value?.raw ?? "");
+      }
+    }
+  });
+  return found;
+};
+var hermeticE2eNoWallClockWaits = {
+  create(context) {
+    const options = bagOf(context.options);
+    const specs = options.specs ?? SPECS;
+    if (!specs.some((pattern) => new RegExp(pattern).test(normalise(context.filename))))
+      return {};
+    const clockWaits = new Set(options.clockWaits ?? CLOCK_WAITS);
+    const networkWaits = new Set(options.networkWaits ?? NETWORK_WAITS);
+    const endpoints = (options.listEndpoints ?? []).map((pattern) => new RegExp(pattern));
+    return {
+      CallExpression(node) {
+        const call = calledName(node);
+        if (call === null)
+          return;
+        if (clockWaits.has(call)) {
+          context.report({ data: { call }, messageId: "clockWait", node });
+          return;
+        }
+        if (!networkWaits.has(call) || endpoints.length === 0)
+          return;
+        const endpoint = textsIn(node.arguments).find((text) => endpoints.some((pattern) => pattern.test(text)));
+        if (endpoint !== undefined) {
+          context.report({ data: { call, endpoint }, messageId: "listResponseWait", node });
+        }
+      }
+    };
+  },
+  fixShape: `An end-to-end spec waits for the state it asserts on, never for a time and never for the network
+event that merely precedes it. \`page.waitForTimeout(500)\` or a promise sleep guesses how long the
+page needs; the guess passes on a fast machine and flakes on a slow one. \`waitForResponse\` on a LIST
+endpoint is the same guess with a better alibi: the response arriving says the request finished, not
+that the page merged the rows into what the user sees. Assert on the page instead — a web-first
+assertion on the element the data produces retries until it holds: \`await
+expect(page.getByRole('row', { name })).toBeVisible()\`. The specs are the files \`specs\` names
+(default: spec files under an \`e2e*\` directory), the calls that sleep are \`clockWaits\` (default
+\`waitForTimeout\`, \`setTimeout\`), and the list endpoints whose response may not stand in for the
+page are the regexes in \`listEndpoints\`, with \`networkWaits\` naming the calls that wait on one
+(default \`waitForResponse\`); with no \`listEndpoints\` the response waits are not judged.`,
+  meta: {
+    docs: {
+      description: 'In an end-to-end spec, a fixed-time wait (`waitForTimeout`, a `setTimeout` sleep) guesses how long the page needs, and a `waitForResponse` on a list endpoint stands in for "the live data was merged" when only the page can say so. Assert on the page state instead. The spec files, the sleeping calls, the waiting calls and the list endpoints are options; the response wait is judged only for endpoints the repo names.'
+    },
+    messages: {
+      clockWait: "`{{call}}` waits for a time, not for a state: it passes when the machine is fast and flakes when it is slow. Wait for the state the next step needs — a web-first assertion on the element it produces retries until it holds.",
+      listResponseWait: "`{{call}}` on a list endpoint ({{endpoint}}) treats the response arriving as the data being shown, and the page merges it later: a race. Assert on what the page renders — a web-first assertion on the element the data produces retries until it holds."
+    },
+    schema: optionsBag({
+      clockWaits: STRINGS,
+      listEndpoints: STRINGS,
+      networkWaits: STRINGS,
+      specs: STRINGS
+    }),
+    type: "problem"
+  },
+  probe(options) {
+    const bag = bagOf(options);
+    const call = firstOf(bag.clockWaits, ["waitForTimeout"]);
+    return {
+      path: pathMatching(firstOf(bag.specs, SPECS), "geonosis-probe.spec.ts"),
+      source: `export const geonosisProbe = async (page) => {
+  await page.${call}(500)
+}
+`
+    };
+  }
+};
+var hermetic_e2e_no_wall_clock_waits_default = hermeticE2eNoWallClockWaits;
+export {
+  hermetic_e2e_no_wall_clock_waits_default as default
+};

package/dist/rules/icon-control-has-name.d.ts

@@ -0,0 +1,53 @@
+import type { RuleContextWithRawOptions } from './lib/context.js';
+import { type Probe } from './lib/probe.js';
+type Name = {
+    name?: string;
+    object?: Name;
+    property?: Name;
+    type: string;
+};
+type Attribute = {
+    name?: Name;
+    type: string;
+};
+type Child = {
+    children?: Child[];
+    openingElement?: {
+        attributes?: Attribute[];
+        name: Name;
+    };
+    type: string;
+    value?: string;
+};
+declare const iconControlHasName: {
+    create(context: RuleContextWithRawOptions): {
+        JSXElement(node: Child): void;
+    };
+    fixShape: string;
+    meta: {
+        docs: {
+            description: string;
+        };
+        messages: {
+            unnamed: string;
+        };
+        schema: {
+            additionalProperties: boolean;
+            properties: {
+                controls: {
+                    items: {
+                        type: 'string';
+                    };
+                    type: 'array';
+                };
+                icons: {
+                    type: 'string';
+                };
+            };
+            type: 'object';
+        }[];
+        type: 'problem';
+    };
+    probe(options: readonly unknown[]): Probe;
+};
+export default iconControlHasName;

package/dist/rules/icon-control-has-name.js

@@ -0,0 +1,71 @@
+// src/rules/icon-control-has-name.ts
+import { bagOf, firstOf } from "./lib/probe.js";
+import { optionsBag, STRING, STRINGS } from "./lib/schema.js";
+var NATIVE_CONTROLS = ["button", "a"];
+var ICONS = "Icon$";
+var NAMED_BY = new Set(["aria-label", "aria-labelledby", "title"]);
+var ICON_NAMED_BY = new Set(["aria-label", "aria-labelledby"]);
+var nameOf = (node) => node === undefined ? "" : node.type === "JSXMemberExpression" ? `${nameOf(node.object)}.${nameOf(node.property)}` : node.name ?? "";
+var said = (child) => child.type !== "JSXText" || (child.value ?? "").trim() !== "";
+var namesItself = (icon) => icon.type === "JSXElement" && ((icon.openingElement?.attributes ?? []).some((one) => one.type === "JSXAttribute" && ICON_NAMED_BY.has(nameOf(one.name))) || nameOf(icon.openingElement?.name) === "svg" && (icon.children ?? []).some((one) => nameOf(one.openingElement?.name) === "title"));
+var iconControlHasName = {
+  create(context) {
+    const options = bagOf(context.options);
+    const controls = new Set([...NATIVE_CONTROLS, ...options.controls ?? []]);
+    const icon = new RegExp(options.icons ?? ICONS);
+    return {
+      JSXElement(node) {
+        const control = nameOf(node.openingElement?.name);
+        if (!controls.has(control))
+          return;
+        const attributes = node.openingElement?.attributes ?? [];
+        if (attributes.some((one) => one.type !== "JSXAttribute" || NAMED_BY.has(nameOf(one.name)))) {
+          return;
+        }
+        const shown = (node.children ?? []).filter(said);
+        if (shown.some(namesItself))
+          return;
+        const icons = shown.map((one) => one.type === "JSXElement" ? nameOf(one.openingElement?.name) : "");
+        if (icons.length === 0 || !icons.every((name) => name === "svg" || icon.test(name)))
+          return;
+        context.report({
+          data: { control, icons: icons.join(", ") },
+          messageId: "unnamed",
+          node
+        });
+      }
+    };
+  },
+  fixShape: `A control whose only content is an icon has no name: the icon is decorative, so a screen reader
+announces "button" and nothing else. Give it \`aria-label\` (or \`aria-labelledby\`, or \`title\`) in the
+app's own words — a label prop the caller passes, never a string the component invents — or put text
+beside the icon, visible or \`sr-only\`. \`<button>\` and \`<a>\` are read by default; \`controls\` names the
+repo's control atoms, and \`icons\` is the pattern an icon component's name matches (\`Icon$\` by default);
+an inline \`<svg>\` is always one.
+An icon that carries its own \`aria-label\` or \`aria-labelledby\` (an icon component must forward it to its
+svg), or an \`<svg>\` holding a \`<title>\`, names the control; a \`title\` attribute on an icon does not. A
+spread may carry the name and is left alone.`,
+  meta: {
+    docs: {
+      description: "A button or link whose only content is an icon component, with no `aria-label`, `aria-labelledby` or `title`, has no accessible name — a screen reader announces a control that says nothing."
+    },
+    messages: {
+      unnamed: "<{{control}}> shows only {{icons}} and has no name a screen reader can read. Give it aria-label in the words the app passes in, or text beside the icon."
+    },
+    schema: optionsBag({ controls: STRINGS, icons: STRING }),
+    type: "problem"
+  },
+  probe(options) {
+    const bag = bagOf(options);
+    const control = firstOf(bag.controls, NATIVE_CONTROLS);
+    return {
+      path: "molecules/geonosis-probe.tsx",
+      source: `export const Probe = () => <${control}><svg /></${control}>
+`
+    };
+  }
+};
+var icon_control_has_name_default = iconControlHasName;
+export {
+  icon_control_has_name_default as default
+};

package/dist/rules/layer-walls.d.ts

@@ -1,30 +1,14 @@
 import { type RuleContextWithOptions } from './lib/context.js';
 import { type Probe } from './lib/probe.js';
 interface Layer {
-    /** Layer names this one may import. A layer may always import itself; this lists the others. */
     mayImport?: string[];
     name: string;
-    /** Regex sources, tested against the normalised filename and against an import's source. */
     paths: string[];
-    /** This layer's own answer to the rule-wide `typeOnly`, for the reason written there. */
     typeOnly?: 'count' | 'skip';
 }
 interface Options {
-    /**
-     * Whether a bare package specifier or a `node:` builtin counts as crossing a wall. It does not by
-     * default: a layer that may import no other layer still runs on a machine with a filesystem, and
-     * a rule that called `node:path` a breach would be unusable in every repo that has one.
-     */
     externals?: 'allow' | 'deny';
     layers?: Layer[];
-    /**
-     * D-034's named exception, and the default every layer keeps unless it says otherwise. A type the
-     * bundler erases is not a dependency, and three packages in this repo borrow one across a wall on
-     * purpose so their runtime graph stays clean. `count` is for walls that are about KNOWLEDGE
-     * rather than weight — a package floor, where `import type { Document }` in a foundation is the
-     * upward reach the floors exist to forbid, compiled away or not. One repo has both kinds, so a
-     * layer may override this for its own files.
-     */
     typeOnly?: 'count' | 'skip';
 }
 declare const layerWalls: {
@@ -83,15 +67,6 @@ declare const layerWalls: {
         }[];
         type: 'problem';
     };
-    /**
-     * A file in one declared layer importing a specifier that lands in another it may not reach.
-     *
-     * Both halves come out of the same regex sources the walls are written in — the filename from the
-     * layer it must sit in, the import from the layer it must not reach — and both are re-tested
-     * against the patterns they were built from. A pair the inversion cannot express is a sentence
-     * rather than a silent zero: the walls are a repo's own vocabulary, so there is no fixture
-     * anywhere that could stand in for them.
-     */
     probe(options: readonly unknown[]): Probe;
 };
 export default layerWalls;

package/dist/rules/layer-walls.js

@@ -8,25 +8,19 @@ import { onImportSource } from "./lib/visitors.js";
 var isExternal = (source) => !isRelative(source) && !source.startsWith("/");
 var PROBE_TARGET = "geonosis-probe-target.ts";
 var PROBE_WALL = "geonosis-probe-wall.ts";
-var inverts = (pattern, leaf) => {
+var invert = (pattern, leaf) => {
   try {
-    pathMatching(pattern, leaf);
-    return true;
+    return pathMatching(pattern, leaf);
   } catch {
-    return false;
+    return;
   }
 };
 var placeIn = (paths, tried) => {
   for (const pattern of paths) {
-    let candidate;
-    try {
-      candidate = pathMatching(pattern, PROBE_WALL);
-    } catch {
-      tried.push(pattern);
-      continue;
-    }
-    if (new RegExp(pattern).test(`/repo-root/${candidate}`))
+    const candidate = invert(pattern, PROBE_WALL);
+    if (candidate !== undefined && new RegExp(pattern).test(`/repo-root/${candidate}`)) {
       return candidate;
+    }
     tried.push(pattern);
   }
   return;
@@ -113,7 +107,7 @@ rule reports that once a run and judges nothing: walls nobody declared are not w
     const tried = [];
     for (const here of layers) {
       const mayImport = new Set(here.mayImport ?? []);
-      const targetPath = layers.filter((other) => other.name !== here.name && !mayImport.has(other.name)).flatMap((other) => other.paths).find((one) => inverts(one, PROBE_TARGET));
+      const targetPath = layers.filter((other) => other.name !== here.name && !mayImport.has(other.name)).flatMap((other) => other.paths).find((one) => invert(one, PROBE_TARGET) !== undefined);
       const path = placeIn(here.paths, tried);
       if (targetPath === undefined || path === undefined)
         continue;

package/dist/rules/lib/atom-map.d.ts

@@ -0,0 +1,24 @@
+export interface Restriction {
+    atom: string;
+    element: string;
+    importPath: string;
+}
+export declare const ATOM_MAP_SCHEMA: {
+    items: {
+        properties: {
+            atom: {
+                type: 'string';
+            };
+            element: {
+                type: 'string';
+            };
+            importPath: {
+                type: 'string';
+            };
+        };
+        required: string[];
+        type: 'object';
+    };
+    type: 'array';
+};
+export declare const atomMapOf: (options: readonly unknown[]) => Restriction[];

package/dist/rules/lib/atom-map.js

@@ -0,0 +1,16 @@
+// src/rules/lib/atom-map.ts
+import { STRING } from "./schema.js";
+var ATOM_MAP_SCHEMA = {
+  items: {
+    properties: { atom: STRING, element: STRING, importPath: STRING },
+    required: ["element", "atom", "importPath"],
+    type: "object"
+  },
+  type: "array"
+};
+var isRestriction = (value) => typeof value === "object" && value !== null && ("atom" in value) && typeof value.atom === "string" && ("element" in value) && typeof value.element === "string" && ("importPath" in value) && typeof value.importPath === "string";
+var atomMapOf = (options) => Array.isArray(options[0]) ? options[0].filter(isRestriction) : [];
+export {
+  ATOM_MAP_SCHEMA,
+  atomMapOf
+};

package/dist/rules/lib/cells-barrel.d.ts

@@ -1,2 +1 @@
-/** Takes a path already normalised to forward slashes. */
 export declare const isCellsBarrel: (path: string) => boolean;

package/dist/rules/lib/colors.d.ts

@@ -1,23 +1,4 @@
-/**
- * What counts as a colour written out.
- *
- * A CSS fact, not a repo fact, so it lives in code rather than in an option (law 6 is about a
- * repo's brands, features and tables — the notations CSS accepts for a colour are the same
- * everywhere). Every one of them is here because a brand escapes through all of them equally: the
- * component that hardcodes `oklch(0.91 0.17 102)` stops following the theme exactly as completely
- * as the one that hardcodes `#ffe849`.
- */
-/** A whole value that is one written-out colour: `#ff0000`, `rgb(1 2 3)`, `tan`. */
 export declare const isColorLiteral: (value: string) => boolean;
-/**
- * A colour written out ANYWHERE inside a value — for the shorthands.
- *
- * `border: '1px solid #ff0000'` and `boxShadow: '0 1px 2px rgba(0,0,0,.2)'` hardcode a colour just
- * as thoroughly as `color` does, and a check that only looked at whole values would pass both.
- * Named colours are deliberately NOT searched for here: `1px solid tan` is real and so is a
- * `transition` naming a property, and a substring search over 148 English words inside a free-form
- * value is how a rule earns its reputation for false positives.
- */
 export declare const containsColorLiteral: (value: string) => boolean;
 export declare const isColorProperty: (property: string) => boolean;
 export declare const isColorShorthand: (property: string) => boolean;

package/dist/rules/lib/colors.js

@@ -1,257 +1,24 @@
 // src/rules/lib/colors.ts
-var FUNCTIONS = [
-  "color",
-  "color-mix",
-  "hsl",
-  "hsla",
-  "hwb",
-  "lab",
-  "lch",
-  "oklab",
-  "oklch",
-  "rgb",
-  "rgba"
-];
+var words = (list) => new Set(list.split(" "));
 var HEX = /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
-var FUNCTION_CALL = new RegExp(`\\b(?:${FUNCTIONS.join("|")})\\(`, "i");
+var FUNCTION_NAMES = "color|color-mix|hsl|hsla|hwb|lab|lch|oklab|oklch|rgb|rgba";
+var FUNCTION_CALL = new RegExp(`\\b(?:${FUNCTION_NAMES})\\(`, "i");
+var FUNCTION_START = new RegExp(`^(?:${FUNCTION_NAMES})\\(`, "i");
 var HEX_ANYWHERE = /(?:^|[\s(,])#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})\b/i;
-var NAMED = new Set([
-  "aliceblue",
-  "antiquewhite",
-  "aqua",
-  "aquamarine",
-  "azure",
-  "beige",
-  "bisque",
-  "black",
-  "blanchedalmond",
-  "blue",
-  "blueviolet",
-  "brown",
-  "burlywood",
-  "cadetblue",
-  "chartreuse",
-  "chocolate",
-  "coral",
-  "cornflowerblue",
-  "cornsilk",
-  "crimson",
-  "cyan",
-  "darkblue",
-  "darkcyan",
-  "darkgoldenrod",
-  "darkgray",
-  "darkgreen",
-  "darkgrey",
-  "darkkhaki",
-  "darkmagenta",
-  "darkolivegreen",
-  "darkorange",
-  "darkorchid",
-  "darkred",
-  "darksalmon",
-  "darkseagreen",
-  "darkslateblue",
-  "darkslategray",
-  "darkslategrey",
-  "darkturquoise",
-  "darkviolet",
-  "deeppink",
-  "deepskyblue",
-  "dimgray",
-  "dimgrey",
-  "dodgerblue",
-  "firebrick",
-  "floralwhite",
-  "forestgreen",
-  "fuchsia",
-  "gainsboro",
-  "ghostwhite",
-  "gold",
-  "goldenrod",
-  "gray",
-  "green",
-  "greenyellow",
-  "grey",
-  "honeydew",
-  "hotpink",
-  "indianred",
-  "indigo",
-  "ivory",
-  "khaki",
-  "lavender",
-  "lavenderblush",
-  "lawngreen",
-  "lemonchiffon",
-  "lightblue",
-  "lightcoral",
-  "lightcyan",
-  "lightgoldenrodyellow",
-  "lightgray",
-  "lightgreen",
-  "lightgrey",
-  "lightpink",
-  "lightsalmon",
-  "lightseagreen",
-  "lightskyblue",
-  "lightslategray",
-  "lightslategrey",
-  "lightsteelblue",
-  "lightyellow",
-  "lime",
-  "limegreen",
-  "linen",
-  "magenta",
-  "maroon",
-  "mediumaquamarine",
-  "mediumblue",
-  "mediumorchid",
-  "mediumpurple",
-  "mediumseagreen",
-  "mediumslateblue",
-  "mediumspringgreen",
-  "mediumturquoise",
-  "mediumvioletred",
-  "midnightblue",
-  "mintcream",
-  "mistyrose",
-  "moccasin",
-  "navajowhite",
-  "navy",
-  "oldlace",
-  "olive",
-  "olivedrab",
-  "orange",
-  "orangered",
-  "orchid",
-  "palegoldenrod",
-  "palegreen",
-  "paleturquoise",
-  "palevioletred",
-  "papayawhip",
-  "peachpuff",
-  "peru",
-  "pink",
-  "plum",
-  "powderblue",
-  "purple",
-  "rebeccapurple",
-  "red",
-  "rosybrown",
-  "royalblue",
-  "saddlebrown",
-  "salmon",
-  "sandybrown",
-  "seagreen",
-  "seashell",
-  "sienna",
-  "silver",
-  "skyblue",
-  "slateblue",
-  "slategray",
-  "slategrey",
-  "snow",
-  "springgreen",
-  "steelblue",
-  "tan",
-  "teal",
-  "thistle",
-  "tomato",
-  "turquoise",
-  "violet",
-  "wheat",
-  "white",
-  "whitesmoke",
-  "yellow",
-  "yellowgreen"
-]);
+var NAMED = words("aliceblue antiquewhite aqua aquamarine azure beige bisque black blanchedalmond blue blueviolet brown burlywood cadetblue chartreuse chocolate coral cornflowerblue cornsilk crimson cyan darkblue darkcyan darkgoldenrod darkgray darkgreen darkgrey darkkhaki darkmagenta darkolivegreen darkorange darkorchid darkred darksalmon darkseagreen darkslateblue darkslategray darkslategrey darkturquoise darkviolet deeppink deepskyblue dimgray dimgrey dodgerblue firebrick floralwhite forestgreen fuchsia gainsboro ghostwhite gold goldenrod gray green greenyellow grey honeydew hotpink indianred indigo ivory khaki lavender lavenderblush lawngreen lemonchiffon lightblue lightcoral lightcyan lightgoldenrodyellow lightgray lightgreen lightgrey lightpink lightsalmon lightseagreen lightskyblue lightslategray lightslategrey lightsteelblue lightyellow lime limegreen linen magenta maroon mediumaquamarine mediumblue mediumorchid mediumpurple mediumseagreen mediumslateblue mediumspringgreen mediumturquoise mediumvioletred midnightblue mintcream mistyrose moccasin navajowhite navy oldlace olive olivedrab orange orangered orchid palegoldenrod palegreen paleturquoise palevioletred papayawhip peachpuff peru pink plum powderblue purple rebeccapurple red rosybrown royalblue saddlebrown salmon sandybrown seagreen seashell sienna silver skyblue slateblue slategray slategrey snow springgreen steelblue tan teal thistle tomato turquoise violet wheat white whitesmoke yellow yellowgreen");
 var isColorLiteral = (value) => {
   const trimmed = value.trim();
   if (trimmed === "")
     return false;
-  if (HEX.test(trimmed))
-    return true;
-  if (NAMED.has(trimmed.toLowerCase()))
-    return true;
-  return new RegExp(`^(?:${FUNCTIONS.join("|")})\\(`, "i").test(trimmed);
+  return HEX.test(trimmed) || NAMED.has(trimmed.toLowerCase()) || FUNCTION_START.test(trimmed);
 };
 var containsColorLiteral = (value) => HEX_ANYWHERE.test(value) || FUNCTION_CALL.test(value);
-var COLOR_PROPERTIES = new Set([
-  "accentColor",
-  "backgroundColor",
-  "borderBlockColor",
-  "borderBlockEndColor",
-  "borderBlockStartColor",
-  "borderBottomColor",
-  "borderColor",
-  "borderInlineColor",
-  "borderInlineEndColor",
-  "borderInlineStartColor",
-  "borderLeftColor",
-  "borderRightColor",
-  "borderTopColor",
-  "caretColor",
-  "color",
-  "columnRuleColor",
-  "fill",
-  "floodColor",
-  "lightingColor",
-  "outlineColor",
-  "stopColor",
-  "stroke",
-  "textDecorationColor",
-  "textEmphasisColor",
-  "WebkitTextFillColor",
-  "WebkitTextStrokeColor",
-  "webkitTextFillColor",
-  "webkitTextStrokeColor"
-]);
-var COLOR_SHORTHANDS = new Set([
-  "background",
-  "border",
-  "borderBottom",
-  "borderLeft",
-  "borderRight",
-  "borderTop",
-  "boxShadow",
-  "columnRule",
-  "filter",
-  "outline",
-  "textDecoration",
-  "textShadow"
-]);
+var COLOR_PROPERTIES = words("accentColor backgroundColor borderBlockColor borderBlockEndColor borderBlockStartColor borderBottomColor borderColor borderInlineColor borderInlineEndColor borderInlineStartColor borderLeftColor borderRightColor borderTopColor caretColor color columnRuleColor fill floodColor lightingColor outlineColor stopColor stroke textDecorationColor textEmphasisColor WebkitTextFillColor WebkitTextStrokeColor webkitTextFillColor webkitTextStrokeColor");
+var COLOR_SHORTHANDS = words("background border borderBottom borderLeft borderRight borderTop boxShadow columnRule filter outline textDecoration textShadow");
 var isColorProperty = (property) => COLOR_PROPERTIES.has(property);
 var isColorShorthand = (property) => COLOR_SHORTHANDS.has(property);
-var COLOR_UTILITIES = new Set([
-  "accent",
-  "bg",
-  "border",
-  "border-b",
-  "border-e",
-  "border-l",
-  "border-r",
-  "border-s",
-  "border-t",
-  "border-x",
-  "border-y",
-  "caret",
-  "decoration",
-  "divide",
-  "fill",
-  "from",
-  "inset-ring",
-  "inset-shadow",
-  "outline",
-  "placeholder",
-  "ring",
-  "ring-offset",
-  "shadow",
-  "stroke",
-  "text",
-  "to",
-  "via"
-]);
-var isColorUtility = (utility) => COLOR_UTILITIES.has(utility.replace(/^.*:/, ""));
+var COLOR_UTILITIES = words("accent bg border border-b border-e border-l border-r border-s border-t border-x border-y caret decoration divide fill from inset-ring inset-shadow outline placeholder ring ring-offset shadow stroke text to via");
+var isColorUtility = (utility) => COLOR_UTILITIES.has(utility);
 export {
   containsColorLiteral,
   isColorLiteral,

package/dist/rules/lib/comments.d.ts

@@ -0,0 +1,19 @@
+export type Comment = {
+    loc: {
+        end: {
+            line: number;
+        };
+        start: {
+            line: number;
+        };
+    };
+    type: string;
+    value: string;
+};
+export type SourceCode = {
+    ast?: {
+        comments?: Comment[];
+    };
+    getAllComments?: () => Comment[];
+};
+export declare const commentsOf: (sourceCode: SourceCode | undefined) => Comment[];

package/dist/rules/lib/comments.js

@@ -0,0 +1,5 @@
+// src/rules/lib/comments.ts
+var commentsOf = (sourceCode) => sourceCode?.getAllComments?.() ?? sourceCode?.ast?.comments ?? [];
+export {
+  commentsOf
+};