@nadicodeai/ui 12.1.54 → 12.1.56

package/dist/eslint/rules/no-native-visible-control.js

@@ -1,92 +0,0 @@
-import { packageOwnedPrimitivesSchema, skipsPackageOwnedPrimitive } from "./jsx-class-utility.js";
-
-const NATIVE_CONTROLS = new Set(["button", "details", "input", "select", "textarea"]);
-
-function staticValue(node) {
-  if (node?.type === "Literal") {
-    return node.value;
-  }
-  if (node?.type === "JSXExpressionContainer") {
-    return staticValue(node.expression);
-  }
-  if (node?.type === "TemplateLiteral" && node.expressions.length === 0) {
-    return node.quasis[0]?.value.cooked;
-  }
-  return undefined;
-}
-
-function hiddenInput(node) {
-  const typeAttribute = node.attributes.find(
-    (attribute) => attribute.type === "JSXAttribute" && attribute.name.name === "type",
-  );
-  return staticValue(typeAttribute?.value) === "hidden";
-}
-
-function isPrimitiveRenderElement(node, packagePrimitiveNames) {
-  const expression = node.parent;
-  const attribute = expression?.parent;
-  const openingElement = attribute?.parent;
-  return (
-    expression?.type === "JSXExpressionContainer" &&
-    attribute?.type === "JSXAttribute" &&
-    attribute.name.name === "render" &&
-    openingElement?.type === "JSXOpeningElement" &&
-    openingElement.name.type === "JSXIdentifier" &&
-    packagePrimitiveNames.has(openingElement.name.name)
-  );
-}
-
-export const noNativeVisibleControl = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow visible native controls in app source; use @nadicodeai/ui primitives",
-    },
-    // Default "exempt": the package's own source is where the primitives that
-    // replace a native control are built, so a native <button> there is the
-    // implementation, not a bypass.
-    schema: [packageOwnedPrimitivesSchema],
-    messages: {
-      nativeVisibleControl:
-        "Use the @nadicodeai/ui primitive instead of native visible <{{element}}>{{hint}}.",
-    },
-  },
-  create(context) {
-    if (skipsPackageOwnedPrimitive(context)) {
-      return {};
-    }
-    const packagePrimitiveNames = new Set();
-    return {
-      ImportDeclaration(node) {
-        if (
-          typeof node.source.value !== "string" ||
-          !node.source.value.startsWith("@nadicodeai/ui")
-        ) {
-          return;
-        }
-        for (const specifier of node.specifiers) {
-          packagePrimitiveNames.add(specifier.local.name);
-        }
-      },
-      JSXOpeningElement(node) {
-        if (node.name.type !== "JSXIdentifier" || !NATIVE_CONTROLS.has(node.name.name)) {
-          return;
-        }
-        if (node.name.name === "input" && hiddenInput(node)) {
-          return;
-        }
-        if (isPrimitiveRenderElement(node.parent, packagePrimitiveNames)) {
-          return;
-        }
-        context.report({
-          node: node.name,
-          messageId: "nativeVisibleControl",
-          data: {
-            element: node.name.name,
-            hint: node.name.name === "details" ? ": Disclosure draws the one disclosure" : "",
-          },
-        });
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-nested-overlay.js

@@ -1,56 +0,0 @@
-/*
- * One overlay at a time.
- *
- * `DialogContent`, `AlertDialogContent`, `SheetContent` and `DrawerContent` each
- * mount a focus trap, a scrim and a layer of their own. Writing one inside
- * another leaves both traps armed on the same tree: focus cannot leave the inner
- * surface to reach the outer one's controls, Escape resolves against whichever
- * trap won the race, and the two scrims composite into a second dim over content
- * that is already dimmed. Nothing about this is visible while the inner overlay
- * is closed, which is why it survives review and reaches the keyboard user.
- *
- * Standard tool checked first: `no-restricted-syntax` selects one node by its
- * shape and cannot ask what encloses it. "An overlay inside an overlay" is a
- * relationship between two elements, so it is read here, on the shared
- * component-name reader that also resolves renamed imports.
- */
-import { jsxComponentName } from "./jsx-class-utility.js";
-
-const OVERLAY_CONTENT = new Set([
-  "AlertDialogContent",
-  "DialogContent",
-  "DrawerContent",
-  "SheetContent",
-]);
-
-export const noNestedOverlay = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow an overlay surface rendered inside another overlay surface",
-    },
-    schema: [],
-    messages: {
-      nestedOverlay:
-        "<{{inner}}> is rendered inside <{{outer}}>. Two overlays on one tree keep both focus traps armed, so the keyboard cannot reach the outer surface and Escape closes the wrong layer, while the scrims stack. Render the second overlay as a sibling driven by state, or replace it with an inline disclosure inside the first.",
-    },
-  },
-  create(context) {
-    return {
-      JSXOpeningElement(node) {
-        const inner = jsxComponentName(node, context);
-        if (!inner || !OVERLAY_CONTENT.has(inner)) return;
-
-        for (const ancestor of context.sourceCode.getAncestors(node)) {
-          // The element this opening tag belongs to is an ancestor of it, and it
-          // is not nested inside itself.
-          if (ancestor.type !== "JSXElement" || ancestor.openingElement === node) continue;
-          const outer = jsxComponentName(ancestor.openingElement, context);
-          if (!outer || !OVERLAY_CONTENT.has(outer)) continue;
-          context.report({ node, messageId: "nestedOverlay", data: { inner, outer } });
-          return;
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-off-grid-spacing.js

@@ -1,115 +0,0 @@
-/*
- * The spacing ladder is closed. DESIGN.md, "Layout > Spacing": "One ladder
- * carries every gap, pad, and stack step. A register picks the rungs it needs;
- * it never interpolates."
- *
- * A pixel value typed into a spacing utility — `p-[13px]`, `gap-[7px]` — is that
- * interpolation. It reads as deliberate and is usually an eyeballed nudge, it
- * cannot move when the ladder does, and every one of them puts a second rhythm
- * beside the one the rest of the surface is built on, which is what makes a
- * layout look almost aligned.
- *
- * Only a bare pixel literal is a finding. `p-[var(--nc-cell-padding)]`,
- * `px-[clamp(24px,5vw,64px)]` and `top-[calc(var(--titlebar-height)+0.5rem)]` are
- * relationships to something the page owns rather than a measurement invented at
- * the call site, so they are outside this rule. So is a value that already lands
- * on a rung: it is the ladder, spelled the long way.
- *
- * Standard tool checked first: `better-tailwindcss`'s `no-restricted-classes`
- * matches a class against a pattern and could refuse every arbitrary spacing
- * value, but its message is the pattern's, one text for every hit. The fix here
- * is a different token for every value, and naming the nearest rung is the whole
- * point of the message, so the arithmetic lives in a rule.
- */
-import { tokenUtilityVisitors } from "./jsx-class-utility.js";
-
-/*
- * The ladder as the theme emits it: `--spacing-nadicode-*`, which Tailwind
- * spells `p-nadicode-md`, `gap-nadicode-lg` and so on. These are the rungs a
- * step may take and the ones a message offers.
- */
-const LADDER = [
-  [0, "0"],
-  [4, "nadicode-xxs"],
-  [8, "nadicode-xs"],
-  [12, "nadicode-sm"],
-  [16, "nadicode-md"],
-  [24, "nadicode-lg"],
-  [32, "nadicode-xl"],
-  [40, "nadicode-2xl"],
-  [48, "nadicode-3xl"],
-  [64, "nadicode-4xl"],
-  [96, "nadicode-5xl"],
-  [128, "nadicode-6xl"],
-];
-
-/*
- * Control geometry from the same section: the seam weight, the focus outline and
- * its offset, a control's inline padding, and the coarse-pointer target. Each
- * owns one role rather than the general rhythm, so a value that lands on one is
- * legal and none of them is ever offered as the nearest rung for a gap.
- */
-const CONTROL_GEOMETRY = new Set([1, 2, 10, 44]);
-
-const SPACING_PREFIX =
-  "(?:p|px|py|pt|pr|pb|pl|ps|pe|m|mx|my|mt|mr|mb|ml|ms|me|gap|gap-x|gap-y|space-x|space-y|inset|inset-x|inset-y|top|right|bottom|left|start|end)";
-const OFF_GRID = new RegExp(`^-?(${SPACING_PREFIX})-\\[(-?\\d+(?:\\.\\d+)?)px\\]$`);
-
-/** `md:hover:p-[13px]` → `p-[13px]`, with a colon inside brackets left alone. */
-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);
-}
-
-/** The closest rung, and the larger of the two when a value sits between them. */
-function nearestRung(pixels) {
-  return LADDER.reduce((closest, rung) =>
-    Math.abs(rung[0] - pixels) <= Math.abs(closest[0] - pixels) ? rung : closest,
-  );
-}
-
-/*
- * A step below zero is written both ways — `-mt-[3px]` puts the sign on the
- * utility, `bottom-[-5px]` puts it in the value — and the replacement carries it
- * on the utility either way, because a token holds a magnitude.
- */
-function offGridFinding(utility) {
-  const unqualified = withoutVariants(utility);
-  const match = OFF_GRID.exec(unqualified);
-  if (!match) return undefined;
-  const [, prefix, value] = match;
-  const pixels = Math.abs(Number(value));
-  if (CONTROL_GEOMETRY.has(pixels)) return undefined;
-  const [rung, token] = nearestRung(pixels);
-  if (rung === pixels) return undefined;
-  const sign = unqualified.startsWith("-") || value.startsWith("-") ? "-" : "";
-  return { value: String(pixels), rung: String(rung), replacement: `${sign}${prefix}-${token}` };
-}
-
-export const noOffGridSpacing = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Disallow a pixel value typed into a spacing utility off the design-system ladder",
-    },
-    schema: [],
-    messages: {
-      offGridSpacing:
-        '"{{utility}}" puts a {{value}}px step beside a layout built on the design-system spacing ladder, so the rhythm reads as almost aligned and the value cannot follow the tokens. The nearest rung is {{rung}}px: use {{replacement}}.',
-    },
-  },
-  create(context) {
-    return tokenUtilityVisitors(context, (node, utility) => {
-      const finding = offGridFinding(utility);
-      if (!finding) return;
-      context.report({ node, messageId: "offGridSpacing", data: { utility, ...finding } });
-    });
-  },
-};

