@starci/eslint-canon-fe 9.3.0 → 9.4.0

package/comments.mjs

@@ -1,159 +0,0 @@
-/**
- * The rules that hold `comments.md`.
- *
- * Both reach further than their names suggest, and deliberately. An emoji rule that read only JSX
- * would miss the one in a log message, so it walks comments, identifiers, string literals, template
- * chunks and JSX text alike - everywhere prose can hide in a source file.
- *
- * `no-vietnamese-in-source` holds the English-only law: identifiers, string literals, template text, JSX text,
- * comments and test titles carry no Vietnamese letter. There is no exemption marker. Detection is
- * structural on characters (`scripts/lib/language.mjs`, folded to NFC), never a word list.
- *
- * The exceptions that remain are placements, not judgements, and that is on purpose: a locale dictionary
- * IS the other language, and a fixture reproducing a real string has to reproduce it exactly. A
- * judgement-based exception would be argued per file forever. The Vietnamese rule has no placement exemption at all.
- */
-
-import { hasSecondLanguage } from "./runtime/scripts/lib/language.mjs"
-import { jsdocBefore } from "./runtime/scripts/lib/jsdoc.mjs"
-import { fileOf, inSlot } from "./lib/scope.mjs"
-
-/**
- * Extended pictographs, or a regional-indicator pair.
- *
- * Two tests rather than one character class, so the class stays free of joiners and combining marks
- * - a single class covering both trips the misleading-character-class rule, and a rule that has to
- * be silenced to exist is one nobody trusts.
- */
-const hasEmoji = (text) =>
-  typeof text === "string" &&
-  (/\p{Extended_Pictographic}/u.test(text) || /[\u{1F1E6}-\u{1F1FF}]{2}/u.test(text))
-
-/**
- * Files whose second-language text or emoji is CONTENT rather than authoring, decided by what the file IS.
- *
- * One kind only: the locale dictionaries (a `.json` file of an i18n slot, `fe.modules.i18n` or `fe.package.i18n`),
- * which are the product's other language. There is no "copy module": a `resources/` folder of strings is copy that
- * skipped the catalogue.
- *
- * @param {object} context - The ESLint rule context.
- * @returns {boolean} True when the linted file holds content rather than authoring.
- */
-export const isContentFile = (context) => {
-  const file = fileOf(context)
-  return inSlot(context, "fe.modules.i18n", "fe.package.i18n") && file.endsWith(".json")
-}
-
-/** Walk every place prose can hide, and hand each to one check. */
-const proseVisitors = (context, report) => {
-  const source = context.sourceCode || context.getSourceCode()
-  return {
-    Program() {
-      for (const comment of source.getAllComments()) report(comment, comment.value)
-    },
-    Identifier(node) {
-      report(node, node.name)
-    },
-    JSXIdentifier(node) {
-      report(node, node.name)
-    },
-    PrivateIdentifier(node) {
-      report(node, node.name)
-    },
-    Literal(node) {
-      if (typeof node.value === "string") report(node, node.value)
-    },
-    TemplateElement(node) {
-      report(node, node.value && node.value.cooked)
-    },
-    JSXText(node) {
-      report(node, node.value)
-    },
-  }
-}
-
-// -- COMMENTS-1 ------------------------------------------------------------------------------------
-
-/** Every export opens with a documentation block. */
-export const requireExportJsdoc = {
-  meta: {
-    type: "suggestion",
-    docs: { description: "Exported declarations open with a documentation block." },
-    schema: [],
-    messages: {
-      jsdoc:
-        "`{{name}}` is exported without an adjacent JSDoc description. An export is read far more often than it is written, and by people who never open the body - name the ROLE it plays, not the signature, which the signature already states.",
-    },
-  },
-  create(context) {
-    const source = context.sourceCode || context.getSourceCode()
-    const hasBlock = (node) => jsdocBefore(source, node) !== null
-    const check = (node) => {
-      const declaration = node.declaration
-      if (!declaration) return
-      const kinds = ["VariableDeclaration", "TSInterfaceDeclaration", "FunctionDeclaration", "TSTypeAliasDeclaration"]
-      if (!kinds.includes(declaration.type) || hasBlock(node)) return
-      const id =
-        declaration.id || (declaration.declarations && declaration.declarations[0] && declaration.declarations[0].id)
-      context.report({ node: id || declaration, messageId: "jsdoc", data: { name: (id && id.name) || "this export" } })
-    }
-    return { ExportNamedDeclaration: check, ExportDefaultDeclaration: check }
-  },
-}
-
-// -- COMMENTS-4 ------------------------------------------------------------------------------------
-
-/** No Unicode emoji in source: stable product reactions use attributed checked-in SVG artwork. */
-export const noEmojiInSource = {
-  meta: {
-    type: "problem",
-    docs: { description: "No emoji in source authoring." },
-    schema: [],
-    messages: {
-      emoji:
-        "Unicode emoji in source authoring. It renders differently on every platform, sorts unpredictably, breaks a terminal that is not expecting it, and does not mean the same thing in two countries. Generic marks belong to the icon vocabulary; product reactions use the attributed checked-in SVG artwork through the reaction leaf.",
-    },
-  },
-  create(context) {
-    if (isContentFile(context)) return {}
-    return proseVisitors(context, (node, text) => {
-      if (hasEmoji(text)) context.report({ node, messageId: "emoji" })
-    })
-  },
-}
-
-// -- COMMENTS-5 ------------------------------------------------------------------------------------
-
-/** Source prose is English: no Vietnamese letter in an identifier, string, comment, JSX text or test title. */
-export const noVietnameseInSource = {
-  meta: {
-    type: "problem",
-    docs: { description: "No Vietnamese in source authoring, specs included." },
-    schema: [],
-    messages: {
-      vietnamese:
-        "A Vietnamese letter in source. Every reader has to be able to read all of the code, its comments and its test titles, and half of a two-language file is unavailable to somebody. Write it in English; product copy lives in the `messages/<locale>.json` catalogue behind `t()`; there is no pragma.",
-    },
-  },
-  create(context) {
-    return proseVisitors(context, (node, text) => {
-      if (hasSecondLanguage(text)) context.report({ node, messageId: "vietnamese" })
-    })
-  },
-}
-
-/** The rules this law contributes to the plugin. */
-export const rules = {
-  "require-export-jsdoc": requireExportJsdoc,
-  "no-emoji-in-source": noEmojiInSource,
-  "no-vietnamese-in-source": noVietnameseInSource,
-}
-
-/**
- * The level this law asks for, as the plugin's own opinion.
- *
- * `require-export-jsdoc` is the one a repository adopting this with history should expect a count
- * from - every undocumented export in the tree reports at once. The other two are usually already
- * at zero, because a second language in source is noticed by readers long before a rule arrives.
- */
-export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]))

