@nadicodeai/ui 12.1.54 → 12.1.56

package/dist/eslint/rules/no-route-width-override.js

@@ -1,135 +0,0 @@
-/*
- * A Portal route does not decide how wide it is.
- *
- * The signed-in chrome owns the content column: `(dashboard)/layout.tsx` renders
- * `PortalShell`, and a reading-width surface takes `ReadingColumn` from
- * `@nadicodeai/ui`. A route that caps its own width with `max-w-*` or centres
- * itself with `mx-auto` makes a second owner for one measurement, which is how
- * neighbouring pages end up at 42rem and 48rem with nothing to say which is
- * right, and how a shell change stops reaching half the routes.
- *
- * What is read is the OUTERMOST element the route renders — the root of every
- * expression its default export returns, descended through fragments and through
- * the conditionals a route writes around a fallback. A width inside the page is
- * a different statement: a skeleton that matches the field it stands in for, or
- * a form column, constrains its own element, not the route, and those are
- * ordinary. The rule's subject is the route's own frame.
- *
- * `max-w-full` and `max-w-none` are kept legal for the same reason: they remove
- * a cap rather than set one, so neither can be the second owner of a width.
- *
- * Standard tool checked first: `better-tailwindcss/no-restricted-classes`
- * matches a class wherever it is written and cannot ask whether the element
- * carrying it is the one the route returns. That relationship is the rule, so it
- * is read here.
- */
-import { openingElementClassUtilities } from "./jsx-class-utility.js";
-
-const CENTERING = "mx-auto";
-const MAX_WIDTH = /^-?max-w-(.+)$/;
-const UNCAPPED = new Set(["full", "none"]);
-
-function withoutVariants(token) {
-  let bracketDepth = 0;
-  let start = 0;
-  for (let index = 0; index < token.length; index += 1) {
-    if (token[index] === "[") bracketDepth += 1;
-    if (token[index] === "]") bracketDepth = Math.max(0, bracketDepth - 1);
-    if (token[index] === ":" && bracketDepth === 0) start = index + 1;
-  }
-  return token.slice(start);
-}
-
-function isWidthOverride(utility) {
-  const unqualified = withoutVariants(utility);
-  if (unqualified === CENTERING) return true;
-  const capped = MAX_WIDTH.exec(unqualified);
-  return capped ? !UNCAPPED.has(capped[1]) : false;
-}
-
-/** The elements one returned expression renders at its outermost level. */
-function rootElements(node, found = []) {
-  if (!node) return found;
-  switch (node.type) {
-    case "JSXElement":
-      found.push(node);
-      return found;
-    case "JSXFragment":
-      for (const child of node.children) rootElements(child, found);
-      return found;
-    case "JSXExpressionContainer":
-      return rootElements(node.expression, found);
-    case "ConditionalExpression":
-      rootElements(node.consequent, found);
-      return rootElements(node.alternate, found);
-    case "LogicalExpression":
-      return rootElements(node.right, found);
-    default:
-      return found;
-  }
-}
-
-const FUNCTION_TYPES = new Set([
-  "ArrowFunctionExpression",
-  "FunctionDeclaration",
-  "FunctionExpression",
-]);
-
-/*
- * Every expression the route function returns, its own returns only: a helper
- * declared inside it renders something else, and its root is not the route's.
- */
-function returnedExpressions(node, found = []) {
-  if (!node || typeof node.type !== "string") return found;
-  if (node.type === "ReturnStatement") {
-    if (node.argument) found.push(node.argument);
-    return found;
-  }
-  if (FUNCTION_TYPES.has(node.type)) return found;
-  for (const [key, value] of Object.entries(node)) {
-    if (key === "parent" || key === "loc" || key === "range") continue;
-    if (Array.isArray(value)) {
-      for (const child of value) returnedExpressions(child, found);
-    } else if (value && typeof value === "object") {
-      returnedExpressions(value, found);
-    }
-  }
-  return found;
-}
-
-function routeRoots(routeFunction) {
-  const body = routeFunction.body;
-  if (body.type !== "BlockStatement") return rootElements(body);
-  return returnedExpressions(body).flatMap((expression) => rootElements(expression));
-}
-
-export const noRouteWidthOverride = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow a Portal route file setting the width of the frame it returns",
-    },
-    schema: [],
-    messages: {
-      routeWidthOverride:
-        '"{{utility}}" makes this route a second owner of the content width, so neighbouring pages drift apart and a shell change stops reaching this one. Page width belongs to the shell column; a reading-width surface takes ReadingColumn from @nadicodeai/ui.',
-    },
-  },
-  create(context) {
-    return {
-      ExportDefaultDeclaration(node) {
-        if (!FUNCTION_TYPES.has(node.declaration.type)) return;
-        for (const root of routeRoots(node.declaration)) {
-          for (const utility of openingElementClassUtilities(root.openingElement, context)) {
-            if (!isWidthOverride(utility)) continue;
-            context.report({
-              node: root.openingElement,
-              messageId: "routeWidthOverride",
-              data: { utility },
-            });
-          }
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-store-cast.js

@@ -1,46 +0,0 @@
-/*
- * A test hands the subject the store methods it calls, as an object typed by
- * the subject's own parameter. `as PortalStore` (or `as unknown as
- * PortalStore`) turns a partial object into the whole 227-method store: the
- * compiler then checks nothing about the methods the fake does implement, and a
- * subject that grows a call reaches `undefined` at run time instead of failing
- * to compile. Narrow the subject's parameter to the capability it uses
- * (`Pick<SomePersistence, "a" | "b">`), then build the fake as that type.
- */
-
-export const noStoreCast = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Disallow casting a partial object to the whole store in a test; type the subject by the store methods it calls and build the fake as that type",
-    },
-    schema: [
-      {
-        type: "object",
-        properties: { types: { type: "array", items: { type: "string" } } },
-        additionalProperties: false,
-      },
-    ],
-    messages: {
-      storeCast:
-        '`as {{name}}` hides which store methods this fake implements, so the compiler checks none of them. Type the subject\'s store parameter as the methods it calls (`Pick<SomePersistence, "a" | "b">`) and build the fake as `Parameters<typeof subject>[0]`.',
-    },
-  },
-
-  create(context) {
-    const names = new Set(context.options[0]?.types ?? ["PortalStore"]);
-    return {
-      TSAsExpression(node) {
-        const type = node.typeAnnotation;
-        if (
-          type.type === "TSTypeReference" &&
-          type.typeName.type === "Identifier" &&
-          names.has(type.typeName.name)
-        ) {
-          context.report({ node, messageId: "storeCast", data: { name: type.typeName.name } });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-token-category-bypass.js

@@ -1,53 +0,0 @@
-import { createRequire } from "node:module";
-
-import { tokenUtilityVisitors } from "./jsx-class-utility.js";
-
-const require = createRequire(import.meta.url);
-const borderRadius = require("@nadicodeai/design-system/tailwind").theme.extend.borderRadius;
-const radiusNameByValue = new Map(
-  Object.entries(borderRadius).map(([name, value]) => [value, name]),
-);
-const ARBITRARY_RADIUS = /^(rounded(?:-(?:t|r|b|l|s|e|ss|se|ee|es|tl|tr|br|bl))?)-\[(.+)\]$/;
-const CANONICAL_RADIUS_VARIABLE = /^var\(--(?:nc-rounded|radius)-([a-z0-9-]+)\)$/;
-
-function canonicalRadiusReplacement(utility) {
-  const variantBoundary = utility.lastIndexOf(":") + 1;
-  const variants = utility.slice(0, variantBoundary);
-  const unqualified = utility.slice(variantBoundary);
-  const match = ARBITRARY_RADIUS.exec(unqualified);
-  if (!match) return undefined;
-
-  const [, prefix, rawValue] = match;
-  const value = rawValue.trim();
-  const variable = CANONICAL_RADIUS_VARIABLE.exec(value);
-  const token = variable?.[1] ?? radiusNameByValue.get(value);
-  if (!token || !(token in borderRadius)) return undefined;
-
-  return `${variants}${prefix}-${token}`;
-}
-
-export const noTokenCategoryBypass = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Disallow arbitrary radius values when the generated design system provides an exact utility",
-    },
-    schema: [],
-    messages: {
-      canonicalTokenUtility:
-        "Replace {{utility}} with the generated design-system utility {{replacement}}.",
-    },
-  },
-  create(context) {
-    return tokenUtilityVisitors(context, (node, utility) => {
-      const replacement = canonicalRadiusReplacement(utility);
-      if (!replacement) return;
-      context.report({
-        node,
-        messageId: "canonicalTokenUtility",
-        data: { replacement, utility },
-      });
-    });
-  },
-};

package/dist/eslint/rules/no-unpinned-vercel-functions-import.js

@@ -1,104 +0,0 @@
-// The standard tool was checked first: core `no-restricted-imports` takes
-// `paths[].importNames` / `allowImportNames`, so a per-symbol allowlist is
-// within its vocabulary. What it cannot do is bind that allowlist to a file.
-// The ban would live in the shared options and each allowed module would need a
-// file-scoped override — and flat config replaces rule options instead of
-// merging them, so every one of those overrides must restate the whole shared
-// object (the package-source patterns, the raw-logo patterns, the portal's kit
-// barrel) to keep them alive. That is one copy of the ban list per allowed
-// module, where a single stale copy silently reopens a boundary; the same
-// last-wins failure `tests/module-boundary-imports.test.ts` exists to catch. A
-// plugin rule keeps the module-to-symbol map in one place and carries the
-// incident and the remediation in its message.
-//
-// Static `import` declarations only. The rule's provenance is a real production
-// crash: `ipAddress()` duck-typed its input and threw on the device-authorize
-// route, and
-// that crash arrived through a plain named import, which is also the only form
-// that can prove which symbols it binds. The rule used to also flag any string
-// literal or template literal spelling the package name anywhere in a file,
-// reaching dynamic `import()`, `require`, and re-exports; nothing in this
-// repository writes those forms, and the catch-all fired on any quoted mention
-// of the name.
-const PACKAGE_NAME = "@vercel/functions";
-
-// Third-party helpers stay behind owned, single-purpose capability seams. Pin
-// the full workspace-relative suffix so a same-named file in another workspace
-// cannot acquire a platform dependency by shadowing an allowed module.
-const ALLOWED_IMPORTS = new Map([
-  ["apps/portal/src/lib/server/db.ts", new Set(["attachDatabasePool"])],
-  ["apps/portal/src/lib/server/deferred-work.ts", new Set(["waitUntil"])],
-  ["apps/portal/src/lib/server/usage-check-cache.ts", new Set(["getCache", "RuntimeCache"])],
-  ["apps/portal/src/lib/server/quiet-job-runs.ts", new Set(["getCache", "RuntimeCache"])],
-]);
-
-function matchesPackage(value) {
-  return (
-    typeof value === "string" && (value === PACKAGE_NAME || value.startsWith(`${PACKAGE_NAME}/`))
-  );
-}
-
-function allowedSymbolsFor(filename) {
-  const normalized = filename.replaceAll("\\", "/");
-  for (const [suffix, symbols] of ALLOWED_IMPORTS) {
-    if (normalized.endsWith(suffix)) {
-      return symbols;
-    }
-  }
-  return undefined;
-}
-
-function importedName(specifier) {
-  if (specifier.type !== "ImportSpecifier") {
-    return undefined;
-  }
-  return specifier.imported.type === "Identifier"
-    ? specifier.imported.name
-    : specifier.imported.value;
-}
-
-/** @type {import('eslint').Rule.RuleModule} */
-export const noUnpinnedVercelFunctionsImport = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Confine static @vercel/functions imports to pinned edge modules and symbols",
-    },
-    messages: {
-      banned:
-        "@vercel/functions duck-types its inputs and ipAddress() crashed production once on a headers-like object. Its use is pinned per module and per symbol; amend the allowlist deliberately or keep the dependency out (found {{value}}).",
-    },
-    schema: [],
-  },
-  create(context) {
-    const allowedSymbols = allowedSymbolsFor(context.filename);
-
-    function report(node, value) {
-      context.report({
-        node,
-        messageId: "banned",
-        data: { value },
-      });
-    }
-
-    return {
-      ImportDeclaration(node) {
-        if (!matchesPackage(node.source.value)) {
-          return;
-        }
-
-        const importsOnlyPinnedSymbols =
-          allowedSymbols &&
-          node.specifiers.length > 0 &&
-          node.specifiers.every((specifier) => {
-            const name = importedName(specifier);
-            return name !== undefined && allowedSymbols.has(name);
-          });
-
-        if (!importsOnlyPinnedSymbols) {
-          report(node, node.source.value);
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/one-control-height.js

@@ -1,163 +0,0 @@
-/*
- * Product chrome uses the 32px control.
- *
- * DESIGN.md ("Layout") gives every control in a product's chrome one height,
- * `control-height`, with a 14px label at 500. The small sizes a control
- * component still ships (`xs`, `sm`, `icon-xs`, `icon-sm`) exist for a control
- * nested inside dense content in another product, such as a composer; a
- * surface that enables this rule has none. The failure this catches: the
- * Portal's header actions rendered at 28px with a 12.8px label beside 32px
- * buttons in the card below them, because each caller picked `size="sm"`.
- *
- * What is read is a JSX element that is a control (a name ending in `Button`
- * or `Trigger`, or a `Toggle`/`ToggleGroupItem`/`NativeSelect`) and its `size`
- * attribute and the heights its `className` sets (`h-7`, `min-h-7`, `size-7`,
- * `h-[28px]`, and a fixed `h-10` or `size-10` above the control unless every
- * branch of its `size` is `"lg"`), with `!` read on either side, plus the `triggerSize` attribute a confirm
- * form passes to the button it renders, plus the `size` key of a `buttonVariants({ ... })` or
- * `toggleVariants({ ... })` call that styles a link as a button.
- * A string literal is read directly and through both branches of a
- * conditional, so `size={compact ? "sm" : "default"}` is reported too.
- *
- * Not read: `InputGroupButton`, a control nested inside an input group, where
- * DESIGN.md allows the small sizes, and `SidebarMenuSubButton`, whose `size`
- * sets its label, not its height.
- *
- * Standard tool checked first: `no-restricted-syntax` can select
- * `JSXAttribute[name.name="size"][value.value="sm"]` but not the element names
- * that make it a control, nor the branches of a conditional value, without a
- * selector per combination.
- */
-import { classUtilities, jsxComponentName } from "./jsx-class-utility.js";
-
-const SMALL_SIZES = new Set(["xs", "sm", "icon-xs", "icon-sm"]);
-const CONTROL_NAMES = new Set(["Toggle", "ToggleGroupItem", "NativeSelect"]);
-const NESTED_CONTROL_NAMES = new Set(["InputGroupButton", "SidebarMenuSubButton"]);
-const VARIANT_FUNCTIONS = new Set(["buttonVariants", "toggleVariants"]);
-const CONTROL_HEIGHT_PX = 32;
-const SPACING_UNIT_PX = 4;
-
-function isControl(name) {
-  return (
-    typeof name === "string" &&
-    !NESTED_CONTROL_NAMES.has(name) &&
-    (CONTROL_NAMES.has(name) || /(?:Button|Trigger)$/.test(name))
-  );
-}
-
-function variantsAndUtility(className) {
-  const parts = [];
-  let depth = 0;
-  let start = 0;
-  for (let index = 0; index < className.length; index += 1) {
-    const character = className[index];
-    if (character === "[") depth += 1;
-    else if (character === "]") depth -= 1;
-    else if (character === ":" && depth === 0) {
-      parts.push(className.slice(start, index));
-      start = index + 1;
-    }
-  }
-  return { variants: parts, utility: className.slice(start).replace(/^!|!$/g, "") };
-}
-
-function offHeight(className) {
-  const { variants, utility } = variantsAndUtility(className);
-  if (variants.some((variant) => variant.startsWith("[&") || /^\*{1,2}$/.test(variant)))
-    return undefined;
-  const match =
-    /^(?<property>min-h|h|size)-(?:(?<steps>\d+(?:\.\d+)?)|\[(?<px>\d+(?:\.\d+)?)px\])$/.exec(
-      utility,
-    );
-  if (!match?.groups) return undefined;
-  const { property, steps, px } = match.groups;
-  const pixels = steps === undefined ? Number(px) : Number(steps) * SPACING_UNIT_PX;
-  const growsFromFloor = property === "min-h";
-  if (pixels > 0 && pixels < CONTROL_HEIGHT_PX) return "small";
-  if (pixels > CONTROL_HEIGHT_PX && !growsFromFloor) return "tall";
-  return undefined;
-}
-
-function literals(node) {
-  if (!node) return [];
-  switch (node.type) {
-    case "Literal":
-      return typeof node.value === "string" ? [{ node, value: node.value }] : [];
-    case "JSXExpressionContainer":
-      return literals(node.expression);
-    case "ConditionalExpression":
-      return [...literals(node.consequent), ...literals(node.alternate)];
-    case "LogicalExpression":
-      return literals(node.right);
-    case "TemplateLiteral":
-      return node.expressions.length === 0
-        ? [{ node, value: node.quasis.map((quasi) => quasi.value.cooked).join("") }]
-        : [];
-    default:
-      return [];
-  }
-}
-
-export const oneControlHeight = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Require the 32px control height for every control in product chrome",
-    },
-    schema: [],
-    messages: {
-      smallControl:
-        '{{attribute}}="{{size}}" renders this control below the 32px control height. Product chrome uses one control: drop the size for the default, or use "icon" for an icon-only control (DESIGN.md "Layout", rule/one-control-height).',
-      smallClassHeight:
-        '"{{utility}}" sets this control below the 32px control height. Product chrome uses one control: drop the height and let the control keep `h-control-height` (DESIGN.md "Layout", rule/one-control-height).',
-      tallClassHeight:
-        '"{{utility}}" sets this control above the 32px control height. Product chrome uses one control: drop the height and let the control keep `h-control-height` (DESIGN.md "Layout", rule/one-control-height).',
-    },
-  },
-  create(context) {
-    const reportSmall = (valueNode, attribute) => {
-      for (const { node, value } of literals(valueNode)) {
-        if (!SMALL_SIZES.has(value)) continue;
-        context.report({ node, messageId: "smallControl", data: { attribute, size: value } });
-      }
-    };
-    return {
-      CallExpression(call) {
-        if (call.callee.type !== "Identifier" || !VARIANT_FUNCTIONS.has(call.callee.name)) return;
-        const [options] = call.arguments;
-        if (options?.type !== "ObjectExpression") return;
-        for (const property of options.properties) {
-          if (property.type !== "Property" || property.computed) continue;
-          const key = property.key.type === "Identifier" ? property.key.name : property.key.value;
-          if (key === "size") reportSmall(property.value, "size");
-        }
-      },
-      JSXAttribute(attribute) {
-        const attributeName = attribute.name.type === "JSXIdentifier" ? attribute.name.name : "";
-        if (attributeName === "className") {
-          if (!isControl(jsxComponentName(attribute.parent, context))) return;
-          const large = attribute.parent.attributes.some((other) => {
-            if (other.type !== "JSXAttribute" || other.name.name !== "size") return false;
-            const sizes = literals(other.value);
-            return sizes.length > 0 && sizes.every(({ value }) => value === "lg");
-          });
-          for (const utility of classUtilities(attribute, context)) {
-            const off = offHeight(utility);
-            if (off === "tall" && large) continue;
-            if (off)
-              context.report({
-                node: attribute,
-                messageId: `${off}ClassHeight`,
-                data: { utility },
-              });
-          }
-          return;
-        }
-        if (attributeName !== "size" && attributeName !== "triggerSize") return;
-        if (attributeName === "size" && !isControl(jsxComponentName(attribute.parent, context)))
-          return;
-        reportSmall(attribute.value, attributeName);
-      },
-    };
-  },
-};

package/dist/eslint/rules/overlay-body-owns-scroll.js

@@ -1,62 +0,0 @@
-/*
- * An overlay scrolls in its body slot.
- *
- * `DialogContent` already scrolls when its content outgrows the viewport. A
- * dialog or drawer that keeps its header and actions in place while the rest
- * scrolls puts that rest in `DialogBody` or `DrawerBody` from `@nadicodeai/ui`,
- * which own the scroll, the flex sizing that lets it shrink, and the inset that
- * keeps a field's focus outline from being clipped. A caller that writes its own
- * `overflow-y-auto` inside the overlay repeats that geometry, and the copies
- * drift: the Portal's action dialog carried two, a pixel apart.
- *
- * Standard tool checked first: `better-tailwindcss/no-restricted-classes` bans a
- * class everywhere and cannot ask what encloses it. "A scroll container inside an
- * overlay" is a relationship between two elements, so it is read here, on the
- * shared component-name and className readers.
- */
-import { jsxComponentName, openingElementClassUtilities } from "./jsx-class-utility.js";
-
-const OVERLAY_CONTENT = new Map([
-  ["DialogContent", "DialogBody"],
-  ["DrawerContent", "DrawerBody"],
-]);
-
-const SCROLL_UTILITIES = new Set(["overflow-y-auto", "overflow-y-scroll", "overflow-auto"]);
-
-export const overlayBodyOwnsScroll = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Require an overlay's scrolling region to be its package body slot",
-    },
-    schema: [],
-    messages: {
-      ownScroll:
-        '"{{utility}}" makes this element a second scroll container inside <{{overlay}}>. The body slot owns an overlay\'s scroll, its shrinking and the inset that keeps focus outlines visible. Put the content in <{{body}}> from @nadicodeai/ui and drop the overflow classes (rule/overlay-body-owns-scroll).',
-    },
-  },
-  create(context) {
-    return {
-      JSXOpeningElement(node) {
-        const utility = openingElementClassUtilities(node, context).find((candidate) =>
-          SCROLL_UTILITIES.has(candidate),
-        );
-        if (!utility) return;
-        const own = jsxComponentName(node, context);
-        if (own && OVERLAY_CONTENT.has(own)) return;
-
-        for (const ancestor of context.sourceCode.getAncestors(node)) {
-          if (ancestor.type !== "JSXElement" || ancestor.openingElement === node) continue;
-          const overlay = jsxComponentName(ancestor.openingElement, context);
-          if (!overlay || !OVERLAY_CONTENT.has(overlay)) continue;
-          context.report({
-            node,
-            messageId: "ownScroll",
-            data: { utility, overlay, body: OVERLAY_CONTENT.get(overlay) },
-          });
-          return;
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/overlay-mounts-closed.js

@@ -1,102 +0,0 @@
-/*
- * An overlay is mounted closed and then opened, so its entry runs.
- *
- * A dialog, drawer, sheet or menu fades in from its starting style when its
- * `open` turns true on a mounted element. One that first mounts already open
- * has no earlier frame to transition from, so it appears at full opacity, and
- * one that unmounts on dismissal never plays its exit. Three spellings mount an
- * overlay open: an `open` fixed to true (its parent mounts it on demand), a
- * truthy `defaultOpen`, and a `key` that changes per opening, which remounts it
- * in the same render that opens it. A list key inside a `.map` callback and a
- * literal key are an element's identity, not an opening.
- *
- * Standard tool checked first: `no-restricted-syntax` can match the attribute,
- * but not the renamed import or the enclosing `.map` a list key sits in, so the
- * shared component-name reader resolves it here.
- */
-import { jsxComponentName } from "./jsx-class-utility.js";
-
-const OVERLAY = /Dialog|Drawer|Sheet|Popover|Menu|Tooltip|HoverCard|Combobox/;
-const PART =
-  /(Content|Trigger|Title|Description|Header|Footer|Body|Item|Group|Label|Separator|Close|Portal|Overlay|Backdrop)$/;
-const LIST_CALLBACK = new Set(["map", "flatMap"]);
-
-function attribute(node, name) {
-  return node.attributes.find(
-    (entry) =>
-      entry.type === "JSXAttribute" &&
-      entry.name.type === "JSXIdentifier" &&
-      entry.name.name === name,
-  );
-}
-
-function isTrue(entry) {
-  if (!entry) return false;
-  if (entry.value === null) return true;
-  return (
-    entry.value.type === "JSXExpressionContainer" &&
-    entry.value.expression.type === "Literal" &&
-    entry.value.expression.value === true
-  );
-}
-
-function isLiteralKey(entry) {
-  if (entry.value?.type === "Literal") return true;
-  const expression =
-    entry.value?.type === "JSXExpressionContainer" ? entry.value.expression : undefined;
-  return (
-    expression?.type === "Literal" ||
-    (expression?.type === "TemplateLiteral" && expression.expressions.length === 0)
-  );
-}
-
-function insideListCallback(node, context) {
-  return context.sourceCode
-    .getAncestors(node)
-    .some(
-      (ancestor) =>
-        (ancestor.type === "ArrowFunctionExpression" || ancestor.type === "FunctionExpression") &&
-        ancestor.parent?.type === "CallExpression" &&
-        ancestor.parent.arguments.includes(ancestor) &&
-        ancestor.parent.callee.type === "MemberExpression" &&
-        LIST_CALLBACK.has(ancestor.parent.callee.property.name),
-    );
-}
-
-export const overlayMountsClosed = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Disallow an overlay that mounts already open, so its entry and exit transitions run",
-    },
-    schema: [],
-    messages: {
-      openFixed:
-        "<{{name}}> is given `open` fixed to true, so it only exists while open and neither its fade in nor its fade out runs. Keep it mounted and drive `open` from state.",
-      defaultOpen:
-        "<{{name}}> mounts open through `defaultOpen`, so its entry never runs. Mount it closed and open it from state.",
-      keyPerOpening:
-        "<{{name}}> takes a `key` that remounts it, so an opening that changes the key mounts it already open and its fade in never runs. Keep one mounted overlay and reset its content another way, such as a key on the content inside it.",
-    },
-  },
-  create(context) {
-    return {
-      JSXOpeningElement(node) {
-        const name = jsxComponentName(node, context);
-        if (!name || !OVERLAY.test(name) || PART.test(name)) return;
-
-        if (isTrue(attribute(node, "open"))) {
-          context.report({ node, messageId: "openFixed", data: { name } });
-        }
-        if (isTrue(attribute(node, "defaultOpen"))) {
-          context.report({ node, messageId: "defaultOpen", data: { name } });
-        }
-        const key = attribute(node, "key");
-        if (key && !isLiteralKey(key) && !insideListCallback(node, context)) {
-          context.report({ node, messageId: "keyPerOpening", data: { name } });
-        }
-      },
-    };
-  },
-};