package/dist/eslint/rules/no-paired-size-utility.js

@@ -1,66 +0,0 @@
-/*
- * A square is written once: `size-4`, never `h-4 w-4`.
- *
- * Standard tool checked first: `better-tailwindcss`'s
- * `no-restricted-classes` judges one class at a time, so it can ban `h-4`
- * outright but cannot see that a `w-4` is beside it — and the pair is the whole
- * point, since `h-4 w-full` is fine. The relationship lives here, on the shared
- * className reader.
- *
- * Replaces the `paired-size` half of the retired @nadicodeai/ui
- * composition-conventions scanner (#822). Stock shadcn shapes that cannot be
- * written any other way carry an inline disable with the reason at the site.
- */
-import {
-  openingElementClassUtilities,
-  packageOwnedPrimitivesSchema,
-  skipsPackageOwnedPrimitive,
-} from "./jsx-class-utility.js";
-
-/** `md:h-4` → `{ variants: "md:", axis: "h", value: "4" }`, or undefined. */
-function sizeUtility(utility) {
-  const separator = utility.lastIndexOf(":");
-  const variants = utility.slice(0, separator + 1);
-  const base = utility.slice(separator + 1);
-  const match = /^([hw])-(.+)$/.exec(base);
-  return match ? { variants, axis: match[1], value: match[2] } : undefined;
-}
-
-export const noPairedSizeUtility = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow paired h-* and w-* utilities of equal value; use size-*",
-    },
-    schema: [packageOwnedPrimitivesSchema],
-    messages: {
-      pairedSize: "Write the square once: use {{variants}}size-{{value}} instead of a h/w pair.",
-    },
-  },
-  create(context) {
-    if (skipsPackageOwnedPrimitive(context)) {
-      return {};
-    }
-
-    return {
-      JSXOpeningElement(node) {
-        const seen = new Map();
-        for (const utility of openingElementClassUtilities(node, context)) {
-          const parsed = sizeUtility(utility);
-          if (!parsed) continue;
-          const key = `${parsed.variants}${parsed.value}`;
-          const axes = seen.get(key) ?? new Set();
-          axes.add(parsed.axis);
-          seen.set(key, axes);
-          if (axes.size === 2) {
-            context.report({
-              node,
-              messageId: "pairedSize",
-              data: { variants: parsed.variants, value: parsed.value },
-            });
-          }
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-raw-shadow.js

@@ -1,70 +0,0 @@
-/*
- * Depth comes off the ladder, not out of Tailwind's box.
- *
- * DESIGN.md, "Elevation & Depth": the four rungs are the four owned utilities,
- * each authored per mode and carrying its own ring as the recipe's final layer.
- * A stock `shadow-md` is a single light-mode drop shadow: it disappears against
- * the true-black dark workspace, it leaves the surface without the ring its
- * neighbours have, and it does not move when the tokens do. Two surfaces meant
- * to sit at the same physical level then read as different objects.
- *
- * `shadow-none` stays legal — removing a shadow an inherited shape brought with
- * it is the correct thing to write, and it is what `packages/ui` already writes.
- *
- * The two packages that BUILD the ladder are outside the rule: the design system
- * authors the rung values, and `@nadicodeai/ui` composes the utilities onto its
- * primitives. Everywhere else a shadow is a caller inventing depth.
- *
- * Standard tool checked first: `better-tailwindcss/no-unknown-classes` cannot
- * see these, because the generated theme clears only the `--color-*` namespace
- * and leaves Tailwind's own `--shadow-*` in place, so `shadow-lg` is a real
- * class that really paints. `no-restricted-classes` in the Portal and the
- * package configs carries `shadow-tooltip|menu|dialog|sheet` — the NAMED shadows
- * the ladder replaced — and nothing about the size scale; `no-invalid-token-utility`
- * judges `shadow-nc-*` against the generated colour tokens only; and the
- * colour-boundary patterns fire on `-nc-` or on an arbitrary colour value. A
- * probe file carrying `shadow-lg shadow-md shadow-[0_2px_4px_black]` linted
- * clean in `apps/portal` before this rule existed. Holding it as a repo-wide
- * restricted class would need the same entry restated in five configs, since a
- * later `no-restricted-classes` entry replaces the earlier one rather than
- * adding to it, so it is one rule instead.
- */
-import { tokenUtilityVisitors } from "./jsx-class-utility.js";
-
-const RAW_SHADOW = /^shadow(?:-(?:2xs|xs|sm|md|lg|xl|2xl|inner|initial|\[.*\]))?$/;
-const PACKAGE_LADDER_PATHS = ["packages/ui/src/", "packages/design-system/"];
-
-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);
-}
-
-export const noRawShadow = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Disallow Tailwind's stock shadow utilities outside the packages that own the material ladder",
-    },
-    schema: [],
-    messages: {
-      rawShadow:
-        '"{{utility}}" paints a light-mode drop shadow with no ring, so the surface loses its edge against the dark workspace and cannot follow the tokens. Choose the physical level instead: nc-elevation-resting, nc-elevation-raised, nc-elevation-floating, or nc-elevation-modal.',
-    },
-  },
-  create(context) {
-    const filename = context.filename.replaceAll("\\", "/");
-    if (PACKAGE_LADDER_PATHS.some((path) => filename.includes(path))) return {};
-
-    return tokenUtilityVisitors(context, (node, utility) => {
-      if (!RAW_SHADOW.test(withoutVariants(utility))) return;
-      context.report({ node, messageId: "rawShadow", data: { utility } });
-    });
-  },
-};