package/control-height.mjs

@@ -1,77 +0,0 @@
-/** CONTROL-HEIGHT-1: one control height; the app never picks a larger step or mixes steps in one row. */
-import { attributeValue, stringOf } from "./lib/ast.mjs"
-import { importOf } from "./lib/bindings.mjs"
-
-const GRAMMAR_ENTRY = /^@starci\/grammar(?:\/(?:common|core|offset-pop))?$/
-const CONTROLS = new Set(["Button", "IconButton", "Switch", "Input", "SearchField", "Select", "Tabs", "SegmentedControl", "Textarea", "NumberField", "ComboBox"])
-/** A marketing hero call to action on a landing page is the one place the 48px step is allowed. */
-const LANDING_PATH = /[\\/](?:landing|hero|marketing)[\\/]|(?:Landing|Hero)[^\\/]*[\\/]/
-/** The default size and its two spellings: the vendor `md` and Grammar's `control` are the same 40px height. */
-const DEFAULT_SIZE = new Set(["md", "control"])
-
-/** The Grammar control a JSX name resolves to; a shadowed or foreign component of the same name is not one. */
-const controlOf = (context, name) => {
-  let root = name
-  const parts = []
-  while (root.type === "JSXMemberExpression") {
-    parts.unshift(root.property.name)
-    root = root.object
-  }
-  if (root.type !== "JSXIdentifier") return null
-  const imported = importOf(context, root)
-  if (!imported || !GRAMMAR_ENTRY.test(imported.source)) return null
-  const role = imported.imported ?? parts.shift()
-  return role !== undefined && parts.length === 0 && CONTROLS.has(role) ? role : null
-}
-
-/** The statically authored size of a control: `control` when absent, null when it is dynamic. */
-const sizeOf = (opening) => {
-  const attribute = opening.attributes.find((entry) => entry.type === "JSXAttribute" && entry.name.name === "size")
-  if (!attribute) return "control"
-  const text = stringOf(attributeValue(attribute))
-  if (text === null) return null
-  return DEFAULT_SIZE.has(text) ? "control" : text
-}
-
-/** The Grammar controls a row holds directly, looking through fragments. */
-const rowControls = (context, element) => element.children.flatMap((child) => {
-  if (child.type === "JSXFragment") return rowControls(context, child)
-  if (child.type !== "JSXElement") return []
-  return controlOf(context, child.openingElement.name) === null ? [] : [child.openingElement]
-})
-
-const controlHeight = {
-  meta: { type: "problem", docs: { description: "CONTROL-HEIGHT-1: one 40px control height, no larger step outside a landing hero, no mixed sizes in one row." }, schema: [], messages: {
-    FE_CONTROL_HEIGHT: "FE_CONTROL_HEIGHT: {{detail}} Grammar draws every standalone control at one 40px height; omit size (sm is for a control nested in an item or a dense toolbar, lg only for a landing hero call to action).",
-  } },
-  create(context) {
-    const landing = LANDING_PATH.test(context.filename)
-    const reported = new Set()
-    const report = (node, detail) => {
-      if (reported.has(node)) return
-      reported.add(node)
-      context.report({ node, messageId: "FE_CONTROL_HEIGHT", data: { detail } })
-    }
-    return {
-      JSXOpeningElement(opening) {
-        const role = controlOf(context, opening.name)
-        if (role === null) return
-        const size = sizeOf(opening)
-        if (size === "xl" || (size === "lg" && !landing)) report(opening, `${role} size="${size}" is a larger control step than the app chrome allows.`)
-      },
-      "JSXElement, JSXFragment"(element) {
-        const controls = rowControls(context, element)
-        const sizes = controls.map(sizeOf)
-        if (sizes.includes(null) || new Set(sizes).size < 2) return
-        const index = sizes.findIndex((size) => size !== sizes[0])
-        report(controls[index], "this control sits in a row with controls of another size.")
-      },
-    }
-  },
-}
-
-/** The one rule of the law. */
-export const rules = { "control-height": controlHeight }
-
-/** The rule reaches consumers at error. */
-export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]))

