@starci/eslint-canon-fe 9.2.0 → 9.4.0

package/index.mjs

@@ -1,317 +0,0 @@
-/**
- * The universal frontend plugin: every applicable law's rules, gathered once.
- *
- * The public factory gathers every universal rule at error. A managed repository config composes
- * it with the selected Grammar-family factory instead of registering individual rules. Family
- * packages consume the public generic infrastructure exports; each rule implementation has one owner.
- *
- * Published IDs identify their owning law. Namespace migrations are explicit in the removed-vocabulary
- * catalog; compatibility aliases cannot create a second owner for a rule.
- */
-import { createRequire } from "node:module"
-import { join } from "node:path"
-import { pathToFileURL } from "node:url"
-import { recommended as brandValuesRecommended, rules as brandValuesRules } from "./brand-values.mjs"
-import { recommended as buttonIntentRecommended, rules as buttonIntentRules } from "./button-intent.mjs"
-import { recommended as controlHeightRecommended, rules as controlHeightRules } from "./control-height.mjs"
-import { recommended as clientBoundaryRecommended, rules as clientBoundaryRules } from "./client-boundary.mjs"
-import { recommended as commentsRecommended, rules as commentsRules } from "./comments.mjs"
-import { recommended as classNamesRecommended, rules as classNamesRules } from "./class-names.mjs"
-import { recommended as envOwnerRecommended, rules as envOwnerRules } from "./env-owner.mjs"
-import { recommended as feStackRecommended, rules as feStackRules } from "./fe-stack.mjs"
-import { recommended as fileLayoutRecommended, rules as fileLayoutRules } from "./file-layout.mjs"
-import { recommended as formattingRecommended, rules as formattingRules } from "./formatting.mjs"
-import { recommended as grammarShimRecommended, rules as grammarShimRules } from "./grammar-shim.mjs"
-import { recommended as hooksFolderRecommended, rules as hooksFolderRules } from "./hooks-folder.mjs"
-import { recommended as hygieneRecommended, rules as hygieneRules } from "./hygiene.mjs"
-import { recommended as landmarkRecommended, rules as landmarkRules } from "./landmark.mjs"
-import { recommended as listsRecommended, rules as listsRules } from "./lists.mjs"
-import { recommended as loadingRecommended, rules as loadingRules } from "./loading.mjs"
-import { recommended as lintEscapeRecommended, rules as lintEscapeRules } from "./lint-escape-hatch.mjs"
-import { recommended as namingRecommended, rules as namingRules } from "./naming.mjs"
-import { recommended as nativeControlsRecommended, rules as nativeControlsRules } from "./native-controls.mjs"
-import { recommended as nextConventionsRecommended, rules as nextConventionsRules } from "./next-conventions.mjs"
-import { recommended as propsRecommended, rules as propsRules } from "./props-and-slots.mjs"
-import { recommended as servedLocaleRecommended, rules as servedLocaleRules } from "./served-locale.mjs"
-import { recommended as drawingRecommended, rules as drawingRules } from "./drawing.mjs"
-import { recommended as sizeBudgetRecommended, rules as sizeBudgetRules } from "./size-and-state-budget.mjs"
-import { recommended as sizeGrowthRecommended, rules as sizeGrowthRules } from "./size-growth.mjs"
-import { recommended as surfaceRulesRecommended, rules as surfaceRules } from "./surface-rules.mjs"
-import { recommended as splitRecommended, rules as splitRules } from "./the-split.mjs"
-import { recommended as tokensRecommended, rules as tokensRules } from "./tokens.mjs"
-import { recommended as transportRecommended, rules as transportRules } from "./transport.mjs"
-import { recommended as translationRecommended, rules as translationRules } from "./translation.mjs"
-import { recommended as typeSafetyRecommended, rules as typeSafetyRules } from "./type-safety.mjs"
-import { recommended as projectGraphRecommended, rules as projectGraphRules } from "./project-graph.mjs"
-import { recommended as sonarParityRecommended, rules as sonarParityRules } from "./sonar-parity.mjs"
-import { buildFeConfig, buildPlainSourceConfig } from "./lib/config.mjs"
-import { why } from "./lib/why.mjs"
-import { recommended as uiRulingsRecommended, rules as uiRulingsRules } from "./ui-rulings.mjs"
-
-/** Each law's contribution, kept separate so a duplicate name is detectable rather than silent. */
-const CONTRIBUTIONS = [
-  { law: "ui-rulings", rules: uiRulingsRules, recommended: uiRulingsRecommended },
-    { law: "project-graph", rules: projectGraphRules, recommended: projectGraphRecommended },
-  { law: "brand-values", rules: brandValuesRules, recommended: brandValuesRecommended },
-  { law: "button-intent", rules: buttonIntentRules, recommended: buttonIntentRecommended },
-  { law: "control-height", rules: controlHeightRules, recommended: controlHeightRecommended },
-  { law: "client-boundary", rules: clientBoundaryRules, recommended: clientBoundaryRecommended },
-  { law: "comments", rules: commentsRules, recommended: commentsRecommended },
-  {
-    law: "class-names",
-    rules: classNamesRules,
-    recommended: classNamesRecommended,
-  },
-  { law: "env-owner", rules: envOwnerRules, recommended: envOwnerRecommended },
-  { law: "fe-stack", rules: feStackRules, recommended: feStackRecommended },
-  { law: "file-layout", rules: fileLayoutRules, recommended: fileLayoutRecommended },
-  { law: "formatting", rules: formattingRules, recommended: formattingRecommended },
-  { law: "grammar-shim", rules: grammarShimRules, recommended: grammarShimRecommended },
-  { law: "hooks-folder", rules: hooksFolderRules, recommended: hooksFolderRecommended },
-  { law: "hygiene", rules: hygieneRules, recommended: hygieneRecommended },
-  { law: "landmark", rules: landmarkRules, recommended: landmarkRecommended },
-  { law: "lists", rules: listsRules, recommended: listsRecommended },
-  { law: "loading", rules: loadingRules, recommended: loadingRecommended },
-  { law: "lint-escape-hatch", rules: lintEscapeRules, recommended: lintEscapeRecommended },
-  { law: "naming", rules: namingRules, recommended: namingRecommended },
-  { law: "native-controls", rules: nativeControlsRules, recommended: nativeControlsRecommended },
-  { law: "next-conventions", rules: nextConventionsRules, recommended: nextConventionsRecommended },
-  { law: "props-and-slots", rules: propsRules, recommended: propsRecommended },
-  { law: "served-locale", rules: servedLocaleRules, recommended: servedLocaleRecommended },
-  { law: "drawing", rules: drawingRules, recommended: drawingRecommended },
-  { law: "size-and-state-budget", rules: sizeBudgetRules, recommended: sizeBudgetRecommended },
-  { law: "size-growth", rules: sizeGrowthRules, recommended: sizeGrowthRecommended },
-  { law: "surface-rules", rules: surfaceRules, recommended: surfaceRulesRecommended },
-  { law: "the-split", rules: splitRules, recommended: splitRecommended },
-  { law: "tokens", rules: tokensRules, recommended: tokensRecommended },
-  { law: "translation", rules: translationRules, recommended: translationRecommended },
-  { law: "transport", rules: transportRules, recommended: transportRecommended },
-  { law: "type-safety", rules: typeSafetyRules, recommended: typeSafetyRecommended },
-  { law: "sonar-parity", rules: sonarParityRules, recommended: sonarParityRecommended },
-]
-
-/** Every gathered law. */
-export const lawOwners = CONTRIBUTIONS.map((entry) => entry.law)
-
-/**
- * Which law declares each rule.
- *
- * Exported because a failing rule is a question about a LAW, and the shortest path from a build log
- * to the document that explains it is this map. It is also what the twin test walks to prove no two
- * laws claim one name.
- */
-export const ruleOwners = Object.fromEntries(
-  CONTRIBUTIONS.flatMap((entry) => Object.keys(entry.rules).map((name) => [name, entry.law])),
-)
-
-/**
- * Every (law, rule name) pair as DECLARED, before any collapsing.
- *
- * `ruleOwners` above and `rules` below are both built with `Object.fromEntries`, which silently
- * keeps the last writer when two laws declare one name. A guard that walks either of them cannot
- * see a collision - the duplicate is gone before it looks, so every name appears exactly once BY
- * CONSTRUCTION and the check passes forever while being blind.
- *
- * That is not hypothetical. The back-end twin had this exact shape, three rules were declared by two
- * laws each, one copy was discarded on import, and its guard reported green throughout. This axis
- * has no collision today; publishing the raw declarations is what keeps that a FACT rather than an
- * assumption nobody can test.
- */
-export const ruleDeclarations = CONTRIBUTIONS.flatMap((entry) =>
-  Object.keys(entry.rules).map((name) => ({ law: entry.law, name })),
-)
-
-/** Every rule this canon publishes, keyed by its published name. */
-export const rules = Object.fromEntries(
-  CONTRIBUTIONS.flatMap((entry) => Object.entries(entry.rules)),
-)
-
-/**
- * The levels this canon asks for, as the plugin's own opinion.
- *
- * Every FE canon rule is an error. Existing debt is fixed before adoption; lowering architecture
- * to warn teaches every later author that the boundary is optional and is not a supported rollout.
- */
-export const recommended = Object.fromEntries(
-  CONTRIBUTIONS.flatMap((entry) => Object.entries(entry.recommended)),
-)
-
-/** Flat-config options that make inline directives ineffective rather than merely forbidden. */
-export { linterOptions } from "./lib/config.mjs"
-export { loadHfs } from "./lib/hfs.mjs"
-
-/**
- * The Vietnamese why of each rule that carries a catalogue code: `{ code, vi, fixVi }`.
- *
- * Read by the harness, which quotes `vi` to the owner and files the finding under `code`.
- */
-export { why }
-
-/** The plugin object, shaped the way a flat config expects it. */
-const plugin = {
-  meta: { name: "eslint-plugin-starci-fe" },
-  rules,
-}
-
-export default plugin
-
-/**
- * The React Hooks plugin, from wherever the consuming repository installed it.
- *
- * A peer dependency is resolved from the package that asks for it, and a package linked by path
- * (`file:`) is resolved from its REAL location - which has no `node_modules` of the repository that
- * linked it. So the plugin is looked up from this package first and from the working directory
- * second; a repository that installed `eslint-plugin-react-hooks` beside its `eslint.config.mjs`
- * is found either way, and one that did not gets a message naming the install rather than a
- * resolver stack trace.
- */
-const loadReactHooks = () => {
-  for (const base of [import.meta.url, pathToFileURL(join(process.cwd(), "noop.js")).href]) {
-    try {
-      return createRequire(base)("eslint-plugin-react-hooks")
-    } catch {
-      // try the next place
-    }
-  }
-  throw new Error("starciFeConfig needs eslint-plugin-react-hooks 7 or newer: npm i -D eslint-plugin-react-hooks")
-}
-
-/** The typescript-eslint plugin whose type-aware rules the factory borrows (Sonar S1874, S6551 and S7503); a dependency of this package. */
-const loadTsPlugin = () => createRequire(import.meta.url)("@typescript-eslint/eslint-plugin")
-
-/** The Sonar way plugins (scripts/lib/sonar-way.mjs); dependencies of this package, pinned exactly. */
-const loadSonarPlugins = () => {
-  const require = createRequire(import.meta.url)
-  const unicorn = require("eslint-plugin-unicorn")
-  return { sonarjs: require("eslint-plugin-sonarjs"), unicorn: unicorn.default ?? unicorn }
-}
-
-/**
- * The React Hooks rules of a plugin, all at error.
- *
- * The plugin's own recommended set is the definition of "the hooks rules" - it carries the classic
- * pair and the compiler-derived ones (`set-state-in-effect`, `refs`, `purity`, `immutability`) - and
- * it ships several of them at `warn`. A warning is the level a team learns to scroll past, so the
- * canon states every one as `error`. Four rules are named on purpose: a plugin too old to carry them
- * would otherwise be adopted silently with the rules that catch effect-driven state and ref reads
- * during render missing.
- *
- * @param {object} reactHooks - The plugin object.
- * @returns {Record<string, "error">} Every recommended hooks rule at error.
- */
-export const reactHooksRules = (reactHooks) => {
-  const configured = reactHooks.configs?.flat?.recommended?.rules ?? {}
-  for (const required of [
-    "react-hooks/set-state-in-effect",
-    "react-hooks/refs",
-    "react-hooks/rules-of-hooks",
-    "react-hooks/exhaustive-deps",
-  ]) {
-    if (!(required in configured)) {
-      throw new Error(`eslint-plugin-react-hooks does not carry ${required}; install version 7 or newer`)
-    }
-  }
-  return Object.fromEntries(Object.keys(configured).map((name) => [name, "error"]))
-}
-
-/**
- * The universal portion of a frontend's flat config, composed with its selected Grammar-family factory.
- *
- * It owns nothing the repository could choose: which files are linted comes from the HFS profile (every app's and every
- * workspace package's `src/`), not which rules are on, not their level, not whether an inline comment may
- * switch one off. NO RULE IS OFF - the factory throws rather than emit a block in which a published rule is missing or
- * below error, so a rule added to this package reaches every repository or the build of this package fails.
- *
- * @param {{ hfs: object }} input - The HFS view of the repository (`loadHfs(import.meta.url)`).
- * @returns {object[]} The flat config: ignores and the typed source block.
- */
-export const starciFeConfig = ({ hfs } = {}) => {
-  const published = Object.keys(rules).map((name) => `starci-fe/${name}`)
-  const notRequested = published.filter((name) => recommended[name] !== "error")
-  if (notRequested.length > 0) {
-    throw new Error(`starciFeConfig: these published rules are not requested at error: ${notRequested.join(", ")}`)
-  }
-  const reactHooks = loadReactHooks()
-  return buildFeConfig({
-    hfs,
-    plugin,
-    reactHooks,
-    tsPlugin: loadTsPlugin(),
-    sonar: loadSonarPlugins(),
-    source: { ...recommended, ...reactHooksRules(reactHooks) },
-  })
-}
-
-/**
- * The flat config of a TypeScript front-end tree that is no HFS app (a runtime package, the harness UI):
- * `export default starciPlainSourceConfig({ root: import.meta.dirname })`. It lints the tree's `src/` with types, with the inline-directive fence, the
- * React Hooks rules, the type-aware rules and the Sonar way rules, and with every canon rule that needs no slot view, all at `error`.
- *
- * @param {{ root: string }} input - The absolute directory holding the tree's `tsconfig.json` and `src/`.
- * @returns {object[]} The flat config: ignores, the typed source block and the Sonar way block.
- */
-export const starciPlainSourceConfig = ({ root } = {}) => {
-  const reactHooks = loadReactHooks()
-  return buildPlainSourceConfig({ root, plugin, hooks: reactHooksRules(reactHooks), reactHooks, tsPlugin: loadTsPlugin(), sonar: loadSonarPlugins() })
-}
-
-/**
- * The flat config of a TypeScript front-end tree that adopts the typed half of the canon first: the inline-directive fence, typed linting, the
- * React Hooks rules, the type-aware typescript-eslint rules and the Sonar way rules over the tree's `src/`, all at `error`. It is
- * `starciPlainSourceConfig` without the canon's own product-structure rules (`SLOT_FREE_RULES`: jsdoc on exports, arrow exports, English-only
- * source, grammar controls, ...), for a tree that has not been brought to them yet; a tree that has uses `starciPlainSourceConfig`.
- *
- * @param {{ root: string }} input - The absolute directory holding the tree's `tsconfig.json` and `src/`.
- * @returns {object[]} The flat config: ignores, the typed source block and the Sonar way block.
- */
-export const starciTypedSourceConfig = ({ root } = {}) => {
-  const reactHooks = loadReactHooks()
-  return buildPlainSourceConfig({ root, plugin, hooks: reactHooksRules(reactHooks), reactHooks, tsPlugin: loadTsPlugin(), sonar: loadSonarPlugins(), canon: false })
-}
-
-// A21 append-only registration: keep the already exported plugin and recommendation live.
-import { recommended as functionBudgetRecommended, rules as functionBudgetRules } from "./function-budget.mjs"
-CONTRIBUTIONS.push({ law: "function-budget", rules: functionBudgetRules, recommended: functionBudgetRecommended })
-lawOwners.push("function-budget")
-ruleDeclarations.push(...Object.keys(functionBudgetRules).map((name) => ({ law: "function-budget", name })))
-Object.assign(ruleOwners, Object.fromEntries(Object.keys(functionBudgetRules).map((name) => [name, "function-budget"])))
-Object.assign(rules, functionBudgetRules)
-Object.assign(recommended, functionBudgetRecommended)
-// A14 modules are also forwarded by the existing hooks-folder and transport contributions so
-// source-only catalog discovery can find them. The appended registration gives each module
-// ownership of those same rule instances without declaring either rule twice.
-import { recommended as swrFamilyRecommended, rules as swrFamilyRules } from "./swr-family.mjs"
-import { recommended as callbackShapeRecommended, rules as callbackShapeRules } from "./callback-shape.mjs"
-
-const A14_CONTRIBUTIONS = [
-  { law: "swr-family", rules: swrFamilyRules, recommended: swrFamilyRecommended },
-  { law: "callback-shape", rules: callbackShapeRules, recommended: callbackShapeRecommended },
-]
-
-for (const addition of A14_CONTRIBUTIONS) {
-  const names = new Set(Object.keys(addition.rules))
-  for (const contribution of CONTRIBUTIONS) {
-    for (const name of names) {
-      if (name in contribution.rules && contribution.rules[name] !== addition.rules[name]) {
-        throw new Error("A14 registration: two laws publish different rules named " + name)
-      }
-    }
-    // Replace contribution views only; the law module's exported maps retain their forwarding
-    // entries for the source-only catalog reader.
-    contribution.rules = Object.fromEntries(Object.entries(contribution.rules).filter(([name]) => !names.has(name)))
-    contribution.recommended = Object.fromEntries(
-      Object.entries(contribution.recommended).filter(([name]) => !names.has(name.replace(/^starci-fe\//, ""))),
-    )
-  }
-  CONTRIBUTIONS.push(addition)
-  lawOwners.push(addition.law)
-  for (const name of names) {
-    const declarations = ruleDeclarations.filter((entry) => entry.name === name)
-    if (declarations.length > 1) throw new Error("A14 registration: duplicate declarations for " + name)
-    if (declarations.length === 1) declarations[0].law = addition.law
-    else ruleDeclarations.push({ law: addition.law, name })
-    ruleOwners[name] = addition.law
-  }
-  Object.assign(rules, addition.rules)
-  Object.assign(recommended, addition.recommended)
-}

package/lib/ast.mjs

@@ -1,97 +0,0 @@
-/**
- * Small AST readers shared by the laws that look at JSX attributes, calls and effect callbacks.
- *
- * ONE PLACE, because each reader answers "what does this node say" and two copies answer it
- * slightly differently: a rule that treats `` `/a` `` as a string and a sibling that does not
- * disagree about which hrefs are hardcoded.
- */
-
-/** The JSX attribute called `name` on an opening element, or null. */
-export const attribute = (opening, name) =>
-  opening.attributes.find(
-    (entry) => entry.type === "JSXAttribute" && entry.name.type === "JSXIdentifier" && entry.name.name === name,
-  ) ?? null
-
-/** The expression an attribute carries: a literal, or the inside of `{...}`; null for a bare attribute. */
-export const attributeValue = (entry) => {
-  if (!entry || !entry.value) return null
-  return entry.value.type === "JSXExpressionContainer" ? entry.value.expression : entry.value
-}
-
-/** The text of a string literal or of a template with no substitution; null for anything else. */
-export const stringOf = (node) => {
-  if (!node) return null
-  if (node.type === "Literal" && typeof node.value === "string") return node.value
-  if (node.type === "TemplateLiteral" && node.expressions.length === 0) return node.quasis[0]?.value.cooked ?? ""
-  return null
-}
-
-/** The leading text of a string literal or template (up to the first substitution); null for anything else. */
-export const leadingTextOf = (node) => {
-  if (!node) return null
-  if (node.type === "TemplateLiteral") return node.quasis[0]?.value.cooked ?? ""
-  return stringOf(node)
-}
-
-/** `a.b.c` for a chain of plain member accesses ending in an identifier; null for anything computed. */
-export const calleeName = (node) => {
-  if (!node) return null
-  if (node.type === "Identifier") return node.name
-  if (node.type === "MemberExpression" && !node.computed && node.property.type === "Identifier") {
-    const head = calleeName(node.object)
-    return head === null ? null : `${head}.${node.property.name}`
-  }
-  return null
-}
-
-/** The name of a JSX element for a plain tag or a component; null for a member or namespaced name. */
-export const tagName = (opening) => (opening.name.type === "JSXIdentifier" ? opening.name.name : null)
-
-/** True for a `className` / `class` JSX attribute. */
-export const isClassAttribute = (node) =>
-  node.type === "JSXAttribute" && node.name && (node.name.name === "className" || node.name.name === "class")
-
-/** Static string carried by a JSX attribute or by a module constant holding a class string. */
-export const staticText = (value) => {
-  if (!value) return null
-  if (value.type === "Literal" && typeof value.value === "string") return value.value
-  if (value.type === "TemplateLiteral" && value.expressions.length === 0) {
-    return value.quasis.map((quasi) => quasi.value.cooked).join(" ")
-  }
-  if (value.type === "JSXExpressionContainer") return staticText(value.expression)
-  return null
-}
-
-/** True for a function expression or an arrow function. */
-export const isFunction = (node) => node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression"
-
-/**
- * Every node under `root`, depth first, through the visitor keys of the parser in use.
- * `enter` may return `false` to skip a node's children.
- */
-export const walk = (sourceCode, root, enter) => {
-  const keys = sourceCode.visitorKeys
-  const visit = (node) => {
-    if (enter(node) === false) return
-    for (const key of keys[node.type] ?? []) {
-      const child = node[key]
-      if (Array.isArray(child)) {
-        for (const item of child) if (item && typeof item.type === "string") visit(item)
-      } else if (child && typeof child.type === "string") {
-        visit(child)
-      }
-    }
-  }
-  visit(root)
-}
-
-/** True when an identifier called `name` appears anywhere under `root`. */
-export const mentions = (sourceCode, root, name) => {
-  let found = false
-  walk(sourceCode, root, (node) => {
-    if (found) return false
-    if (node.type === "Identifier" && node.name === name) found = true
-    return undefined
-  })
-  return found
-}

package/lib/bindings.mjs

@@ -1,159 +0,0 @@
-/**
- * Bindings of the front-end canon: what an identifier resolves to through the scope manager, which module an import
- * comes from, which function a name stands for, and a stable KEY for an expression that names a place (a variable, a
- * member path, `this.x`). A rule that must decide "is this the same handle / target / listener" compares keys, never
- * spellings: two `id` variables in different scopes have different keys, `timerRef.current` has one key wherever it is
- * written.
- */
-
-import { stringOf } from "./ast.mjs"
-
-/** The globals that all name the browser's global object. */
-const GLOBAL_OBJECT = new Set(["window", "globalThis", "self"])
-
-/** Wrappers that change a node's type, not its identity. */
-const TRANSPARENT = new Set(["TSAsExpression", "TSNonNullExpression", "TSSatisfiesExpression", "TSTypeAssertion", "ChainExpression", "ParenthesizedExpression"])
-
-/**
- * The node without the wrappers that only change its type (`x as T`, `x!`, `x?.y`).
- *
- * @param {object} node - An ESTree node.
- * @returns {object} The inner node.
- */
-export const unwrap = (node) => {
-  let current = node
-  while (current && TRANSPARENT.has(current.type)) current = current.expression
-  return current
-}
-
-/**
- * The node's parent with the type-only wrappers skipped upward.
- *
- * @param {object} node - An ESTree node.
- * @returns {object|null} The first parent that is not a type-only wrapper.
- */
-export const parentOf = (node) => {
-  let current = node.parent
-  while (current && TRANSPARENT.has(current.type)) current = current.parent
-  return current ?? null
-}
-
-/** True for a function expression, an arrow function or a function declaration. */
-export const isFn = (node) =>
-  Boolean(node) && (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration")
-
-/**
- * The scope-manager variable an identifier resolves to, or null for a global.
- *
- * @param {object} context - The ESLint rule context.
- * @param {object} identifier - An ESTree identifier.
- * @returns {object|null} The variable.
- */
-export const variableOf = (context, identifier) => {
-  for (let scope = context.sourceCode.getScope(identifier); scope; scope = scope.upper) {
-    const variable = scope.set.get(identifier.name)
-    if (variable) return variable
-  }
-  return null
-}
-
-/**
- * Where an identifier was imported from.
- *
- * @param {object} context - The ESLint rule context.
- * @param {object} identifier - An ESTree identifier.
- * @returns {{ source: string, imported: string|null }|null} The module specifier and the imported name (`null` for a default or namespace import), or null when the identifier is not an import.
- */
-export const importOf = (context, identifier) => {
-  const variable = variableOf(context, identifier)
-  const definition = variable?.defs.find((entry) => entry.type === "ImportBinding")
-  if (!definition) return null
-  const specifier = definition.node
-  const source = String(definition.parent.source.value)
-  if (specifier.type === "ImportSpecifier") return { source, imported: specifier.imported.name ?? String(specifier.imported.value) }
-  return { source, imported: null }
-}
-
-/** The property path a destructured binding selects from its initializer; null for an unselected or rest binding. */
-export const patternPath = (pattern, name) => {
-  if (pattern.type === "Identifier") return pattern.name === name ? [] : null
-  if (pattern.type === "AssignmentPattern") return patternPath(pattern.left, name)
-  if (pattern.type !== "ObjectPattern") return null
-  for (const property of pattern.properties) {
-    if (property.type !== "Property") continue
-    const nested = patternPath(property.value, name)
-    if (nested !== null) return [property.computed ? stringOf(property.key) : property.key.name ?? property.key.value, ...nested]
-  }
-  return null
-}
-
-/**
- * The function an expression stands for: the function itself, or the function a same-file variable or declaration holds.
- *
- * @param {object} context - The ESLint rule context.
- * @param {object} node - An ESTree expression.
- * @returns {object|null} The function node, or null when it cannot be resolved in this file.
- */
-export const functionOf = (context, node) => {
-  const inner = unwrap(node)
-  if (!inner) return null
-  if (isFn(inner)) return inner
-  if (inner.type !== "Identifier") return null
-  const variable = variableOf(context, inner)
-  for (const definition of variable?.defs ?? []) {
-    if (definition.type === "FunctionName" && definition.node.type === "FunctionDeclaration") return definition.node
-    if (definition.type === "Variable" && definition.node.id.type === "Identifier") {
-      const init = unwrap(definition.node.init)
-      if (isFn(init)) return init
-    }
-  }
-  return null
-}
-
-/** A stable numeric id per scope-manager variable, so keys compare by binding and not by spelling. */
-const VARIABLE_IDS = new WeakMap()
-let nextVariableId = 1
-const idOf = (variable) => {
-  if (!VARIABLE_IDS.has(variable)) VARIABLE_IDS.set(variable, nextVariableId++)
-  return VARIABLE_IDS.get(variable)
-}
-
-/**
- * The key of an expression that names a place: `v12` for a variable, `v12.current` for a member path, `this.timer` for
- * a member of `this`, `g:window` for the browser's global object under any of its names. Anything else has no key.
- *
- * @param {object} context - The ESLint rule context.
- * @param {object} node - An ESTree expression.
- * @returns {string|null} The key.
- */
-export const keyOf = (context, node) => {
-  const inner = unwrap(node)
-  if (!inner) return null
-  if (inner.type === "Identifier") {
-    const variable = variableOf(context, inner)
-    if (variable && variable.defs.length > 0) return `v${idOf(variable)}`
-    return GLOBAL_OBJECT.has(inner.name) ? "g:window" : `g:${inner.name}`
-  }
-  if (inner.type === "ThisExpression") return "this"
-  if (inner.type === "MemberExpression") {
-    const head = keyOf(context, inner.object)
-    if (head === null) return null
-    if (!inner.computed && inner.property.type === "Identifier") return `${head}.${inner.property.name}`
-    if (inner.computed && inner.property.type === "Literal") return `${head}[${String(inner.property.value)}]`
-    return null
-  }
-  return null
-}
-
-/**
- * The receiver and the member name of a call written as `receiver.name(...)`, or the bare name of `name(...)`.
- *
- * @param {object} call - An ESTree call expression.
- * @returns {{ receiver: object|null, name: string }|null} The parts, or null for a computed or exotic callee.
- */
-export const calleeParts = (call) => {
-  const callee = unwrap(call.callee)
-  if (callee.type === "Identifier") return { receiver: null, name: callee.name }
-  if (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier") return { receiver: callee.object, name: callee.property.name }
-  return null
-}

package/lib/class-text.mjs

@@ -1,29 +0,0 @@
-/** Shared static class-string readers for token discipline and Grammar scale checks. */
-import { isClassAttribute, staticText } from "./ast.mjs"
-import { isProductSource } from "./scope.mjs"
-
-/** Static strings in JSX, constants and arrays, preserving the authored class order. */
-const classText = (value) => {
-  if (value?.type === "JSXExpressionContainer") return classText(value.expression)
-  if (value?.type === "ArrayExpression") {
-    const members = value.elements.map((element) => classText(element)).filter(Boolean)
-    return members.length > 0 ? members.join(" ") : null
-  }
-  return staticText(value)
-}
-
-/** Visit class strings in product JSX, declarations and named class arrays. */
-export const classTextVisitors = (context, report) => {
-  if (!isProductSource(context)) return {}
-  return {
-    JSXAttribute(node) {
-      if (isClassAttribute(node)) report(node, classText(node.value))
-    },
-    VariableDeclarator(node) {
-      report(node, classText(node.init))
-    },
-    Property(node) {
-      if (!node.computed && node.key.type === "Identifier" && node.key.name === "classes") report(node, classText(node.value))
-    },
-  }
-}