@nadicodeai/ui 12.1.54 → 12.1.55

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 } });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/prefer-radio-for-few-static-options.js

@@ -1,77 +0,0 @@
-/*
- * A short fixed set of choices is shown, not hidden.
- *
- * A `Select` spends a click and a popup to reveal what it holds. That trade pays
- * for itself over a long or a loaded list; it does not pay for two or three
- * options that are known at author time, where the popup costs the reader the
- * one thing they came for — seeing what the alternatives are — and costs the
- * keyboard user an open-then-arrow instead of a single arrow.
- *
- * The count has to be STATIC to be a finding. A `SelectContent` filled from
- * `{items.map(...)}` holds however many rows the data has today, so its shape is
- * not this rule's business and any expression child stands the rule down.
- *
- * Standard tool checked first: `no-restricted-syntax` can select a
- * `SelectContent`, but not one whose children are exactly two or three elements
- * of one name and nothing dynamic. That is a property of the subtree, so it is
- * read here.
- */
-import { jsxComponentName } from "./jsx-class-utility.js";
-
-const CONTENT_TAG = "SelectContent";
-const ITEM_TAG = "SelectItem";
-
-/*
- * The items one content subtree renders, and whether anything in it is computed.
- * Groups and separators are descended through; an item's own children are not,
- * because a label built from a variable says nothing about how many items there
- * are. Attributes are out of scope for the same reason: `value={option.value}`
- * on a hand-written item is ordinary.
- */
-function scanContent(node, context, found) {
-  for (const child of node.children) {
-    if (child.type === "JSXExpressionContainer") {
-      if (child.expression.type !== "JSXEmptyExpression") found.dynamic = true;
-      continue;
-    }
-    if (child.type === "JSXFragment") {
-      scanContent(child, context, found);
-      continue;
-    }
-    if (child.type !== "JSXElement") continue;
-    if (jsxComponentName(child.openingElement, context) === ITEM_TAG) {
-      found.items.push(child);
-      continue;
-    }
-    scanContent(child, context, found);
-  }
-  return found;
-}
-
-export const preferRadioForFewStaticOptions = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Prefer RadioGroup over Select for two or three statically written options",
-    },
-    schema: [],
-    messages: {
-      fewStaticOptions:
-        "This Select holds {{count}} options fixed at author time, so a reader has to open it to learn what the alternatives are. RadioGroup shows all {{count}} at once and takes one arrow key instead of an open and an arrow. Use RadioGroup with a RadioGroupItem per option.",
-    },
-  },
-  create(context) {
-    return {
-      JSXElement(node) {
-        if (jsxComponentName(node.openingElement, context) !== CONTENT_TAG) return;
-        const { items, dynamic } = scanContent(node, context, { items: [], dynamic: false });
-        if (dynamic || items.length < 2 || items.length > 3) return;
-        context.report({
-          node: node.openingElement,
-          messageId: "fewStaticOptions",
-          data: { count: String(items.length) },
-        });
-      },
-    };
-  },
-};

package/dist/eslint/rules/settings-section-description.js

@@ -1,45 +0,0 @@
-/*
- * Every settings section says what it changes.
- *
- * DESIGN.md ("Cards and sections") gives a settings section a one-line
- * description under its title, the line that tells a person what changing the
- * fields below will do before they change them. The failure this catches: the
- * Portal's Profile photo and Personal details sections, whose titles named the
- * content and nothing said what the change reaches.
- *
- * What is read is a `SettingsSection` element and whether it passes a
- * `description` attribute. A spread may carry one, so an element with a spread
- * attribute is not reported.
- *
- * Standard tool checked first: `no-restricted-syntax` can select
- * `JSXOpeningElement[name.name="SettingsSection"]:not(:has(JSXAttribute[name.name="description"]))`,
- * but not through a renamed import, which `jsxComponentName` resolves.
- */
-import { jsxComponentName } from "./jsx-class-utility.js";
-
-export const settingsSectionDescription = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Require a one-line description on every SettingsSection",
-    },
-    schema: [],
-    messages: {
-      missingDescription:
-        'This SettingsSection has no description. Say in one line what changing it does, under its title (DESIGN.md "Cards and sections", rule/settings-section-described).',
-    },
-  },
-  create(context) {
-    return {
-      JSXOpeningElement(node) {
-        if (jsxComponentName(node, context) !== "SettingsSection") return;
-        const described = node.attributes.some(
-          (attribute) =>
-            attribute.type === "JSXSpreadAttribute" ||
-            (attribute.name?.type === "JSXIdentifier" && attribute.name.name === "description"),
-        );
-        if (!described) context.report({ node, messageId: "missingDescription" });
-      },
-    };
-  },
-};