@nadicodeai/ui 12.1.165 → 12.1.167

package/dist/eslint/rules/no-control-in-read-only-surface.js

@@ -1,106 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector can match a
- * `Button` below `TooltipContent`, but not follow a renamed import to the part,
- * count the links across a HoverCardContent's children and its summary's
- * `action`.
- */
-import { renderedImports, walk } from "./rendered-import.js";
-
-const OVERLAYS = new Set(["Tooltip", "HoverCard"]);
-const CONTROLS = new Set(["Button", "ButtonLink", "TextLink", "Link", "a"]);
-const NATIVE_CONTROLS = new Set(["input", "select", "textarea"]);
-const HOVER_CARD_SUMMARY = "HoverCardSummary";
-
-const hasAttribute = (openingElement, attributeName) =>
-  openingElement.attributes.some(
-    (attribute) => attribute.type === "JSXAttribute" && attribute.name.name === attributeName,
-  );
-
-export const noControlInReadOnlySurface = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Tooltip text and a Choicebox tile are for reading; a HoverCard holds at most one link.",
-    },
-    schema: [],
-    messages: {
-      "read-only-surface":
-        "Tooltip text and a Choicebox tile are for reading: move the control outside. A HoverCard holds at most one link, through HoverCardSummary's `action`, and never a second Tooltip or HoverCard; for more, open a Popover, a menu or the record's page.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const { visitorKeys } = context.sourceCode;
-
-    const nameOf = (element) => {
-      const { name } = element.openingElement;
-      if (name.type !== "JSXIdentifier" && name.type !== "JSXMemberExpression") return null;
-      if (name.type === "JSXIdentifier" && /^[a-z]/.test(name.name)) return name.name;
-      const imported = importOf(name);
-      if (!imported) return null;
-      return imported.name === "default" ? name.name : imported.name;
-    };
-
-    const isInteractive = (element, name) =>
-      CONTROLS.has(name) ||
-      NATIVE_CONTROLS.has(name) ||
-      hasAttribute(element.openingElement, "onClick") ||
-      hasAttribute(element.openingElement, "tabIndex");
-
-    function visitChildren(container, visit) {
-      for (const child of container.children) {
-        if (visit(child) === false) continue;
-        walk(child, visitorKeys, visit);
-      }
-    }
-
-    function checkTooltipContent(container) {
-      visitChildren(container, (child) => {
-        if (child.type !== "JSXElement") return true;
-        const name = nameOf(child);
-        if (!OVERLAYS.has(name) && !isInteractive(child, name)) return true;
-        context.report({ node: child.openingElement, messageId: "read-only-surface" });
-        return false;
-      });
-    }
-
-    function checkChoiceboxItem(container) {
-      visitChildren(container, (child) => {
-        if (child.type !== "JSXElement" || !isInteractive(child, nameOf(child))) return true;
-        context.report({ node: child.openingElement, messageId: "read-only-surface" });
-        return false;
-      });
-    }
-
-    function checkHoverCardContent(container) {
-      let links = 0;
-      visitChildren(container, (child) => {
-        if (child.type !== "JSXElement") return true;
-        const name = nameOf(child);
-        const { openingElement } = child;
-        if (OVERLAYS.has(name)) {
-          context.report({ node: openingElement, messageId: "read-only-surface" });
-          return false;
-        }
-        const isLink =
-          CONTROLS.has(name) ||
-          hasAttribute(openingElement, "onClick") ||
-          (name === HOVER_CARD_SUMMARY && hasAttribute(openingElement, "action"));
-        if (!isLink) return true;
-        links += 1;
-        if (links > 1) context.report({ node: openingElement, messageId: "read-only-surface" });
-        return true;
-      });
-    }
-
-    return {
-      JSXElement(node) {
-        const name = nameOf(node);
-        if (name === "TooltipContent") checkTooltipContent(node);
-        else if (name === "ChoiceboxGroupItem") checkChoiceboxItem(node);
-        else if (name === "HoverCardContent") checkHoverCardContent(node);
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-decorative-icon.js

@@ -1,164 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector such as
- * `CardTitle JSXOpeningElement` matches any element under a title, not the
- * ones bound to an icon module, and cannot stop at a control between the two
- * (`<CardHeader><Button><Plus/></Button></CardHeader>` is allowed). This rule
- * joins the element to its import and reads the nearest container above it.
- */
-import { renderedImports, sourceMatches, writtenName } from "./rendered-import.js";
-
-export const noDecorativeIcon = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A title or a label carries no icon; an icon belongs to a control or a menu row.",
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          iconModules: { type: "array", items: { type: "string" }, uniqueItems: true },
-          headings: { type: "array", items: { type: "string" }, uniqueItems: true },
-          controls: { type: "array", items: { type: "string" }, uniqueItems: true },
-        },
-        additionalProperties: false,
-      },
-    ],
-    defaultOptions: [
-      {
-        iconModules: ["lucide-react", "@nadicodeai/ui/components/house-icons"],
-        headings: [
-          "h1",
-          "h2",
-          "h3",
-          "h4",
-          "h5",
-          "h6",
-          "legend",
-          "dt",
-          "th",
-          "caption",
-          "CardTitle",
-          "CardDescription",
-          "CardHeader",
-          "DialogTitle",
-          "SheetTitle",
-          "AlertDialogTitle",
-          "DrawerTitle",
-          "FieldLabel",
-          "FieldLegend",
-          "Label",
-          "ItemTitle",
-          "TableHead",
-        ],
-        controls: [
-          "button",
-          "a",
-          "Button",
-          "Link",
-          "CardAction",
-          "TabsTrigger",
-          "TabsLink",
-          "ToggleGroupItem",
-          "Toggle",
-          "SidebarMenuButton",
-          "InputGroupAddon",
-          "InputGroupButton",
-        ],
-      },
-    ],
-    messages: {
-      "beside-heading":
-        "A title or a label carries no icon: an identity mark starts a row or a card (IdentityMark), and an icon belongs to a control or a menu row.",
-    },
-  },
-  create(context) {
-    const [{ iconModules, headings, controls }] = context.options;
-    const headingNames = new Set(headings);
-    const controlNames = new Set(controls);
-    const importOf = renderedImports(context);
-    const isIconImport = (name) => {
-      const imported = importOf({ type: "JSXIdentifier", name });
-      return (
-        imported !== null &&
-        iconModules.some((module) => sourceMatches(imported.source, module, context.filename))
-      );
-    };
-
-    function constantOf(name, scope) {
-      for (let current = scope; current; current = current.upper) {
-        const variable = current.set.get(name);
-        if (!variable) continue;
-        const [definition] = variable.defs;
-        const declared =
-          definition?.type === "Variable" && definition.parent.kind === "const"
-            ? definition.node.init
-            : null;
-        return declared ?? null;
-      }
-      return null;
-    }
-
-    function holdsAnIcon(value, scope, seen = new Set()) {
-      if (!value || seen.has(value)) return false;
-      seen.add(value);
-      switch (value.type) {
-        case "Identifier":
-          return (
-            isIconImport(value.name) || holdsAnIcon(constantOf(value.name, scope), scope, seen)
-          );
-        case "MemberExpression":
-          return holdsAnIcon(value.object, scope, seen);
-        case "ConditionalExpression":
-          return [value.consequent, value.alternate].some((branch) =>
-            holdsAnIcon(branch, scope, seen),
-          );
-        case "LogicalExpression":
-          return [value.left, value.right].some((side) => holdsAnIcon(side, scope, seen));
-        case "ObjectExpression":
-          return value.properties.some(
-            (property) => property.type === "Property" && holdsAnIcon(property.value, scope, seen),
-          );
-        case "ArrayExpression":
-          return value.elements.some((element) => holdsAnIcon(element, scope, seen));
-        default:
-          return false;
-      }
-    }
-
-    function isIcon(openingElement) {
-      const imported = importOf(openingElement.name);
-      if (imported) {
-        return iconModules.some((module) =>
-          sourceMatches(imported.source, module, context.filename),
-        );
-      }
-      const { name } = openingElement;
-      if (name.type !== "JSXIdentifier" || !/^[A-Z]/.test(name.name)) return false;
-      const scope = context.sourceCode.getScope(openingElement);
-      return holdsAnIcon(constantOf(name.name, scope), scope);
-    }
-
-    return {
-      JSXOpeningElement(node) {
-        if (!isIcon(node)) return;
-        for (let current = node.parent.parent; current; current = current.parent) {
-          if (current.type === "JSXAttribute") {
-            if (headingNames.has(writtenName(current.parent.name))) {
-              context.report({ node, messageId: "beside-heading" });
-            }
-            return;
-          }
-          if (current.type !== "JSXElement") continue;
-          const name = writtenName(current.openingElement.name);
-          if (controlNames.has(name)) return;
-          if (headingNames.has(name)) {
-            context.report({ node, messageId: "beside-heading" });
-            return;
-          }
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-deprecated-zod-api.js

@@ -1,215 +0,0 @@
-/*
- * Legacy Zod 3 APIs, in two sets that are enforced from two different places.
- *
- * UNANNOTATED — the three the installed zod 4.6.5 leaves without a
- * `@deprecated` tag: `promise` carries only prose, `.strict()` and `.strip()`
- * carry only a "consider…" hint. No tag means no type-aware rule can fire on
- * them, so they are this rule's own policy and are reported in every
- * workspace.
- *
- * ANNOTATED — the rest, which Zod does tag `@deprecated`, `nativeEnum`
- * included. `@typescript-eslint/no-deprecated` reports those with the
- * library's own replacement text, but only where it is turned on, and it needs
- * type information. In this repository that is `@nadicodeai/ui` alone:
- * switching the Portal on measured 10.4s → 25.8s per lint run and surfaced 15
- * unrelated findings (React's `FormEvent`, vitest's `toThrowError`), so it
- * stays ui-only (#821). The Portal and the website are where this repository
- * writes most of its Zod, so the names stay listed here for them — a second
- * copy of an upstream annotation, kept deliberately because the alternative is
- * no coverage at all in two of three workspaces (#822).
- *
- * The split is a rule option: `upstreamAnnotated: "report"` (default) names
- * them, `"defer"` leaves them to the type-aware rule. `@nadicodeai/ui` selects
- * `"defer"` in the root config, so no tagged API is reported twice there.
- */
-const LEGACY_FACTORIES = new Map([["promise", "await the value before parsing it"]]);
-
-const UPSTREAM_ANNOTATED_FACTORIES = new Map([["nativeEnum", "z.enum()"]]);
-
-const LEGACY_METHODS = {
-  object: new Map([
-    ["strict", "z.strictObject()"],
-    ["strip", "z.object(), which strips unknown keys by default"],
-  ]),
-};
-
-const UPSTREAM_ANNOTATED_METHODS = {
-  number: new Map([
-    ["finite", "remove it; z.number() already rejects infinite values"],
-    ["safe", ".int()"],
-    ["step", ".multipleOf()"],
-  ]),
-  object: new Map([
-    ["merge", ".extend(other.shape)"],
-    ["passthrough", "z.looseObject()"],
-  ]),
-  string: new Map([
-    ...[
-      "base64",
-      "base64url",
-      "cidrv4",
-      "cidrv6",
-      "cuid",
-      "cuid2",
-      "e164",
-      "email",
-      "emoji",
-      "guid",
-      "ipv4",
-      "ipv6",
-      "jwt",
-      "ksuid",
-      "nanoid",
-      "ulid",
-      "url",
-      "uuid",
-      "uuidv4",
-      "uuidv6",
-      "uuidv7",
-      "xid",
-    ].map((name) => [name, `z.${name.startsWith("uuidv") ? "uuid" : name}()`]),
-    ...["date", "datetime", "duration", "time"].map((name) => [name, `z.iso.${name}()`]),
-  ]),
-};
-
-function defersAnnotated(context) {
-  return context.options?.[0]?.upstreamAnnotated === "defer";
-}
-
-/** The factory table a run consults: the unannotated always, the annotated unless deferred. */
-function legacyFactories(context) {
-  if (defersAnnotated(context)) return LEGACY_FACTORIES;
-  return new Map([...UPSTREAM_ANNOTATED_FACTORIES, ...LEGACY_FACTORIES]);
-}
-
-/** The method table a run consults: the unannotated always, the annotated unless deferred. */
-function legacyMethods(context) {
-  if (defersAnnotated(context)) return LEGACY_METHODS;
-  const merged = {};
-  for (const family of new Set([
-    ...Object.keys(LEGACY_METHODS),
-    ...Object.keys(UPSTREAM_ANNOTATED_METHODS),
-  ])) {
-    merged[family] = new Map([
-      ...(UPSTREAM_ANNOTATED_METHODS[family] ?? []),
-      ...(LEGACY_METHODS[family] ?? []),
-    ]);
-  }
-  return merged;
-}
-
-function memberName(node) {
-  if (!node.computed && node.property.type === "Identifier") {
-    return node.property.name;
-  }
-  if (node.computed && node.property.type === "Literal") {
-    // 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 typeof node.property.value === "string" ? node.property.value : undefined;
-  }
-  return undefined;
-}
-
-export const noDeprecatedZodApi = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow the Zod 3 APIs that Zod 4 replaced without marking them @deprecated",
-    },
-    schema: [
-      {
-        type: "object",
-        properties: { upstreamAnnotated: { enum: ["report", "defer"] } },
-        additionalProperties: false,
-      },
-    ],
-    messages: {
-      legacyFactory: "{{api}} is legacy in Zod 4; use {{replacement}}.",
-      legacyMethod: "{{api}} is legacy in Zod 4; use {{replacement}}.",
-    },
-  },
-
-  create(context) {
-    const sourceCode = context.sourceCode;
-    const factories = legacyFactories(context);
-    const methods = legacyMethods(context);
-    const zodBindings = new Set();
-
-    function isZodBinding(identifier) {
-      for (let scope = sourceCode.getScope(identifier); scope; scope = scope.upper) {
-        const variable = scope.set.get(identifier.name);
-        if (variable) {
-          return zodBindings.has(variable);
-        }
-      }
-      return false;
-    }
-
-    function rootFactory(call) {
-      if (call.type !== "CallExpression" || call.callee.type !== "MemberExpression") {
-        return undefined;
-      }
-      const factory = memberName(call.callee);
-      if (!factory) {
-        return undefined;
-      }
-      if (call.callee.object.type === "Identifier" && isZodBinding(call.callee.object)) {
-        return factory;
-      }
-      return rootFactory(call.callee.object);
-    }
-
-    return {
-      ImportDeclaration(node) {
-        if (node.source.value !== "zod") {
-          return;
-        }
-        for (const specifier of node.specifiers) {
-          const importsNamespace = specifier.type === "ImportNamespaceSpecifier";
-          const importsZ =
-            specifier.type === "ImportSpecifier" &&
-            ((specifier.imported.type === "Identifier" && specifier.imported.name === "z") ||
-              (specifier.imported.type === "Literal" && specifier.imported.value === "z"));
-          if (!importsNamespace && !importsZ) {
-            continue;
-          }
-          for (const variable of sourceCode.getDeclaredVariables(specifier)) {
-            zodBindings.add(variable);
-          }
-        }
-      },
-
-      CallExpression(node) {
-        if (node.callee.type !== "MemberExpression") {
-          return;
-        }
-        const method = memberName(node.callee);
-        if (!method) {
-          return;
-        }
-
-        if (node.callee.object.type === "Identifier" && isZodBinding(node.callee.object)) {
-          const replacement = factories.get(method);
-          if (replacement) {
-            context.report({
-              node: node.callee.property,
-              messageId: "legacyFactory",
-              data: { api: `z.${method}()`, replacement },
-            });
-          }
-          return;
-        }
-
-        const factory = rootFactory(node.callee.object);
-        const family = factory === "strictObject" || factory === "looseObject" ? "object" : factory;
-        const replacement = methods[family]?.get(method);
-        if (replacement) {
-          context.report({
-            node: node.callee.property,
-            messageId: "legacyMethod",
-            data: { api: `z.${factory}().${method}()`, replacement },
-          });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-global-patch.js

@@ -1,115 +0,0 @@
-/*
- * A product built on another system's runtime must not replace what that
- * runtime calls: assigning `history.pushState`, a property of `window`, or a
- * member of a built-in prototype changes the code the other system runs, behind
- * its back. Nadia's desktop once replaced `history.pushState` and
- * `replaceState` to rewrite Hermes's routes; the product declares its intent to
- * the owning system instead.
- *
- * Standard tool checked first: core `no-restricted-syntax` can match an
- * assignment to `history.pushState` by name, but the route lock wrote it as
- * `const { history } = target; history.pushState = guarded`, and a member
- * reached through a local alias (`const h = window.history`) carries no global
- * name a selector can see. This rule resolves a local constant to what it was
- * initialised from before matching.
- *
- * Which objects count as globals is configuration: the workspace names them
- * where the rule is turned on, and this file holds only the matching.
- */
-
-const PATCHERS = new Set([
-  "Object.assign",
-  "Object.defineProperty",
-  "Object.defineProperties",
-  "Reflect.set",
-  "Reflect.defineProperty",
-]);
-
-function variableOf(scope, name) {
-  for (let current = scope; current; current = current.upper) {
-    const found = current.set.get(name);
-    if (found) return found;
-  }
-  return null;
-}
-
-function aliasOf(context, identifier) {
-  const variable = variableOf(context.sourceCode.getScope(identifier), identifier.name);
-  const definition = variable?.defs.length === 1 ? variable.defs[0] : null;
-  if (definition?.type !== "Variable" || definition.parent?.kind !== "const") return null;
-  const { id, init } = definition.node;
-  return id.type === "Identifier" && init ? init : null;
-}
-
-function pathOf(context, node, seen = new Set()) {
-  if (node.type === "Identifier") {
-    if (seen.has(node.name)) return node.name;
-    const alias = aliasOf(context, node);
-    if (alias) return pathOf(context, alias, new Set([...seen, node.name])) ?? node.name;
-    return node.name;
-  }
-  if (node.type === "ChainExpression") return pathOf(context, node.expression, seen);
-  if (node.type === "MemberExpression" && !node.computed && node.property.type === "Identifier") {
-    const object = pathOf(context, node.object, seen);
-    return object === null ? null : `${object}.${node.property.name}`;
-  }
-  return null;
-}
-
-export const noGlobalPatch = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow replacing a member of a global object or a built-in prototype",
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          globals: { type: "string" },
-          reason: { type: "string" },
-        },
-        required: ["globals"],
-        additionalProperties: false,
-      },
-    ],
-    messages: {
-      patch:
-        "`{{target}}` is a global another system's code runs; replacing it changes that code behind its back. Declare the intent to its owner instead.{{reason}}",
-    },
-  },
-  create(context) {
-    const options = context.options?.[0];
-    if (!options) return {};
-    const globals = new RegExp(options.globals);
-    const reason = options.reason ? ` ${options.reason}` : "";
-
-    const isGlobal = (path) => {
-      const owner = path.split(".").at(-1);
-      return owner === "prototype" || globals.test(owner);
-    };
-
-    const check = (node, target) => {
-      if (target.type !== "MemberExpression") return;
-      const owner = pathOf(context, target.object);
-      if (owner === null || !isGlobal(owner)) return;
-      const member = target.computed ? "[…]" : `.${target.property.name}`;
-      context.report({ node, messageId: "patch", data: { reason, target: `${owner}${member}` } });
-    };
-
-    return {
-      AssignmentExpression(node) {
-        check(node, node.left);
-      },
-      CallExpression(node) {
-        const callee = pathOf(context, node.callee);
-        const [target] = node.arguments;
-        if (!callee || !PATCHERS.has(callee) || !target) return;
-        const owner = pathOf(context, target);
-        if (owner !== null && isGlobal(owner)) {
-          context.report({ node, messageId: "patch", data: { reason, target: owner } });
-        }
-      },
-    };
-  },
-};