@starci/eslint-grammar-core 0.13.0 → 0.14.0

package/lib/app-shell-owner.mjs

@@ -1,83 +0,0 @@
-/** Imported shell-band delegation requires its canonical composition in every visible source alternative. */
-import { functionOf, importOf } from "@starci/eslint-canon-fe/lib/bindings.mjs"
-import { isBarControl, propOf, resolveLocal, textProp } from "./app-shell.mjs"
-import { isNavigationDrawer } from "./app-shell-scope.mjs"
-import { visitFunction, visitVisible } from "./app-shell-visible.mjs"
-import { headerProofs, importedHeader } from "./app-shell-owner-source.mjs"
-
-const OVERLAYS = new Set(["Dialog", "AlertDialog", "Drawer", "Popover", "DropdownMenu", "Tooltip"])
-
-const importBinding = (context, opening) => {
-  const name = opening.name.type === "JSXMemberExpression" ? opening.name.object : opening.name
-  return name.type === "JSXIdentifier" ? importOf(context, name) : null
-}
-
-const reactFragment = (context, opening) => {
-  const imported = importBinding(context, opening)
-  return imported?.source === "react" && (imported.imported === "Fragment" || opening.name.type === "JSXMemberExpression" && opening.name.property.name === "Fragment")
-}
-
-const proveOwner = (owner, seen, kind) => {
-  if (!owner) return false
-  const { context, value } = owner
-  const key = `${kind}:${context.filename}:${value.range?.join(":")}`
-  const proofs = headerProofs(context)
-  if (proofs.has(key)) return proofs.get(key)
-  if (seen.has(key)) return false
-  const fn = functionOf(context, resolveLocal(context, value))
-  const valid = Boolean(fn) && proveComposition(context, (visit, branch) => visitFunction(context, fn, visit, new Set(), branch, []), new Set(seen).add(key), kind)
-  proofs.set(key, valid)
-  return valid
-}
-
-/** Drawer bodies must expose navigation on every branch, outside nested overlay content. */
-const proveDrawerBody = (context, opening, seen) => proveComposition(context, (visit, branch) => {
-  const children = opening.parent.children.filter((child) => child.type !== "JSXText" || child.value.trim())
-  if (children.length) for (const child of children) visitVisible(context, child, visit, new Set(), branch)
-  else visitVisible(context, propOf(context, opening, "children").value, visit, new Set(), branch)
-}, seen, "sidebar")
-
-const matchesComposition = (context, opening, name, seen, kind) => {
-  if (kind === "drawer") return isNavigationDrawer(context, opening) && proveDrawerBody(context, opening, seen)
-  if (kind === "sidebar") return name === "Sidebar" && textProp(context, opening, "presentation") === "drawer"
-  return ["TopBar", "NavigationFeatureNav"].includes(name)
-}
-
-const proveComposition = (context, render, seen, kind) => {
-  const pending = [new Map()]
-  while (pending.length) {
-    const choices = pending.pop()
-    const branch = []
-    let found = false
-    let unknown = false
-    render((opening, name) => {
-      if (reactFragment(context, opening)) return
-      if (matchesComposition(context, opening, name, seen, kind)) { found = true; return false }
-      if (OVERLAYS.has(name)) return false
-      if (kind === "bar" && (["header", "nav", "main"].includes(name) || isBarControl(context, opening, name))) { unknown = true; return false }
-      if (name === null && importBinding(context, opening)) {
-        if (proveOwner(importedHeader(context, opening), seen, kind)) found = true
-        else unknown = true
-        return false
-      }
-    }, (node) => {
-      if (!choices.has(node)) branch.push(node)
-      return choices.get(node) ?? "consequent"
-    })
-    const missing = branch.find((node) => !choices.has(node))
-    if (missing) pending.push(new Map([...choices, [missing, "alternate"]]), new Map([...choices, [missing, "consequent"]]))
-    else if (!found || unknown) return false
-  }
-  return true
-}
-
-/** True only for an imported JSX header whose owned implementation reaches a canonical Grammar bar. */
-export const provesImportedBar = (context, opening) => {
-  if (reactFragment(context, opening)) return null
-  if (!importBinding(context, opening)) return null
-  return proveOwner(importedHeader(context, opening), new Set(), "bar")
-}
-
-/** True only when every visible compact-header alternative reaches a left Drawer with a drawer Sidebar. */
-export const provesNavigationOpener = (context, expression) => proveComposition(context,
-  (visit, branch) => visitVisible(context, expression, visit, new Set(), branch), new Set(), "drawer")

