@nadicodeai/ui 12.1.165 → 12.1.166

package/dist/eslint/rules/workspace-declares-imports.js

@@ -1,163 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { builtinModules } from "node:module";
-import { dirname, join, relative, sep } from "node:path";
-
-const DEPENDENCY_FIELDS = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies",
-];
-
-const BUILTINS = new Set(builtinModules);
-
-export const DECLARED_DEPENDENCIES_SETTING = "nadicodeai/declared-dependencies";
-
-const manifests = new Map();
-const scopes = new Map();
-
-function readManifest(directory) {
-  const path = join(directory, "package.json");
-  return existsSync(path) ? JSON.parse(readFileSync(path, "utf8")) : undefined;
-}
-
-function manifestIn(directory) {
-  if (!manifests.has(directory)) manifests.set(directory, readManifest(directory));
-  return manifests.get(directory);
-}
-
-function declaredBy(manifest) {
-  return new Set(DEPENDENCY_FIELDS.flatMap((field) => Object.keys(manifest[field] ?? {})));
-}
-
-function sortedNames(manifest) {
-  return [...declaredBy(manifest)].sort();
-}
-
-export function declaredDependencies(rootDirectory) {
-  const root = readManifest(rootDirectory);
-  const workspaces = {};
-  for (const path of [...workspacePaths(root)].sort()) {
-    const manifest = readManifest(join(rootDirectory, path));
-    if (manifest !== undefined) {
-      workspaces[path] = { name: manifest.name, declared: sortedNames(manifest) };
-    }
-  }
-  return { root: sortedNames(root), workspaces };
-}
-
-function workspacePaths(manifest) {
-  const list = Array.isArray(manifest.workspaces)
-    ? manifest.workspaces
-    : (manifest.workspaces?.packages ?? []);
-  return new Set(list.map((path) => path.replace(/\/$/, "")));
-}
-
-function computeScope(directory) {
-  const candidates = [];
-  for (let current = directory; ; current = dirname(current)) {
-    const manifest = manifestIn(current);
-    if (manifest?.workspaces !== undefined) {
-      const listed = workspacePaths(manifest);
-      const workspace = candidates.find((candidate) =>
-        listed.has(relative(current, candidate).split(sep).join("/")),
-      );
-      if (workspace === undefined) return undefined;
-      const own = manifestIn(workspace);
-      const path = relative(current, workspace).split(sep).join("/");
-      return {
-        workspacePath: path,
-        workspaceName: own.name ?? path,
-        ownName: own.name,
-        rootDeclared: declaredBy(manifest),
-        workspaceDeclared: declaredBy(own),
-      };
-    }
-    if (manifest !== undefined) candidates.push(current);
-    if (dirname(current) === current) return undefined;
-  }
-}
-
-function scopeOf(directory) {
-  if (!scopes.has(directory)) scopes.set(directory, computeScope(directory));
-  return scopes.get(directory);
-}
-
-function declaredNamesOf(scope, given) {
-  const entry = given?.workspaces?.[scope.workspacePath];
-  if (entry === undefined || !Array.isArray(given.root)) return scope;
-  return {
-    ownName: entry.name,
-    workspaceName: entry.name ?? scope.workspacePath,
-    rootDeclared: new Set(given.root),
-    workspaceDeclared: new Set(entry.declared),
-  };
-}
-
-function packageNameOf(specifier) {
-  if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("node:")) {
-    return undefined;
-  }
-  const [first, second = ""] = specifier.split("/");
-  const name = first.startsWith("@") ? `${first}/${second}` : first;
-  return BUILTINS.has(name) ? undefined : name;
-}
-
-function specifierOf(node) {
-  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- ESTree types Literal.value as string | number | boolean | RegExp | bigint | null; only typeof picks the string.
-  return node?.type === "Literal" && typeof node.value === "string" ? node.value : undefined;
-}
-
-export const workspaceDeclaresImports = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Require a workspace to declare each package it imports that the root package.json declares",
-    },
-    schema: [],
-    messages: {
-      undeclared:
-        '"{{name}}" is declared by the root package.json but not by {{workspace}}. Declare it in the workspace that imports it, so a root bump is attributed to that workspace.',
-    },
-  },
-  create(context) {
-    const found = scopeOf(dirname(context.filename));
-    if (found === undefined) return {};
-    const scope = declaredNamesOf(found, context.settings[DECLARED_DEPENDENCIES_SETTING]);
-
-    function check(source) {
-      const specifier = specifierOf(source);
-      if (specifier === undefined) return;
-      const name = packageNameOf(specifier);
-      if (
-        name === undefined ||
-        name === scope.ownName ||
-        !scope.rootDeclared.has(name) ||
-        scope.workspaceDeclared.has(name)
-      ) {
-        return;
-      }
-      context.report({
-        node: source,
-        messageId: "undeclared",
-        data: { name, workspace: scope.workspaceName },
-      });
-    }
-
-    return {
-      ImportDeclaration: (node) => check(node.source),
-      ExportNamedDeclaration: (node) => check(node.source),
-      ExportAllDeclaration: (node) => check(node.source),
-      ImportExpression: (node) => check(node.source),
-      TSExternalModuleReference: (node) => check(node.expression),
-      TSImportType: (node) =>
-        check(node.argument?.type === "TSLiteralType" ? node.argument.literal : node.argument),
-      CallExpression: (node) => {
-        if (node.callee.type === "Identifier" && node.callee.name === "require") {
-          check(node.arguments[0]);
-        }
-      },
-    };
-  },
-};

