@nadicodeai/ui 12.1.165 → 12.1.166

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

package/dist/eslint/rules/no-hand-built-busy.js

@@ -1,104 +0,0 @@
-/*
- * Standard tool checked first: `no-restricted-imports` refuses an import by
- * module, but not the same export by module and file area (PendingLabel is
- * allowed inside packages/ui), and `no-restricted-syntax` cannot join a
- * PendingLabel element to the Button it sits under through a renamed import.
- */
-import { openingElementClassUtilities } from "./jsx-class-utility.js";
-import { PACKAGE_BARREL, renderedImports } from "./rendered-import.js";
-
-const PENDING_LABEL = "PendingLabel";
-const PENDING_LABEL_MODULES = new Set([
-  PACKAGE_BARREL,
-  `${PACKAGE_BARREL}/components/pending-label`,
-]);
-const BUTTONS = new Set(["Button", "ButtonLink"]);
-const SPINNER_ICONS = new Set([
-  "Loader",
-  "LoaderIcon",
-  "Loader2",
-  "Loader2Icon",
-  "LoaderCircle",
-  "LoaderCircleIcon",
-  "LoaderPinwheel",
-]);
-const ICON_MODULE = "lucide-react";
-const SPIN = "animate-spin";
-const FUNCTIONS = new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
-
-const PACKAGE_PATH = "/packages/ui/";
-const PORTAL_PATH = "/apps/portal/";
-
-const PENDING_LABEL_ONLY = new Set([PENDING_LABEL]);
-
-const SOURCE_SIDE = { ImportSpecifier: "imported", ExportSpecifier: "local" };
-
-const sourceName = (specifier) => {
-  const named = specifier[SOURCE_SIDE[specifier.type]];
-  return named?.name ?? named?.value;
-};
-
-const isSpinToken = (utility) => utility.split(":").pop().replace(/^!/, "") === SPIN;
-
-function insideAButton(element, importOf) {
-  for (let current = element.parent; current; current = current.parent) {
-    if (FUNCTIONS.has(current.type)) return false;
-    if (current.type === "JSXElement" && BUTTONS.has(importOf(current.openingElement.name)?.name)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-export const noHandBuiltBusy = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A working button takes loading and loadingLabel; no product hand-builds a busy label or a spinner.",
-    },
-    schema: [],
-    messages: {
-      "hand-built-busy":
-        "A working button takes loading and loadingLabel: it keeps its place and focus, says its loadingLabel and shows no spinner. A wait past a second is WaitingLine.",
-    },
-  },
-  create(context) {
-    const filename = context.filename.replaceAll("\\", "/");
-    const inPackage = filename.includes(PACKAGE_PATH);
-    const inPortal = filename.includes(PORTAL_PATH);
-    const importOf = renderedImports(context);
-
-    const report = (node) => context.report({ node, messageId: "hand-built-busy" });
-
-    function bannedFrom(source) {
-      if (source === ICON_MODULE) return SPINNER_ICONS;
-      if (!inPackage && PENDING_LABEL_MODULES.has(source)) return PENDING_LABEL_ONLY;
-      return null;
-    }
-
-    function checkImport(node) {
-      if (node.importKind === "type" || node.exportKind === "type") return;
-      const source = node.source?.value;
-      const bannedNames = bannedFrom(source);
-      if (!bannedNames) return;
-      for (const specifier of node.specifiers) {
-        if (specifier.importKind === "type" || specifier.exportKind === "type") continue;
-        if (bannedNames.has(sourceName(specifier))) report(specifier);
-      }
-    }
-
-    return {
-      ImportDeclaration: checkImport,
-      ExportNamedDeclaration: checkImport,
-      JSXElement(node) {
-        if (importOf(node.openingElement.name)?.name !== PENDING_LABEL) return;
-        if (insideAButton(node, importOf)) report(node.openingElement);
-      },
-      JSXOpeningElement(node) {
-        if (inPortal) return;
-        if (openingElementClassUtilities(node, context).some(isSpinToken)) report(node);
-      },
-    };
-  },
-};