@commonplaces/oxlint-plugin 0.3.1 → 0.5.0

package/dist/web/typography.js

@@ -0,0 +1,98 @@
+import { Array, Option, Predicate } from "effect";
+import { report, rule } from "../conventions/shared.js";
+const stringValue = (node) => node.type === "Literal" && Predicate.isString(node.value)
+    ? Option.some(node.value)
+    : node.type === "TemplateElement"
+        ? Option.some(node.value.cooked ?? node.value.raw)
+        : Option.none();
+const classContext = (node) => {
+    const parent = node.parent;
+    if (parent === null)
+        return false;
+    if (parent.type === "JSXAttribute" &&
+        parent.name.type === "JSXIdentifier" &&
+        Array.contains(["class", "className"], parent.name.name))
+        return true;
+    if (parent.type === "CallExpression" &&
+        parent.callee.type === "Identifier" &&
+        Array.contains(["cn", "clsx", "cva", "twMerge"], parent.callee.name))
+        return true;
+    return classContext(parent);
+};
+// Variant colons inside arbitrary selectors/values do not delimit the utility.
+const utility = (text) => {
+    const state = Array.reduce(Array.fromIterable(text), { square: 0, paren: 0, last: -1, index: 0 }, (previous, character) => ({
+        square: character === "["
+            ? previous.square + 1
+            : character === "]"
+                ? Math.max(0, previous.square - 1)
+                : previous.square,
+        paren: character === "("
+            ? previous.paren + 1
+            : character === ")"
+                ? Math.max(0, previous.paren - 1)
+                : previous.paren,
+        last: character === ":" && previous.square === 0 && previous.paren === 0
+            ? previous.index
+            : previous.last,
+        index: previous.index + 1,
+    }));
+    return text
+        .slice(state.last + 1)
+        .replace(/^!|!$/gu, "")
+        .replace(/\/.*$/u, "");
+};
+const typography = [
+    "font-bold",
+    "font-medium",
+    "font-mono",
+    "font-normal",
+    "font-sans",
+    "font-semibold",
+    "leading-none",
+    "leading-normal",
+    "leading-relaxed",
+    "leading-snug",
+    "leading-tight",
+    "text-2xl",
+    "text-3xl",
+    "text-4xl",
+    "text-base",
+    "text-lg",
+    "text-md",
+    "text-sm",
+    "text-xl",
+    "text-xs",
+    "tracking-display",
+    "tracking-loose",
+    "tracking-tight",
+];
+export const typographyRules = {
+    "semantic-typography": rule("Use shared semantic typography primitives instead of local text-size, line-height, tracking and font utility piles.", (context) => {
+        const check = (node) => {
+            if (classContext(node) &&
+                stringValue(node).pipe(Option.exists((value) => Array.some(value.split(/\s+/u), (word) => Array.contains(typography, utility(word))))))
+                report(context, node);
+        };
+        return { Literal: check, TemplateElement: check };
+    }),
+    "gap-layout": rule("Use flex/grid gap rather than sibling-margin space-x/space-y utilities.", (context) => {
+        const check = (node) => {
+            if (classContext(node) &&
+                stringValue(node).pipe(Option.exists((value) => Array.some(value.split(/\s+/u), (word) => /^space-[xy]-/u.test(utility(word))))))
+                report(context, node);
+        };
+        return { Literal: check, TemplateElement: check };
+    }),
+    "safe-type-line-height": rule("Use semantic line-height tokens; reject calculated divisions and ratios below one.", (context) => {
+        const check = (node) => {
+            if (stringValue(node).pipe(Option.exists((value) => Array.some(Array.fromIterable(value.matchAll(/--text-[a-z0-9-]+--line-height\s*:\s*(?<value>[^;"'`\n}]+)/giu)), (match) => {
+                const text = match.groups?.value?.trim() ?? "";
+                const number = Number(text);
+                return (/^calc\([^)]*\/[^)]*\)$/u.test(text) || (Number.isFinite(number) && number < 1));
+            }))))
+                report(context, node);
+        };
+        return { Literal: check, TemplateElement: check };
+    }),
+};

package/dist/web.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@oxlint/plugins").Plugin;
+export default _default;

package/dist/web.js

@@ -0,0 +1,120 @@
+import { eslintCompatPlugin } from "@oxlint/plugins";
+import { Array, Option, Predicate } from "effect";
+import { propertyName } from "./syntax.js";
+import { report, rule } from "./conventions/shared.js";
+import { typographyRules } from "./web/typography.js";
+const nameOf = (node) => node.type === "JSXIdentifier" ? Option.some(node.name) : propertyName(node);
+const routes = (filename) => /(?:^|\/)src\/routes\/.+\.[jt]sx?$/u.test(filename);
+const mdxKeys = [
+    "a",
+    "blockquote",
+    "code",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "hr",
+    "img",
+    "li",
+    "ol",
+    "p",
+    "pre",
+    "table",
+    "tbody",
+    "td",
+    "th",
+    "thead",
+    "tr",
+    "ul",
+];
+export default eslintCompatPlugin({
+    meta: { name: "web" },
+    rules: {
+        ...typographyRules,
+        "no-context-nullish-default": rule("Use canonical Schema-owned metadata and preserve absent values rather than inventing defaults.", (context) => ({
+            LogicalExpression(node) {
+                if (node.operator === "??" &&
+                    node.left.type === "MemberExpression" &&
+                    Option.exists(propertyName(node.left.property), (name) => Array.contains(["description", "image", "title"], name)))
+                    report(context, node);
+            },
+        })),
+        "no-page-wrapper": rule("Compose the route in its owning route component rather than delegating to a page-sized wrapper.", (context) => ({
+            Property(node) {
+                if (routes(context.filename) &&
+                    Option.contains(propertyName(node.key), "component") &&
+                    node.value.type === "Identifier" &&
+                    /^[A-Z][A-Za-z]*Page$/u.test(node.value.name))
+                    report(context, node.value);
+            },
+        })),
+        "no-route-local-seo": rule("Reuse the canonical checked route metadata builder.", (context) => ({
+            CallExpression(node) {
+                if (node.callee.type === "Identifier" && node.callee.name === "seo")
+                    report(context, node);
+            },
+        })),
+        "no-route-local-markdown-negotiation": rule("Keep Markdown negotiation in the application's request middleware owner.", (context) => ({
+            ImportDeclaration(node) {
+                if (/[/]seo-aeo[/]markdown-negotiation$/u.test(node.source.value))
+                    report(context, node);
+            },
+        })),
+        "no-unscoped-server-functions": rule("Use the application's typed runtime boundary rather than creating TanStack server-function wrappers.", (context) => ({
+            ImportDeclaration(node) {
+                if (node.source.value === "@tanstack/react-start")
+                    Array.forEach(node.specifiers, (specifier) => {
+                        if (specifier.type === "ImportSpecifier" &&
+                            Option.exists(propertyName(specifier.imported), (name) => name === "createServerFn" || name === "createServerOnlyFn"))
+                            report(context, specifier);
+                    });
+            },
+        })),
+        "no-route-json-ld": rule("Let the canonical checked metadata owner encode JSON-LD scripts.", (context) => ({
+            Property(node) {
+                if (routes(context.filename) &&
+                    Option.contains(propertyName(node.key), "type") &&
+                    node.value.type === "Literal" &&
+                    node.value.value === "application/ld+json")
+                    report(context, node.value);
+            },
+        })),
+        "no-module-owned-public-asset-url": rule("Import module-owned image and pattern assets through the bundler's module graph.", (context) => ({
+            JSXAttribute(node) {
+                if (Option.contains(nameOf(node.name), "src") &&
+                    node.value?.type === "Literal" &&
+                    Predicate.isString(node.value.value) &&
+                    /^\/(?:images|patterns)\//u.test(node.value.value))
+                    report(context, node.value);
+            },
+        })),
+        "no-http-globals-in-seo": rule("Keep Web HTTP adaptation outside SEO and AEO domain modules.", (context) => ({
+            Identifier(node) {
+                if (/(?:\/(?:seo|seo-aeo)\/|\/packages\/aeo\/)/u.test(context.filename) &&
+                    Array.contains(["Request", "Response", "Headers"], node.name))
+                    report(context, node);
+            },
+        })),
+        "no-local-mdx-registry": rule("Reuse a shared MDX component registry rather than rebuilding it in a route or component.", (context) => ({
+            VariableDeclarator(node) {
+                if (node.id.type === "Identifier" &&
+                    (node.id.name === "mdxComponents" ||
+                        (node.id.name === "components" &&
+                            node.init?.type === "ObjectExpression" &&
+                            Array.some(node.init.properties, (property) => property.type === "Property" &&
+                                Option.exists(propertyName(property.key), (name) => Array.contains(mdxKeys, name))))))
+                    report(context, node.id);
+            },
+            JSXAttribute(node) {
+                if (Option.contains(nameOf(node.name), "components") &&
+                    node.parent.type === "JSXOpeningElement" &&
+                    Option.contains(nameOf(node.parent.name), "MDX") &&
+                    node.value?.type === "JSXExpressionContainer" &&
+                    node.value.expression.type === "ObjectExpression")
+                    report(context, node);
+            },
+        })),
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@commonplaces/oxlint-plugin",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "Shared Oxlint rules for strict Effect TypeScript, Alchemy and repository code.",
   "license": "MIT",
   "author": "Cooper Corbett",
@@ -29,6 +29,14 @@
       "types": "./dist/effect.d.ts",
       "default": "./dist/effect.js"
     },
+    "./conventions": {
+      "types": "./dist/conventions.d.ts",
+      "default": "./dist/conventions.js"
+    },
+    "./web": {
+      "types": "./dist/web.d.ts",
+      "default": "./dist/web.js"
+    },
     "./alchemy": {
       "types": "./dist/alchemy.d.ts",
       "default": "./dist/alchemy.js"
@@ -48,6 +56,10 @@
     "./anti-slop-effect": {
       "types": "./dist/anti-slop/effect/index.d.ts",
       "default": "./dist/anti-slop/effect/index.js"
+    },
+    "./style": {
+      "types": "./dist/style.d.ts",
+      "default": "./dist/style.js"
     }
   },
   "publishConfig": {
@@ -60,18 +72,19 @@
     "prepack": "bun run build"
   },
   "dependencies": {
-    "@oxlint/plugins": "1.80.0",
-    "effect": "4.0.2"
+    "@oxlint/plugins": "1.89.0",
+    "effect": "4.0.5",
+    "ultracite": "8.0.1"
   },
   "devDependencies": {
-    "@effect/platform-node": "4.0.2",
-    "@effect/vitest": "4.0.2",
-    "@types/bun": "1.4.0",
+    "@effect/platform-node": "4.0.5",
+    "@effect/vitest": "4.0.5",
+    "@types/bun": "1.4.3",
     "typescript": "7.0.2",
-    "vitest": "5.0.1"
+    "vitest": "5.0.5"
   },
   "peerDependencies": {
-    "oxlint": "1.80.0 || 1.85.0 || 1.86.0"
+    "oxlint": "1.86.0 || 1.89.0"
   },
   "engines": {
     "node": ">=22.14.0"