package/lib/app-shell-scope.mjs

@@ -1,79 +0,0 @@
-/** Structural app-shell ownership, distinct from generic flow-based site chrome. */
-import { walk } from "@starci/eslint-canon-fe/lib/ast.mjs"
-import { kindOfFile, roleOfFile } from "@starci/eslint-canon-fe/lib/scope.mjs"
-import { grammarName, propOf, textProp } from "./app-shell.mjs"
-import { visitVisible } from "./app-shell-visible.mjs"
-
-/** A workspace identity or a sidebar/navigation slot identifies an application shell structurally. */
-export const isAppShell = (context, opening) => {
-  if (grammarName(context, opening) !== "WorkspaceShell") return false
-  const viewport = textProp(context, opening, "viewport")
-  if (viewport === "fixed" || viewport !== "flow" && ownsAppFrame(context, opening)) return true
-  const navigation = propOf(context, opening, "navigation")
-  if (navigation.value !== null || !navigation.known) return true
-  let identity = false
-  visitVisible(context, propOf(context, opening, "header").value, (_node, name) => {
-    if (name === "IdentityLockup") identity = true
-  })
-  return identity
-}
-
-/** A left Drawer containing a drawer Sidebar is the mobile navigation opener, including an extracted client owner. */
-export const isNavigationDrawer = (context, opening) => {
-  if (grammarName(context, opening) !== "Drawer" || textProp(context, opening, "placement") !== "left") return false
-  let sidebar = false
-  const inspect = (node, name) => {
-    if (name === "Sidebar" && textProp(context, node, "presentation") === "drawer") sidebar = true
-  }
-  for (const child of opening.parent.children) visitVisible(context, child, inspect)
-  visitVisible(context, propOf(context, opening, "children").value, inspect)
-  return sidebar
-}
-
-/** Shell-named React owners and the HFS layout kind compose an app frame, rather than page-local navigation. */
-export const ownsAppFrame = (context, node) => {
-  if (kindOfFile(context) === "layouts" || roleOfFile(context) === "layout") return true
-  let rendered = null
-  let shellName = false
-  for (let current = node.parent; current; current = current.parent) {
-    if (current.type === "ReturnStatement") rendered = current.argument
-    if (current.type === "FunctionDeclaration") { shellName = /Shell(?:Base)?$/.test(current.id?.name ?? ""); break }
-    if (current.type === "ArrowFunctionExpression" || current.type === "FunctionExpression") {
-      rendered ??= current.body
-      shellName = current.parent?.type === "VariableDeclarator" && /Shell(?:Base)?$/.test(current.parent.id.name ?? "")
-      break
-    }
-  }
-  if (shellName) return true
-  let sidebar = false
-  visitVisible(context, rendered, (_opening, name) => { if (name === "Sidebar") sidebar = true })
-  return sidebar
-}
-
-const APP_BAR_CACHE = new WeakMap()
-
-/** Every visible opening hosted by a structurally identified app shell in this source file. */
-export const appBarOpenings = (context) => {
-  const source = context.sourceCode
-  if (APP_BAR_CACHE.has(source)) return APP_BAR_CACHE.get(source)
-  const openings = new Set()
-  walk(source, source.ast, (node) => {
-    if (node.type !== "JSXOpeningElement" || !isAppShell(context, node)) return
-    for (const slot of ["header", "compactHeader"]) {
-      visitVisible(context, propOf(context, node, slot).value, (opening) => { openings.add(opening) })
-    }
-  })
-  APP_BAR_CACHE.set(source, openings)
-  return openings
-}
-
-/** Grammar bars are app bars unless an explicit generic flow shell establishes site-chrome ownership. */
-export const isAppBar = (context, opening) => {
-  if (!["TopBar", "NavigationFeatureNav"].includes(grammarName(context, opening))) return false
-  for (let current = opening.parent; current; current = current.parent) {
-    if (current.type !== "JSXElement") continue
-    const shell = current.openingElement
-    if (grammarName(context, shell) === "WorkspaceShell" && textProp(context, shell, "viewport") === "flow" && !isAppShell(context, shell)) return false
-  }
-  return true
-}