package/dist/eslint/strict-design-system.js

@@ -1,250 +0,0 @@
-import { createRequire } from "node:module";
-
-/*
- * The strict design-system checks, as selector lists for core
- * `no-restricted-syntax`. The plugin registers that core rule once per check,
- * under the check's own name, so each check keeps its `nadicodeai/<name>` id
- * and no two checks share one option list (flat config replaces a rule's
- * options rather than merging them).
- *
- * A class check reads the string literals inside a `className` attribute and a
- * `cva()` call, one class token at a time, variants included.
- */
-
-const theme = createRequire(import.meta.url)("@nadicodeai/design-system/tailwind").theme.extend;
-const escape = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-
-/** Any variant chain: `md:`, `group-data-x/tabs:`, `has-[[data-slot=a]:focus]:`. */
-const VARIANTS = String.raw`(?:(?:[^\s:\[\]]|\[(?:[^\s\[\]]|\[[^\s\]]*\])*\])+:)*`;
-export const token = (body, variants = VARIANTS) =>
-  String.raw`/(^|\s)${variants}!?(?:${body})!?(\s|$)/`;
-export const literal = (pattern) =>
-  `:matches(Literal[value=${pattern}], TemplateElement[value.raw=${pattern}])`;
-const CLASS_SITES =
-  ":matches(JSXAttribute[name.name='className'], Program:has(ImportDeclaration[source.value='class-variance-authority'] > ImportSpecifier[local.name='cva']) CallExpression[callee.name='cva'])";
-// A cva variant map's keys name variants, not classes.
-const classToken = (body, variants) =>
-  `${CLASS_SITES} ${literal(token(body, variants))}:not(Property > .key)`;
-const ownClass = (body) =>
-  `:has(> JSXOpeningElement:has(JSXAttribute[name.name='className'] ${literal(token(body))}))`;
-
-/** A component import from the package or the app may not be renamed: a check recognises it by its JSX name. */
-export const keepName = (names, checks = "design-system lint checks") =>
-  names.map((name) => ({
-    selector: `ImportDeclaration[source.value=/^(@nadicodeai\\/ui|@\\/components|\\.)/] > ImportSpecifier[imported.name='${name}'][local.name!='${name}']`,
-    message: `Import ${name} under its own name: the ${checks} recognise it by that name.`,
-  }));
-
-const OVERLAY_CONTENT = ["AlertDialogContent", "DialogContent", "DrawerContent", "SheetContent"];
-const OVERLAY_ROOTS = [
-  "Dialog",
-  "AlertDialog",
-  "Drawer",
-  "Sheet",
-  "Popover",
-  "DropdownMenu",
-  "ContextMenu",
-  "Tooltip",
-  "HoverCard",
-  "Combobox",
-  "ActionMenu",
-];
-
-const card = "JSXElement[openingElement.name.name=/^(Card|\\w*Card)$/]";
-const cardChild = `:matches(${card}, JSXExpressionContainer:has(> ${card}), JSXExpressionContainer:has(> :matches(ConditionalExpression, LogicalExpression):has(> ${card})))`;
-const mappedCards = `JSXExpressionContainer:has(> CallExpression[callee.property.name=/^(map|from)$/]:has(${card}))`;
-
-const bareControl =
-  "JSXOpeningElement[name.name=/^(Button|button)$/]:not(:has(> JSXAttribute[name.name=/^aria-label(ledby)?$/])):not(:has(> JSXSpreadAttribute)):not(JSXAttribute[name.name='render'] JSXOpeningElement)";
-const onlyElements =
-  ":not(:matches(JSXElement, JSXFragment, Literal[value=null], Literal[value=false], Identifier[name='undefined'], ConditionalExpression, LogicalExpression))";
-const rendersText = `:matches(JSXText[value=/\\S/], :matches(JSXElement, JSXFragment) > JSXExpressionContainer:not([expression.type=/^(JSXElement|JSXFragment|JSXEmptyExpression|ConditionalExpression|LogicalExpression)$/]), ConditionalExpression > ${onlyElements}:matches(.consequent, .alternate), LogicalExpression > ${onlyElements}.right)`;
-const elementChild =
-  ":matches(JSXElement, JSXFragment, JSXExpressionContainer[expression.type=/^(JSXElement|JSXFragment|ConditionalExpression|LogicalExpression)$/])";
-
-const overlayRoot = `JSXOpeningElement[name.name=/Dialog|Drawer|Sheet|Popover|Menu|Tooltip|HoverCard|Combobox/]:not([name.name=/(Content|Trigger|Title|Description|Header|Footer|Body|Item|Group|Label|Separator|Close|Portal|Overlay|Backdrop)$/])`;
-const isTrue = ":matches([value=null], [value.expression.value=true])";
-
-const selectItem = "JSXElement[openingElement.name.name='SelectItem']";
-const nativeOption =
-  "JSXElement[openingElement.name.name=/^(NativeSelectOption|option)$/]:has(> JSXOpeningElement:has(> JSXAttribute[name.name='value']:matches([value.value=/./], [value.expression.value=/./])))";
-const noExpressionChild =
-  ":not(:has(> JSXExpressionContainer[expression.type!='JSXEmptyExpression']))";
-const fewItems = (parent, item) =>
-  `${parent}:has(> ${item} ~ ${item}):not(:has(> ${item} ~ ${item} ~ ${item} ~ ${item}))${noExpressionChild}`;
-const fewOptions = (root, group, item) =>
-  `JSXElement[openingElement.name.name='${root}']${noExpressionChild}:matches(${fewItems("JSXElement", item)}, :has(> ${fewItems(`JSXElement[openingElement.name.name=/^${group}$/]`, item)})) > JSXOpeningElement`;
-const fewFixedOptionsMessage =
-  "Two or three fixed options are a SegmentedControl when they switch views of one surface, or a RadioGroup when they are a setting; a Select hides them until it opens.";
-
-const drawerSlot = "/^Drawer(Header|Body|Footer)$/";
-const drawerEdge = literal(token(String.raw`border(-[tby])?(-\d+)?`));
-
-const SPACING =
-  "(?: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)";
-// The ladder rungs and the control geometry (seam, focus outline and offset, inline padding, touch target).
-const ON_GRID = String.raw`(?:0|1|2|4|8|10|12|16|24|32|40|44|48|64|96|128)(?:\.0+)?`;
-
-const typographyTokens = Object.keys(theme.fontSize).map(escape).join("|");
-const colorTokens = Object.keys(theme.colors).map(escape).join("|");
-const radiusValues = [...new Set(Object.values(theme.borderRadius))].map(escape).join("|");
-const radiusNames = Object.keys(theme.borderRadius).map(escape).join("|");
-const invalidTokenMessage =
-  "This class is not generated by the installed nadicode design system. Use a utility from @nadicodeai/design-system/tailwind.";
-
-export const strictDesignSystemSelectors = {
-  "card-row-owner": [
-    {
-      selector: `JSXElement:not([openingElement.name.name='CardRow']):matches(${ownClass(String.raw`grid-cols-(?!1(\s|$))\S+`)}, ${ownClass("flex-row")}, ${ownClass("flex")}:not(${ownClass("flex-col")})):matches(:has(> ${cardChild} ~ ${cardChild}), :has(> ${mappedCards})) > JSXOpeningElement`,
-      message:
-        "These cards are laid side by side without the owner of that row. An alignment class or a wrapper around a card is then enough for the shortest card to stop at its content and the row to end on a ragged edge. Use CardRow from @nadicodeai/ui, which stretches its cells and makes every card fill the one it lands in (rule/card-row-equal-height).",
-    },
-  ],
-  "drawer-owns-its-edges": [
-    ...keepName(["DrawerHeader", "DrawerBody", "DrawerFooter"]),
-    {
-      selector: `JSXOpeningElement[name.name=${drawerSlot}] > JSXAttribute[name.name='className'] ${drawerEdge}`,
-      message:
-        "This border gives a drawer slot a second edge. The drawer draws the hairline between its header, its body and its footer; drop the border class (rule/drawer-owns-its-edges).",
-    },
-    {
-      selector: `JSXElement:has(> JSXElement[openingElement.name.name=${drawerSlot}]) > JSXOpeningElement > JSXAttribute[name.name='className'] ${drawerEdge}`,
-      message:
-        "This border draws an edge around a drawer slot. The drawer draws the hairline between its header, its body and its footer; render the slot without this wrapper (rule/drawer-owns-its-edges).",
-    },
-  ],
-  "icon-control-accessible-name": [
-    ...keepName(["Button"]),
-    {
-      selector: `JSXElement:not(:has(${rendersText})):matches(:has(> ${bareControl}:has(> JSXAttribute[name.name='size'][value.value=/^icon(-xs|-sm|-lg)?$/])), :has(> ${elementChild})) > ${bareControl}`,
-      message:
-        'A screen reader announces "button" and nothing more for this control: its content is an icon, and an icon carries no name. Add aria-label with the action it performs, point aria-labelledby at the text that names it, or put that text in a child with the sr-only class.',
-    },
-  ],
-  "no-invalid-token-utility": [
-    {
-      selector: classToken(`nc-type-(?!(?:${typographyTokens})(\\s|$))\\S*`),
-      message: invalidTokenMessage,
-    },
-    {
-      selector: classToken(
-        `(?:bg|text|border|outline|ring|fill|stroke|decoration|accent|caret|divide|from|via|to|shadow)-nc-(?!(?:${colorTokens})(\\/\\S*)?(\\s|$))\\S+`,
-      ),
-      message: invalidTokenMessage,
-    },
-  ],
-  "no-native-visible-control": [
-    {
-      selector:
-        "JSXOpeningElement[name.name=/^(button|details|input|select|textarea)$/]:not([name.name='input']:has(> JSXAttribute[name.name='type']:matches([value.value='hidden'], [value.expression.value='hidden'], [value.expression.quasis.0.value.cooked='hidden']))):not(JSXOpeningElement > JSXAttribute[name.name='render'] > JSXExpressionContainer > JSXElement > JSXOpeningElement):not(Property[key.name='render'] > JSXElement > JSXOpeningElement)",
-      message:
-        "Use the @nadicodeai/ui primitive instead of a native visible control; a <details> takes Disclosure, which draws the one disclosure.",
-    },
-  ],
-  "no-nested-overlay": [
-    ...keepName(OVERLAY_CONTENT),
-    {
-      selector: `JSXElement[openingElement.name.name=/^(${OVERLAY_CONTENT.join("|")})$/] JSXElement[openingElement.name.name=/^(${OVERLAY_CONTENT.join("|")})$/] > JSXOpeningElement`,
-      message:
-        "This overlay is rendered inside another overlay. 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.",
-    },
-  ],
-  "no-off-grid-spacing": [
-    {
-      selector: classToken(String.raw`-?${SPACING}-\[-?(?!${ON_GRID}px\])\d+(?:\.\d+)?px\]`),
-      message:
-        "This pixel step sits off the design-system spacing ladder, so the rhythm reads as almost aligned and the value cannot follow the tokens. Use a rung: 0, nadicode-xxs (4px), nadicode-xs (8), nadicode-sm (12), nadicode-md (16), nadicode-lg (24), nadicode-xl (32), nadicode-2xl (40), nadicode-3xl (48), nadicode-4xl (64), nadicode-5xl (96), nadicode-6xl (128).",
-    },
-  ],
-  "no-raw-shadow": [
-    {
-      selector: classToken(
-        String.raw`shadow(?:-(?:2xs|xs|sm|md|lg|xl|2xl|inner|initial|\[\S*\]))?`,
-      ),
-      message:
-        "A stock shadow 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.",
-    },
-  ],
-  "no-repainted-focus": [
-    {
-      selector: classToken(
-        String.raw`-?ring(?:-\S*)?`,
-        String.raw`(?=\S*focus)${VARIANTS.slice(0, -1)}+`,
-      ),
-      message:
-        "Focus never paints a box-shadow: the base layer draws the offset outline. Drop this ring utility.",
-    },
-    {
-      selector: classToken(
-        String.raw`\[outline\S*|outline(?!-(?:none|hidden|ring|sidebar-ring)(?:\s|$))(?!-offset-)(?:-\S*)?`,
-        String.raw`(?=\S*focus)${VARIANTS.slice(0, -1)}+`,
-      ),
-      message:
-        "This 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.",
-    },
-  ],
-  "no-token-category-bypass": [
-    {
-      selector: classToken(
-        String.raw`rounded(?:-(?:t|r|b|l|s|e|ss|se|ee|es|tl|tr|br|bl))?-\[\s*(?:${radiusValues}|var\(--(?:nc-rounded|radius)-(?:${radiusNames})\))\s*\]`,
-      ),
-      message:
-        "This class spells a design-system radius by its value. Use the generated rounded-<token> utility the value belongs to.",
-    },
-  ],
-  "overlay-body-owns-scroll": [
-    ...keepName(["DialogContent", "DrawerContent"]),
-    {
-      selector: `JSXElement[openingElement.name.name=/^(DialogContent|DrawerContent)$/] JSXOpeningElement:not([name.name=/^(DialogContent|DrawerContent)$/]) > JSXAttribute[name.name='className'] ${literal(token("overflow-y-auto|overflow-y-scroll|overflow-auto"))}`,
-      message:
-        "This makes the element a second scroll container inside an overlay. The body slot owns an overlay's scroll, its shrinking and the inset that keeps focus outlines visible. Put the content in DialogBody or DrawerBody from @nadicodeai/ui and drop the overflow classes (rule/overlay-body-owns-scroll).",
-    },
-  ],
-  "overlay-mounts-closed": [
-    ...keepName(OVERLAY_ROOTS),
-    {
-      selector: `${overlayRoot} > JSXAttribute[name.name='open']${isTrue}`,
-      message:
-        "This overlay 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.",
-    },
-    {
-      selector: `${overlayRoot} > JSXAttribute[name.name='defaultOpen']${isTrue}`,
-      message:
-        "This overlay mounts open through `defaultOpen`, so its entry never runs. Mount it closed and open it from state.",
-    },
-    {
-      selector: `${overlayRoot} > JSXAttribute[name.name='key'][value.type='JSXExpressionContainer']:not([value.expression.type='Literal']):not([value.expression.type='TemplateLiteral'][value.expression.expressions.length=0]):not(CallExpression[callee.property.name=/^(map|flatMap)$/] > :function JSXAttribute)`,
-      message:
-        "This overlay 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.",
-    },
-  ],
-  "waiting-line-stays-mounted": [
-    ...keepName(["WaitingLine"]),
-    ...[
-      "LogicalExpression > JSXElement[openingElement.name.name='WaitingLine']",
-      "ConditionalExpression:not([alternate.type='JSXElement']) > JSXElement.consequent[openingElement.name.name='WaitingLine']",
-      "ConditionalExpression:not([consequent.type='JSXElement']) > JSXElement.alternate[openingElement.name.name='WaitingLine']",
-    ].map((selector) => ({
-      selector,
-      message:
-        "This waiting line mounts with the wait, so its 2 px and its gap arrive with it and the layout moves. Keep it mounted with the control it waits for and pass `waiting`, or place it on its container's edge, out of the flow (rule/waiting-line-stays-mounted).",
-    })),
-  ],
-  "prefer-radio-for-few-static-options": [
-    ...keepName([
-      "SelectContent",
-      "SelectItem",
-      "NativeSelect",
-      "NativeSelectOption",
-      "NativeSelectOptGroup",
-    ]),
-    {
-      selector: fewOptions("SelectContent", "SelectGroup", selectItem),
-      message: fewFixedOptionsMessage,
-    },
-    {
-      selector: fewOptions("NativeSelect", "(NativeSelectOptGroup|optgroup)", nativeOption),
-      message: fewFixedOptionsMessage,
-    },
-  ],
-};