package/dist/eslint/rules/no-repainted-focus.js

@@ -1,75 +0,0 @@
-import { classUtilities } from "./jsx-class-utility.js";
-
-/**
- * Keyboard focus has one owner: the globals.css base layer draws the offset
- * ink outline on every :focus-visible element (DESIGN.md "Focus ring"), and an
- * invalid control takes the same geometry in the destructive hue. A component
- * that paints focus with a box-shadow ring, a raw outline width, or its own
- * hue forks that treatment. Standard tool checked first: no
- * upstream Tailwind rule models "focus variant may only suppress or restate
- * the canonical outline".
- *
- * A focus-variant utility may only suppress the outline (outline-none,
- * outline-hidden), restate the canonical treatment on a proxy target through
- * the one shared `nc-focus-outline` utility plus a ring-role color (as
- * input-group does when the group carries the indicator for its inner
- * control), or move non-paint properties (z-index, colors of the element
- * itself, …). Restating the style, width, and offset as separate utilities is
- * a fork of that owner, so the raw outline width belongs to nobody.
- */
-const RING_BASE = /^-?ring(?:-|$)/;
-const ALLOWED_OUTLINE_BASE = new Set(["nc-focus-outline", "outline-none", "outline-hidden"]);
-const ALLOWED_OUTLINE_COLOR = /^outline-(?:ring|sidebar-ring)$/;
-const OUTLINE_OFFSET = /^-?outline-offset-/;
-
-function baseOf(utility) {
-  let depth = 0;
-  let base = utility;
-  for (let i = 0; i < utility.length; i += 1) {
-    const ch = utility[i];
-    if (ch === "[" || ch === "(") depth += 1;
-    else if (ch === "]" || ch === ")") depth -= 1;
-    else if (ch === ":" && depth === 0) base = utility.slice(i + 1);
-  }
-  return base;
-}
-
-function repaintedFocus(utility) {
-  if (!utility.includes("focus")) return undefined;
-  const base = baseOf(utility);
-  if (base === utility) return undefined;
-  if (RING_BASE.test(base)) return "boxShadowFocus";
-  if (base.startsWith("[outline")) return "customFocusOutline";
-  if (ALLOWED_OUTLINE_BASE.has(base)) return undefined;
-  if (!base.startsWith("outline")) return undefined;
-  if (ALLOWED_OUTLINE_COLOR.test(base) || OUTLINE_OFFSET.test(base)) return undefined;
-  return "customFocusOutline";
-}
-
-export const noRepaintedFocus = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Keep keyboard focus on the base-layer outline: no box-shadow ring, raw width, or component hue on a focus variant",
-    },
-    schema: [],
-    messages: {
-      boxShadowFocus:
-        "Focus never paints a box-shadow: the base layer draws the offset outline. Drop {{utility}}.",
-      customFocusOutline:
-        "{{utility}} repaints focus with its own width or hue. The base layer owns the focus outline; a proxy target takes nc-focus-outline plus a ring-role color.",
-    },
-  },
-  create(context) {
-    return {
-      JSXAttribute(node) {
-        for (const utility of classUtilities(node)) {
-          const messageId = repaintedFocus(utility);
-          if (messageId === undefined) continue;
-          context.report({ node, messageId, data: { utility } });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-resting-settings-control.js

@@ -1,89 +0,0 @@
-/*
- * The settings law, proved on the surfaces that declare they follow it.
- *
- * A file that renders `SettingsFactsSection` has said its settings are a
- * reading surface: current values stated as facts, one affordance opening the
- * editor that changes them. The regression this catches is a form control
- * rendered beside those facts rather than inside the editor they summon.
- *
- * "Inside the editor" means inside a `SettingsSection`, an `ActionDialogForm`'s
- * `fields` prop, or a `Dialog`/`Drawer` subtree for a surface that owns its own. Being a
- * CHILD of `ActionDialogForm` is the opposite: children are the resting surface
- * the dialog is opened from, which is exactly where a control must not be.
- *
- * The scope is the declaring file rather than every page, so a registry
- * toolbar's search or a mobile nav select is never a violation — a guard whose
- * allow-list carries live violations documents debt instead of preventing it.
- *
- * Standard tool checked first: `no-restricted-syntax` selects one
- * node by shape and cannot ask what else the file renders, nor whether an
- * ancestor summoned the subtree. Both are relationships, so the rule lives
- * here. Replaces `restingSettingsControlViolations` in the retired portal
- * page-grammar analyzers (#821).
- */
-import { jsxComponentName } from "./jsx-class-utility.js";
-
-// The controls a person types or picks into. Lowercase `input` is deliberately
-// absent: a hidden field carries context a summoned editor already decided, and
-// it is not a control anyone rests their eyes on.
-const RESTING_CONTROL_TAGS = new Set([
-  "Checkbox",
-  "Input",
-  "InputOTP",
-  "NativeSelect",
-  "Select",
-  "Switch",
-  "Textarea",
-]);
-
-const FACTS_SECTION_TAG = "SettingsFactsSection";
-
-function summons(node, context) {
-  if (node.type === "JSXAttribute") {
-    return (
-      node.name.name === "fields" && jsxComponentName(node.parent, context) === "ActionDialogForm"
-    );
-  }
-  if (node.type !== "JSXElement") return false;
-  const name = jsxComponentName(node.openingElement, context);
-  return ["SettingsSection", "Dialog", "DialogContent", "Drawer", "DrawerContent"].includes(name);
-}
-
-export const noRestingSettingsControl = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Disallow a form control resting beside the facts it should be summoned over, on a settings-facts surface",
-    },
-    schema: [],
-    messages: {
-      restingControl:
-        "<{{tag}}> rests beside its facts: use SettingsSection for a form, or put it in the summoned editor (ActionDialogForm `fields`, Dialog, or Drawer).",
-    },
-  },
-  create(context) {
-    let declaresFacts = false;
-    const resting = [];
-
-    return {
-      JSXOpeningElement(node) {
-        const name = jsxComponentName(node, context);
-        if (name === FACTS_SECTION_TAG) {
-          declaresFacts = true;
-          return;
-        }
-        if (!name || !RESTING_CONTROL_TAGS.has(name)) return;
-        if (context.sourceCode.getAncestors(node).some((ancestor) => summons(ancestor, context)))
-          return;
-        resting.push({ node, name });
-      },
-      "Program:exit"() {
-        if (!declaresFacts) return;
-        for (const { node, name } of resting) {
-          context.report({ node, messageId: "restingControl", data: { tag: name } });
-        }
-      },
-    };
-  },
-};