package/lib/app-shell-visible.mjs

@@ -1,92 +0,0 @@
-/** Traverse only the visible bar composition and its local React owners. */
-import { functionOf, variableOf } from "@starci/eslint-canon-fe/lib/bindings.mjs"
-import { grammarName, propOf, resolveLocal } from "./app-shell.mjs"
-
-const BAR_SLOTS = {
-  WorkspaceShell: ["header", "compactHeader"],
-  TopBar: ["brand", "navigation", "actions"],
-  NavigationFeatureNav: ["identity", "navigation", "actions", "compactNavigationTrigger"],
-  DropdownMenu: ["trigger"],
-  Popover: ["trigger"],
-  Drawer: ["trigger"],
-}
-
-/** Visible JSX composition only: menu, popover and drawer bodies are outside the navbar band. */
-export const visitVisible = (context, expression, visit, seen = new Set(), branch = () => "both", ancestors = []) => {
-  const node = resolveLocal(context, expression)
-  if (!node || seen.has(node)) return
-  const visited = new Set(seen).add(node)
-  const next = (child) => visitVisible(context, child, visit, visited, branch, ancestors)
-  switch (node.type) {
-    case "JSXExpressionContainer": next(node.expression); break
-    case "JSXFragment": for (const child of node.children) next(child); break
-    case "ConditionalExpression": visitConditional(node, next, branch); break
-    case "LogicalExpression": visitLogical(context, node, next, branch); break
-    case "ArrayExpression": for (const item of node.elements) next(item); break
-    case "JSXElement": visitElement(context, node, visit, visited, branch, ancestors); break
-  }
-}
-
-const visitConditional = (node, next, branch) => {
-  const choice = branch(node)
-  if (choice !== "alternate") next(node.consequent)
-  if (choice !== "consequent") next(node.alternate)
-}
-
-const visitLogical = (context, node, next, branch) => {
-  const left = resolveLocal(context, node.left)
-  const known = left?.type === "Literal"
-  let right = node.operator === "&&" ? Boolean(left?.value) : !left?.value
-  if (node.operator === "??") right = left?.value === null
-  if (!known) {
-    const choice = branch(node)
-    if (choice === "both") { next(node.left); next(node.right); return }
-    right = choice === "consequent"
-  }
-  next(right ? node.right : node.left)
-}
-
-const visitElement = (context, node, visit, seen, branch, ancestors) => {
-  const opening = node.openingElement
-  const name = grammarName(context, opening)
-  if (visit(opening, name, ancestors) === false) return
-  const inside = [...ancestors, opening]
-  const next = (child) => visitVisible(context, child, visit, seen, branch, inside)
-  if (name === null && opening.name.type === "JSXIdentifier") {
-    const fn = functionOf(context, resolveLocal(context, opening.name)) ?? variableOf(context, opening.name)?.defs.find((definition) => definition.type === "FunctionName")?.node
-    if (fn) visitFunction(context, fn, visit, seen, branch, inside)
-  }
-  const slots = BAR_SLOTS[name]
-  if (slots) for (const slot of slots) next(propOf(context, opening, slot).value)
-  if (["DropdownMenu", "Popover", "Drawer"].includes(name)) return
-  for (const child of node.children) next(child)
-}
-
-/** Visit a rendered owner's returns with the same branch, overlay and local-binding semantics as inline JSX. */
-export const visitFunction = (context, fn, visit, seen, branch, ancestors) => {
-  if (fn.body.type !== "BlockStatement") return visitVisible(context, fn.body, visit, seen, branch, ancestors)
-  visitStatements(context, fn.body.body, visit, seen, branch, ancestors)
-}
-
-const visitStatements = (context, statements, visit, seen, branch, ancestors) => {
-  for (const statement of statements) {
-    if (statement.type === "ReturnStatement") {
-      visitVisible(context, statement.argument, visit, seen, branch, ancestors)
-      return true
-    }
-    if (statement.type === "BlockStatement" && visitStatements(context, statement.body, visit, seen, branch, ancestors)) return true
-    if (statement.type === "IfStatement") {
-      if (visitIf(context, statement, visit, seen, branch, ancestors)) return true
-    }
-  }
-  return false
-}
-
-const visitIf = (context, statement, visit, seen, branch, ancestors) => {
-  const condition = resolveLocal(context, statement.test)
-  let choice = branch(statement)
-  if (condition?.type === "Literal") choice = condition.value ? "consequent" : "alternate"
-  const consequent = choice !== "alternate" && visitStatements(context, [statement.consequent], visit, seen, branch, ancestors)
-  const alternate = choice !== "consequent" && statement.alternate && visitStatements(context, [statement.alternate], visit, seen, branch, ancestors)
-  return choice === "consequent" && consequent || choice === "alternate" && alternate || consequent && alternate
-}