package/drawing.mjs

@@ -1,321 +0,0 @@
-/**
- * The rules that hold the drawing law (the `drawing` slot role: a surface's pure `component.tsx`).
- *
- * TWO AXES, AND ONLY ONE IS DRAWN. A surface's `state` is its SHAPE: a layout the owner approves as
- * one drawing. A slot's data status (loading, forbidden, error, empty) is not a shape; it is a
- * status recipe applied per resource, and it is never a drawn shape. Mixing the two is what made
- * every block ship four hand-drawn variants that disagreed with each other.
- *
- * THE PURE HALF TAKES ATOMS. `component.tsx` receives `{ state, props, on }`: `props` is data
- * (strings, numbers, booleans, arrays, plain objects), `on` is actions whose arguments are data,
- * and feature composition may also take named `render` callbacks inside `props` to render supplied
- * blocks. A layout alone also takes `children`, because the router puts the page there.
- *
- * ONLY ITS OWN INDEX MAY IMPORT IT. Other tiers use the connected export, so the pure half stays a
- * private drawing surface that audit can render from a fixture.
- *
- * Every rule reads one file. Types imported from elsewhere are trusted as data; only names this
- * file declares are followed, which is exact for the tree the convention produces and silent,
- * never wrong, beyond it.
- */
-
-import { classifyImport, roleOfFile } from "./lib/scope.mjs"
-
-import { inSplitTier, pureHalf } from "./lib/drawing-scope.mjs"
-
-/** Type names that carry a rendered tree rather than data. */
-const NON_ATOM_TYPE = /^(?:ReactNode|ReactElement|ReactPortal|JSX\.Element|Element|ComponentType|FC|FunctionComponent|ElementType|ComponentProps|RenderFunction)$/
-
-/** Feature composition's render callbacks return a rendered value and take only data. */
-const RENDER_RESULT_TYPE = /^(?:ReactNode|ReactElement|JSX\.Element)$/
-const RENDER_PROP_NAME = /^render(?:[A-Z][A-Za-z0-9]*)?$/
-
-/** The printed name of a type reference, qualified names included. */
-const typeNameOf = (node) => {
-  const name = node?.typeName
-  if (!name) return ""
-  if (name.type === "Identifier") return name.name
-  if (name.type === "TSQualifiedName") return `${typeNameOf({ typeName: name.left })}.${name.right.name}`
-  return ""
-}
-
-/** Every type this file declares, by name, so references can be followed locally. */
-const collectLocalTypes = (program) => {
-  const types = new Map()
-  const visit = (statement) => {
-    const declaration = statement?.type === "ExportNamedDeclaration" ? statement.declaration : statement
-    if (declaration?.type === "TSTypeAliasDeclaration") types.set(declaration.id.name, declaration.typeAnnotation)
-    if (declaration?.type === "TSInterfaceDeclaration") types.set(declaration.id.name, declaration.body)
-  }
-  for (const statement of program.body) visit(statement)
-  return types
-}
-
-/** The members of an object-shaped type node, following local names and intersections. */
-const membersOf = (node, types, seen = new Set()) => {
-  if (!node) return []
-  if (node.type === "TSTypeLiteral") return node.members
-  if (node.type === "TSInterfaceBody") return node.body
-  if (node.type === "TSIntersectionType") return node.types.flatMap((part) => membersOf(part, types, seen))
-  if (node.type === "TSTypeReference") {
-    const name = typeNameOf(node)
-    if (seen.has(name) || !types.has(name)) return []
-    seen.add(name)
-    return membersOf(types.get(name), types, seen)
-  }
-  return []
-}
-
-/** The key a property signature declares. */
-const keyOf = (member) => (member.key?.type === "Identifier" ? member.key.name : member.key?.value)
-
-// -- DRAWING-1 ----------------------------------------------------------------------------------
-
-/** The pure half takes atom data and actions; feature composition may receive named render callbacks. */
-export const basePropsAtom = {
-  meta: {
-    type: "problem",
-    docs: { description: "A pure `XBase` takes `shape`, atom `props` and `on` actions; feature composition may receive named render callbacks in `props`." },
-    schema: [],
-    messages: {
-      tree:
-        "`{{path}}` hands a rendered tree (`{{type}}`) into the pure half. Write the child inside `component.tsx` and pass it atoms (ids, strings, flags); a tree handed in cannot be drawn, audited or reused.",
-      action:
-        "`{{path}}` is a function inside `props`. Actions live in `on`; feature composition may receive named `render` callbacks that take atoms and return rendered blocks.",
-      onData:
-        "`on.{{key}}` is not an action. `on` holds functions only; data belongs in `props`.",
-      member:
-        "`{{key}}` is not part of the pure contract. A pure half takes `shape`, `props` and `on`{{children}}.",
-      renamed:
-        "`state` is the retired name of the drawn shape: rename it `shape` (owner ruling fe-shape-not-state).",
-    },
-  },
-  create(context) {
-    const tier = pureHalf(context)
-    if (!tier) return {}
-    let types = new Map()
-
-    /** Resolve render results locally; an optional empty result does not make data a render prop. */
-    const isRenderResult = (node, seen = new Set()) => {
-      if (!node) return false
-      if (node.type === "TSUnionType") {
-        const empty = (part) => ["TSNullKeyword", "TSUndefinedKeyword"].includes(part.type)
-          || part.type === "TSLiteralType" && part.literal.value === null
-        return node.types.some((part) => isRenderResult(part, new Set(seen)))
-          && node.types.every((part) => empty(part) || isRenderResult(part, new Set(seen)))
-      }
-      if (node.type !== "TSTypeReference") return false
-      const name = typeNameOf(node)
-      if (RENDER_RESULT_TYPE.test(name.replace(/^React\./, ""))) return true
-      if (!types.has(name) || seen.has(name)) return false
-      return isRenderResult(types.get(name), new Set(seen).add(name))
-    }
-
-    const checkRenderCallback = (node, path, allowed) => {
-      if (!allowed || !isRenderResult(node.returnType?.typeAnnotation)) return false
-      for (const parameter of node.params ?? node.parameters ?? []) {
-        checkData(parameter.typeAnnotation?.typeAnnotation, `${path}(${parameter.name ?? "arg"})`, new Set(), false, true)
-      }
-      return true
-    }
-
-    const checkDataReference = (node, path, seen, renderProp, renderParameter) => {
-      const name = typeNameOf(node)
-      if (NON_ATOM_TYPE.test(renderParameter ? name.replace(/^React\./, "") : name)) {
-        context.report({ node, messageId: "tree", data: { path, type: name } })
-        return
-      }
-      for (const argument of node.typeArguments?.params ?? node.typeParameters?.params ?? []) checkData(argument, path, seen, false, renderParameter)
-      if (types.has(name) && !seen.has(name)) {
-        const nextSeen = renderProp || renderParameter ? new Set(seen) : seen
-        nextSeen.add(name)
-        checkData(types.get(name), path, nextSeen, renderProp, renderParameter)
-      }
-    }
-
-    const checkDataMember = (member, path, seen, renderParameter) => {
-      const memberPath = `${path}.${keyOf(member)}`
-      const allowsRender = tier !== "blocks" && path === "props" && RENDER_PROP_NAME.test(keyOf(member))
-      if (member.type === "TSMethodSignature") {
-        if (!checkRenderCallback(member, memberPath, allowsRender)) context.report({ node: member, messageId: "action", data: { path: memberPath } })
-      } else if (member.type === "TSPropertySignature") {
-        checkData(member.typeAnnotation?.typeAnnotation, memberPath, seen, allowsRender, renderParameter)
-      }
-    }
-
-    /** Walk a data type: report trees and functions anywhere inside it. */
-    const checkData = (node, path, seen, renderProp = false, renderParameter = false) => {
-      if (!node) return
-      switch (node.type) {
-        case "TSFunctionType":
-          if (checkRenderCallback(node, path, renderProp)) return
-          context.report({ node, messageId: "action", data: { path } })
-          return
-        case "TSTypeReference":
-          checkDataReference(node, path, seen, renderProp, renderParameter)
-          return
-        case "TSUnionType":
-        case "TSIntersectionType":
-          for (const part of node.types) checkData(part, path, seen, renderProp, renderParameter)
-          return
-        case "TSArrayType":
-          checkData(node.elementType, path, seen, false, renderParameter)
-          return
-        case "TSTypeOperator":
-          checkData(node.typeAnnotation, path, seen, false, renderParameter)
-          return
-        case "TSTypeLiteral":
-        case "TSInterfaceBody":
-          for (const member of node.members ?? node.body) checkDataMember(member, path, seen, renderParameter)
-          return
-        default:
-      }
-    }
-
-    /** Walk `on`: every member is a function whose parameters are data. */
-    const checkActions = (node) => {
-      for (const member of membersOf(node, types)) {
-        const key = keyOf(member)
-        const type = member.type === "TSMethodSignature" ? member : member.typeAnnotation?.typeAnnotation
-        if (type?.type !== "TSFunctionType" && type?.type !== "TSMethodSignature") {
-          context.report({ node: member, messageId: "onData", data: { key } })
-          continue
-        }
-        for (const parameter of type.params ?? type.parameters ?? []) {
-          checkData(parameter.typeAnnotation?.typeAnnotation, `on.${key}(${parameter.name ?? "arg"})`, new Set())
-        }
-      }
-    }
-
-    return {
-      Program(node) {
-        types = collectLocalTypes(node)
-      },
-      VariableDeclarator(node) {
-        if (node.id?.type !== "Identifier" || !/^[A-Z][A-Za-z0-9]*Base$/.test(node.id.name)) return
-        const fn = node.init
-        if (fn?.type !== "ArrowFunctionExpression" && fn?.type !== "FunctionExpression") return
-        const annotation = fn.params?.[0]?.typeAnnotation?.typeAnnotation
-        for (const member of membersOf(annotation, types)) {
-          const key = keyOf(member)
-          const type = member.typeAnnotation?.typeAnnotation
-          if (key === "shape") continue
-          if (key === "state") {
-            context.report({ node: member, messageId: "renamed" })
-            continue
-          }
-          if (key === "props") checkData(type, "props", new Set())
-          else if (key === "on") checkActions(type)
-          else if (key === "children" && tier === "layouts") continue
-          else {
-            context.report({
-              node: member,
-              messageId: "member",
-              data: { key, children: tier === "layouts" ? ", plus the router's `children`" : "" },
-            })
-          }
-        }
-      },
-    }
-  },
-}
-
-// -- DRAWING-2 ----------------------------------------------------------------------------------
-
-/** Only the sibling `index.tsx` (and its specs) may reach `component.tsx`; only `X` leaves the folder. */
-export const baseImportPair = {
-  meta: {
-    type: "problem",
-    docs: { description: "A pure `component.tsx` is imported only by its sibling `index.tsx`, which never re-exports `XBase`." },
-    schema: [],
-    messages: {
-      reach:
-        "`{{source}}` reaches into another surface's pure half. Import that surface's connected export from its folder; the pure half is a private drawing surface.",
-      reexport:
-        "`index.tsx` re-exports `{{name}}`. The folder exports only its connected `X`; the pure `XBase` stays behind it so no other tier can bypass the owner.",
-    },
-  },
-  create(context) {
-    const isOwnIndex = roleOfFile(context) === "entry"
-    const inTier = inSplitTier(context)
-    // An import reaches a pure half when the file it resolves to has the `drawing` role of its slot.
-    const reachesPure = (source) => classifyImport(context, source)?.role === "drawing"
-
-    const check = (node, source) => {
-      if (typeof source !== "string" || !reachesPure(source)) return
-      const isSibling = /^\.\/[^/]+$/.test(source)
-      if (isSibling && isOwnIndex) return
-      if (isSibling && !inTier) return
-      context.report({ node, messageId: "reach", data: { source } })
-    }
-
-    return {
-      ImportDeclaration(node) {
-        check(node, node.source?.value)
-      },
-      ExportAllDeclaration(node) {
-        check(node, node.source?.value)
-      },
-      ExportNamedDeclaration(node) {
-        const source = node.source?.value
-        if (!source) return
-        check(node, source)
-        if (!isOwnIndex || !inTier || node.exportKind === "type") return
-        for (const specifier of node.specifiers ?? []) {
-          const name = specifier.exported?.name ?? specifier.local?.name
-          if (specifier.exportKind !== "type" && /^[A-Z][A-Za-z0-9]*Base$/.test(name)) {
-            context.report({ node: specifier, messageId: "reexport", data: { name } })
-          }
-        }
-      },
-    }
-  },
-}
-
-// -- DRAWING-3 ----------------------------------------------------------------------------------
-
-/** Words that name a data status or an open/closed lifecycle, never a drawn shape. */
-const DATA_STATUS = new Set([
-  "pending", "loading", "failed", "error", "errored", "empty", "forbidden", "unavailable",
-  "skeleton", "closed", "idle", "refreshing", "retrying",
-])
-
-/** A surface's `XShape` names shapes only. */
-export const noDataStatusShape = {
-  meta: {
-    type: "problem",
-    docs: { description: "`XShape` of a pure half names drawn shapes, never a data status or open/closed." },
-    schema: [],
-    messages: {
-      status:
-        "`{{name}}` lists \"{{value}}\" as a shape. Loading, forbidden, error and empty describe resource status: pass them as data to the owned status renderer. Open/closed is a boolean atom. A shape is a layout the owner approves as one drawing.",
-    },
-  },
-  create(context) {
-    if (!pureHalf(context)) return {}
-    const check = (name, node) => {
-      const members = node?.type === "TSUnionType" ? node.types : [node]
-      for (const member of members) {
-        const value = member?.type === "TSLiteralType" ? member.literal?.value : undefined
-        if (typeof value === "string" && DATA_STATUS.has(value)) {
-          context.report({ node: member, messageId: "status", data: { name, value } })
-        }
-      }
-    }
-    return {
-      TSTypeAliasDeclaration(node) {
-        if (/^[A-Z][A-Za-z0-9]*(?:Shape|State)$/.test(node.id.name)) check(node.id.name, node.typeAnnotation)
-      },
-    }
-  },
-}
-
-/** The rules this law contributes to the plugin. */
-export const rules = {
-  "base-props-atom": basePropsAtom,
-  "base-import-pair": baseImportPair,
-  "no-data-status-shape": noDataStatusShape,
-}
-
-/** Every FE canon rule is an error; existing debt is fixed before adoption. */
-export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]))