package/lib/app-shell.mjs

@@ -1,148 +0,0 @@
-/** Static readers for the visible Grammar app-bar composition, including local JSX owners. */
-import { attributeValue, stringOf } from "@starci/eslint-canon-fe/lib/ast.mjs"
-import { functionOf, importOf, unwrap, variableOf } from "@starci/eslint-canon-fe/lib/bindings.mjs"
-
-const GRAMMAR_SOURCE = /^@starci\/grammar(?:\/|$)/
-/** Grammar controls whose visible hit target belongs to the navbar band's size contract. */
-const BAR_CONTROLS = new Set(["Button", "IconButton", "Switch", "AvatarButton", "PlainPressable", "IdentityLockup", "SearchField", "Input", "TextField", "Select", "TextAction"])
-const BAR_WRAPPERS = new Set(["GrammarRoot", "WorkspaceShell", "TopBar", "NavigationFeatureNav", "Region", "PageContainer", "NavLandmark", "Form", "Fieldset", "Field", "ButtonGroup", "DropdownMenu", "Popover", "Drawer", "Tooltip"])
-const ACTION_PROPS = ["onPress", "onClick", "onAction", "onValueChange", "onSelectionChange", "onSelectedChange", "onChange", "onInputChange"]
-const INTERACTION_PROPS = new Set(["label", "value", "defaultValue", "selectedKey", "selectedKeys", "selectionMode", "href", ...ACTION_PROPS])
-
-/** Bar policy also counts labelled/value/selection/action field owners, so an extra control cannot vanish from the cluster. */
-export const isBarControl = (context, opening, name) => {
-  if (BAR_CONTROLS.has(name)) return true
-  if (!name || !/^[A-Z]/.test(name) || BAR_WRAPPERS.has(name)) return false
-  if (opening.attributes.some((entry) => entry.type === "JSXAttribute" && INTERACTION_PROPS.has(entry.name.name))) return true
-  return [...INTERACTION_PROPS].some((prop) => propOf(context, opening, prop).value !== null)
-}
-/** A literal or constant's initializer, without type-only wrappers. */
-export const resolveLocal = (context, expression, seen = new Set()) => {
-  const node = unwrap(expression)
-  if (node?.type === "MemberExpression") return resolveMember(context, node, seen)
-  if (node?.type === "CallExpression") return resolveCall(context, node, seen)
-  if (!["Identifier", "JSXIdentifier"].includes(node?.type) || seen.has(node)) return node
-  const definition = variableOf(context, node)?.defs.find((entry) => entry.type === "Variable")
-  if (!definition || definition.parent?.kind !== "const") return node
-  seen.add(node)
-  return resolveLocal(context, initializerOf(definition.node, node), seen)
-}
-
-const resolveCall = (context, node, seen) => {
-  if (seen.has(node)) return node
-  seen.add(node)
-  const fn = functionOf(context, resolveLocal(context, node.callee, seen))
-  if (!fn) return node
-  if (fn.body.type !== "BlockStatement") return resolveLocal(context, fn.body, seen)
-  if (fn.body.body.some((statement) => !["VariableDeclaration", "ReturnStatement"].includes(statement.type))) return node
-  const returned = fn.body.body.find((statement) => statement.type === "ReturnStatement")
-  return returned ? resolveLocal(context, returned.argument, seen) : node
-}
-
-const resolveMember = (context, node, seen) => {
-  const key = node.computed ? stringOf(node.property) : node.property.name
-  if (!key) return node
-  const property = objectValue(context, node.object, key, seen)
-  return property.known && property.value !== null ? resolveLocal(context, property.value, seen) : node
-}
-
-const initializerOf = (declaration, node) => {
-  if (declaration.id.type === "ObjectPattern") {
-    const property = declaration.id.properties.find((entry) => entry.type === "Property" && entry.value.name === node.name)
-    if (!property) return node
-    return { type: "MemberExpression", object: declaration.init, property: property.key, computed: property.computed }
-  }
-  return declaration.init
-}
-
-/** The imported Grammar component's name; aliases and namespace imports keep their identity. */
-export const grammarName = (context, opening) => {
-  const name = opening.name
-  if (name.type === "JSXIdentifier") {
-    const canonical = expressionName(context, name)
-    if (canonical) return canonical
-    return variableOf(context, name)?.defs.length ? null : name.name
-  }
-  if (name.type !== "JSXMemberExpression" || name.object.type !== "JSXIdentifier") return null
-  return expressionName(context, { type: "MemberExpression", object: name.object, property: name.property, computed: false })
-}
-
-const expressionName = (context, expression) => {
-  const resolved = resolveLocal(context, expression)
-  if (resolved?.type === "MemberExpression") {
-    return namespaceName(context, resolved.object, resolved.computed ? stringOf(resolved.property) : resolved.property.name)
-  }
-  if (!["Identifier", "JSXIdentifier"].includes(resolved?.type)) return null
-  const imported = importOf(context, resolved)
-  return imported && GRAMMAR_SOURCE.test(imported.source) ? imported.imported : null
-}
-
-const namespaceName = (context, expression, property) => {
-  const object = resolveLocal(context, expression)
-  if (!["Identifier", "JSXIdentifier"].includes(object?.type)) return null
-  const imported = importOf(context, object)
-  return imported && GRAMMAR_SOURCE.test(imported.source) ? property : null
-}
-
-const objectValue = (context, expression, name, seen = new Set()) => {
-  const node = resolveLocal(context, expression)
-  if (node?.type === "ConditionalExpression") return conditionalObjectValue(context, node, name, seen)
-  if (node?.type !== "ObjectExpression" || seen.has(node)) return { known: false, value: null }
-  seen.add(node)
-  let result = { known: true, value: null }
-  for (const property of node.properties) {
-    if (property.type === "SpreadElement") {
-      const spread = objectValue(context, property.argument, name, seen)
-      if (!spread.known || spread.value !== null) result = spread
-    } else if (!property.computed && (property.key.name ?? property.key.value) === name) {
-      result = { known: true, value: property.value }
-    }
-  }
-  return result
-}
-
-const conditionalObjectValue = (context, node, name, seen) => {
-  if (seen.has(node)) return { known: false, value: null }
-  const visited = new Set(seen).add(node)
-  const values = [node.consequent, node.alternate].map((branch) => objectValue(context, branch, name, new Set(visited)))
-  return { known: values.every((value) => value.known && value.value === null), value: null }
-}
-
-/** The effective prop, respecting JSX spread order; unknown later spreads cannot prove a value. */
-export const propOf = (context, opening, name) => {
-  let result = { known: true, value: null }
-  for (const entry of opening.attributes) {
-    if (entry.type === "JSXSpreadAttribute") {
-      const spread = objectValue(context, entry.argument, name)
-      if (!spread.known || spread.value !== null) result = spread
-    } else if (entry.name.name === name) result = { known: true, value: attributeValue(entry), present: true }
-  }
-  return result
-}
-
-/** A statically proven string prop, or null for missing/unknown values. */
-export const textProp = (context, opening, name) => {
-  const prop = propOf(context, opening, name)
-  return prop.known ? stringOf(resolveLocal(context, prop.value)) : null
-}
-
-/** The source spelling is semantic evidence for an icon or action whose translated label is dynamic. */
-export const semanticText = (context, opening) => {
-  const values = ["source", "icon", "label", "aria-label", "id", ...ACTION_PROPS].map((name) => {
-    const prop = propOf(context, opening, name)
-    return prop.value ? context.sourceCode.getText(prop.value) : ""
-  })
-  return values.join(" ")
-}
-
-/** The right-cluster role and the Grammar kind that must draw it. */
-export const clusterRole = (context, opening, name) => {
-  if (name === "Switch") return "theme"
-  if (name === "AvatarButton") return "account"
-  const text = semanticText(context, opening)
-  if (/language|locale|translate/i.test(text)) return "language"
-  if (/notification|bell/i.test(text)) return "notifications"
-  if (/account|avatar|profile/i.test(text)) return "account"
-  if (/theme|darkmode|color.?mode/i.test(text)) return "theme"
-  return null
-}

package/lib/rule-contract.mjs

@@ -1,11 +0,0 @@
-/** The ordered ownership test that governs every Grammar-specific lint rule. */
-export const RULE_OWNERSHIP = "knowledge/patterns/fe/index.yaml#FE-RULE-OWNERSHIP"
-
-/** Attach the governing ownership rule and the rule's behavioral source without changing enforcement. */
-export const defineFamilyRules = (rules, knowledge) => {
-  for (const rule of Object.values(rules)) {
-    const source = rule.meta.docs?.url ?? knowledge
-    rule.meta.docs = { ...rule.meta.docs, url: source, knowledge: source, ownership: RULE_OWNERSHIP }
-  }
-  return rules
-}

package/lib/status-tones.generated.mjs

@@ -1,9 +0,0 @@
-// Generated by packages/stylelint-canon/lib/write-vocabulary.mjs from packages/grammar/src. Do not edit: run `npm run vocabulary` in packages/stylelint-canon.
-
-/** The status tones of the grammar: each has a solid pair and a soft pair (`--<tone>-soft`, `--<tone>-soft-foreground`). */
-export const STATUS_TONES = [
-  "success",
-  "warning",
-  "danger",
-  "info",
-]

package/lib/why.mjs

@@ -1,38 +0,0 @@
-/** Failure-code guidance for the selected Grammar family contract. */
-export const why = {
-  "app-shell-frame": {
-    code: "FE_APP_SHELL_FRAME",
-    en: "The app frame must use Grammar WorkspaceShell with its fixed viewport.",
-    fix: "Compose WorkspaceShell viewport=\"fixed\" and supply its header, navigation and primary slots.",
-  },
-  "navbar-cluster": {
-    code: "FE_NAVBAR_CLUSTER",
-    en: "Navbar action component kinds or order differ from the app-shell canon.",
-    fix: "Compose Language IconButton, theme Switch, notification IconButton and account AvatarButton in that order.",
-  },
-  "navbar-control-size": {
-    code: "FE_NAVBAR_CONTROL_SIZE",
-    en: "A navbar control does not use Grammar's shared control height.",
-    fix: "Set size=\"control\" on every visible bar control.",
-  },
-  "no-navbar-create": {
-    code: "FE_NAVBAR_CREATE",
-    en: "A create action is composed into the global navbar.",
-    fix: "Move the create action to the page that owns it.",
-  },
-  "no-raw-structural-element": {
-    code: "FE_NATIVE_FORM_CONTROL",
-    en: "Raw `<tag>` in `<file>`. Page structure and text are composed from grammar components, not hand-written HTML.",
-    fix: "Replace it with the matching grammar component (`Heading`, `Text`, `SurfaceCard`, ...); if grammar lacks it, add it to grammar or the ui package instead of drawing it in place.",
-  },
-  "no-shell-bottom-tabs": {
-    code: "FE_APP_SHELL_BOTTOM_TABS",
-    en: "Bottom tab navigation replaces the required mobile sidebar drawer.",
-    fix: "Use WorkspaceShell navigationDrawer and Sidebar presentation=\"drawer\".",
-  },
-  "status-text-uses-soft-foreground": {
-    code: "FE_STYLE_TOKEN_ONLY",
-    en: "`<file>` paints text or an icon with a solid status tone (`<what>`, e.g. `text-success`). A solid tone is a background colour; used as a text colour it reads below 4.5:1 on the page background.",
-    fix: "Switch to the soft pair: `text-<tone>-soft-foreground` (with `bg-<tone>-soft` when it sits on a light surface); a solid tone is used only with `bg-<tone>` and `text-<tone>-foreground`.",
-  },
-}

package/menu-entries.mjs

@@ -1,146 +0,0 @@
-/**
- * The menu entries a product hands to Grammar's `DropdownMenu`.
- *
- * HeroUI colours a destructive menu item through its `danger` variant, which Grammar exposes as `tone: "danger"`. An entry the app
- * forgets to tone reads like any other command: sign out and delete sit beside "Settings" in the same ink, and the one click that
- * cannot be taken back gets no mark. The decision is the entry's meaning, so it is checked where the entry is written: an entry whose
- * id or label says it signs out, deletes, removes, leaves or revokes carries `tone: "danger"`.
- *
- * The terms are this canon's own list, English and Vietnamese. They are compared as whole words after the text is lower-cased, split
- * at `-`, `_` and camelCase, and stripped of diacritics (the Vietnamese for "sign out" with its tone marks is `dang xuat`), so `signOut`, `sign-out`,
- * `Sign out` and the tone-marked Vietnamese spelling are one term.
- *
- * WHERE IT LOOKS. A menu entry is an object literal in the `entries` attribute of a `DropdownMenu`, or in a declaration typed as
- * `DropdownMenuEntry`, `DropdownMenuItem` or `DropdownMenuSection` (an array of them too), including the `items` of a section and the
- * `submenu` of an item. Anything it cannot see through (a spread, a call) it leaves alone: the rule refuses to guess.
- */
-
-import { resolveLocal } from "./lib/app-shell.mjs"
-import { stringOf } from "@starci/eslint-canon-fe/lib/ast.mjs"
-import { isProductSource } from "@starci/eslint-canon-fe/lib/scope.mjs"
-import { defineFamilyRules } from "./lib/rule-contract.mjs"
-
-/** The English terms of a destructive entry. */
-const DESTRUCTIVE_TERMS_EN = Object.freeze([
-  "sign out", "log out", "logout", "signout",
-  "delete", "remove", "erase", "destroy", "discard", "purge",
-  "leave workspace", "leave team", "leave group", "leave organization", "leave project", "leave channel", "leave course", "revoke", "deactivate", "disconnect", "unlink", "unsubscribe", "terminate",
-  "close account", "cancel subscription", "cancel plan",
-])
-
-/** The Vietnamese terms, written without diacritics (the text is compared after the diacritics are stripped). */
-const DESTRUCTIVE_TERMS_VI = Object.freeze([
-  "dang xuat", "xoa", "xoa bo", "go bo", "loai bo", "roi khoi", "roi nhom", "thu hoi",
-  "vo hieu hoa", "ngat ket noi", "huy dang ky", "huy goi", "cham dut", "dong tai khoan",
-])
-
-/** A destructive term as a whole word or phrase of the normalized text. */
-const DESTRUCTIVE_PATTERN = new RegExp(String.raw`(?:^|\s)(?:${[...DESTRUCTIVE_TERMS_EN, ...DESTRUCTIVE_TERMS_VI].map((term) => term.replaceAll(" ", String.raw`\s+`)).join("|")})(?=\s|$)`)
-
-/** The text lower-cased, split at separators and camelCase, with diacritics stripped. */
-export const normalizeText = (text) =>
-  text
-    .replaceAll(/([a-z0-9])([A-Z])/g, "$1 $2")
-    .replaceAll(/[-_./:]+/g, " ")
-    .toLowerCase()
-    .replaceAll("\u0111", "d")
-    .normalize("NFD")
-    .replaceAll(/\p{M}+/gu, "")
-    .replaceAll(/\s+/g, " ")
-    .trim()
-
-/** True when the id or label text names a destructive command. */
-export const isDestructiveText = (text) => DESTRUCTIVE_PATTERN.test(normalizeText(text))
-
-const MENU_TYPES = new Set(["DropdownMenuEntry", "DropdownMenuItem", "DropdownMenuSection"])
-
-/** The value node of the property called `name` in an object literal, or null. */
-const propertyValue = (object, name) =>
-  object.properties.find((entry) => entry.type === "Property" && !entry.computed && (entry.key.name === name || entry.key.value === name))?.value ?? null
-
-/** The element type of an array type (`T[]`, `readonly T[]`, `ReadonlyArray<T>`), else the type itself. */
-const elementTypeOf = (type) => {
-  if (type.type === "TSTypeOperator") return elementTypeOf(type.typeAnnotation)
-  if (type.type === "TSArrayType") return type.elementType
-  const isArrayName = type.type === "TSTypeReference" && type.typeName.type === "Identifier" && (type.typeName.name === "ReadonlyArray" || type.typeName.name === "Array")
-  return isArrayName ? (type.typeArguments ?? type.typeParameters)?.params[0] ?? type : type
-}
-
-/** True when the type annotation names a menu entry type or an array of one. */
-const isMenuType = (annotation) => {
-  const type = annotation?.typeAnnotation
-  if (!type) return false
-  const element = elementTypeOf(type)
-  return element.type === "TSTypeReference" && element.typeName.type === "Identifier" && MENU_TYPES.has(element.typeName.name)
-}
-
-/** Every possible value must prove danger; an unresolved value cannot mark a destructive action. */
-const provesDangerTone = (context, expression, seen = new Set()) => {
-  const node = resolveLocal(context, expression)
-  if (!node || seen.has(node)) return false
-  if (node.type !== "ConditionalExpression") return stringOf(node) === "danger"
-  const visited = new Set(seen).add(node)
-  return [node.consequent, node.alternate].every((branch) => provesDangerTone(context, branch, visited))
-}
-
-/** Report an entry (an object literal), then walk the `items` of a section and the `submenu` of an item. */
-function visitEntries(context, node, report) {
-  if (!node) return
-  if (node.type === "ArrayExpression") {
-    for (const element of node.elements) visitEntries(context, element, report)
-    return
-  }
-  if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression") {
-    visitEntries(context, node.expression, report)
-    return
-  }
-  if (node.type !== "ObjectExpression") return
-  const kind = stringOf(propertyValue(node, "kind"))
-  if (kind === "section") {
-    visitEntries(context, propertyValue(node, "items"), report)
-    return
-  }
-  const text = [stringOf(propertyValue(node, "id")), stringOf(propertyValue(node, "label"))].filter((value) => value !== null)
-  const tone = propertyValue(node, "tone")
-  const toned = provesDangerTone(context, tone)
-  if (!toned && text.some(isDestructiveText)) report(node, text.find(isDestructiveText))
-  visitEntries(context, propertyValue(node, "submenu"), report)
-}
-
-/** A destructive menu entry carries `tone: "danger"`. */
-export const destructiveMenuEntryNeedsDangerTone = {
-  meta: {
-    type: "problem",
-    docs: { description: "A menu entry whose id or label signs out, deletes, removes, leaves or revokes carries `tone: \"danger\"`." },
-    schema: [],
-    messages: {
-      tone:
-        "The menu entry `{{text}}` is destructive but has no `tone: \"danger\"`. HeroUI colours the label and glyph of a danger item so the one click that cannot be taken back is marked; without the tone it reads like \"Settings\". Add `tone: \"danger\"` to the entry.",
-    },
-  },
-  create(context) {
-    if (!isProductSource(context)) return {}
-    const report = (node, text) => context.report({ node, messageId: "tone", data: { text } })
-    return {
-      JSXAttribute(node) {
-        if (node.name.type !== "JSXIdentifier" || node.name.name !== "entries") return
-        const element = node.parent?.name
-        if (element?.type !== "JSXIdentifier" || element.name !== "DropdownMenu") return
-        visitEntries(context, node.value?.type === "JSXExpressionContainer" ? node.value.expression : null, report)
-      },
-      VariableDeclarator(node) {
-        if (isMenuType(node.id.typeAnnotation)) visitEntries(context, node.init, report)
-      },
-    }
-  },
-}
-
-/** The rules this law contributes to the plugin. */
-export const rules = {
-  "destructive-menu-entry-needs-danger-tone": destructiveMenuEntryNeedsDangerTone,
-}
-
-defineFamilyRules(rules, "knowledge/hfs/rules.yaml#R93")
-
-/** Every rule is an error. */
-export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-grammar/${name}`, "error"]))