@nadicodeai/ui 12.1.165 → 12.1.167

package/dist/eslint/rules/no-tooltip-around-labelled-field.js

@@ -1,72 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector can match a
- * `Field` descendant of a `Tooltip` by element name, but not that both are
- * imports from the design system, nor reach a field named in the `render`
- * element of a trigger, so it would also refuse a product's own `Input`.
- */
-import { renderedImports, walk } from "./rendered-import.js";
-
-const WRAPPERS = new Set(["Tooltip", "TooltipTrigger", "HoverCard", "HoverCardTrigger"]);
-const POPUPS = new Set(["TooltipContent", "HoverCardContent"]);
-const FIELDS = new Set([
-  "Input",
-  "Textarea",
-  "ClearableInput",
-  "CollectionSearch",
-  "Select",
-  "SelectTrigger",
-  "NativeSelect",
-  "Combobox",
-  "ComboboxInput",
-  "Checkbox",
-  "Switch",
-  "Label",
-  "FieldLabel",
-  "SettingsField",
-]);
-
-const FROM_DESIGN_SYSTEM = /^(@nadicodeai\/ui(\/|$)|@\/|\.)/;
-
-export const noTooltipAroundLabelledField = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A Tooltip or HoverCard never wraps a field: put the help on an icon button beside it.",
-    },
-    schema: [],
-    messages: {
-      "field-tooltip":
-        "Do not put a Tooltip or HoverCard on a field: its text becomes a second, hidden label. Put the help on an icon button beside the field.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const exportOf = (elementName) => {
-      const imported = importOf(elementName);
-      return imported && FROM_DESIGN_SYSTEM.test(imported.source) ? imported.name : null;
-    };
-
-    function wrapsAField(element) {
-      let found = false;
-      walk(element, context.sourceCode.visitorKeys, (child) => {
-        if (child.type !== "JSXElement") return true;
-        const name = exportOf(child.openingElement.name);
-        if (POPUPS.has(name)) return false;
-        if (!FIELDS.has(name)) return true;
-        found = true;
-        return "stop";
-      });
-      return found;
-    }
-
-    return {
-      JSXElement(node) {
-        if (!WRAPPERS.has(exportOf(node.openingElement.name))) return;
-        if (wrapsAField(node)) {
-          context.report({ node: node.openingElement, messageId: "field-tooltip" });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-weight-class-on-strong-in-type-role.js

@@ -1,57 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector can match a
- * `strong` whose own className holds a weight class, but cannot ask whether some
- * element above it carries a type role, so it would refuse every weighted
- * `<strong>` or none. This rule reads both classNames, ancestors included, in
- * one file.
- */
-import { openingElementClassUtilities } from "./jsx-class-utility.js";
-
-const STRONG_TAGS = new Set(["strong", "b"]);
-const WEIGHT_CLASS = /^font-(medium|semibold|bold)$/;
-const TYPE_ROLE_CLASS = /^(nc-type-|text-(display-|heading-|body-|label|caption))/;
-
-const baseUtility = (utility) => utility.slice(utility.lastIndexOf(":") + 1).replace(/^!/, "");
-
-const hasUtility = (element, context, pattern) =>
-  openingElementClassUtilities(element, context).some((utility) =>
-    pattern.test(baseUtility(utility)),
-  );
-
-function hasTypeRoleAncestor(element, context) {
-  for (let ancestor = element.parent?.parent; ancestor; ancestor = ancestor.parent) {
-    if (
-      ancestor.type === "JSXElement" &&
-      hasUtility(ancestor.openingElement, context, TYPE_ROLE_CLASS)
-    ) {
-      return true;
-    }
-  }
-  return false;
-}
-
-export const noWeightClassOnStrongInTypeRole = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A type role sets the weight of a nested <strong>; the element carries no weight class.",
-    },
-    schema: [],
-    messages: {
-      "weight-on-strong":
-        "The type role sets the weight of a nested <strong>: 550 in copy, 500 in labels and headings. Remove the font-weight class from the <strong>.",
-    },
-  },
-  create(context) {
-    return {
-      JSXOpeningElement(node) {
-        if (node.name.type !== "JSXIdentifier" || !STRONG_TAGS.has(node.name.name)) return;
-        if (!hasUtility(node, context, WEIGHT_CLASS)) return;
-        if (hasTypeRoleAncestor(node, context)) {
-          context.report({ node, messageId: "weight-on-strong" });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-write-in-subscription.js

@@ -1,140 +0,0 @@
-/*
- * A callback a store subscription or a watcher runs must not write: code that
- * listens to another system's state and writes that state, or state coupled to
- * it, back is a loop the other system can restart on every change. Nadia's
- * desktop once held Hermes's pane layout this way, and Hermes's own reaction to
- * each correction fed the next one until the window ran out of memory. The
- * product declares its intent once and the owning system applies it.
- *
- * Standard tool checked first: core `no-restricted-syntax` can match a write
- * nested in an inline callback, but the loop was written as `atom.listen(hold)`,
- * a named function declared elsewhere in the file, and a selector cannot follow
- * that reference. This rule resolves a passed identifier through scope analysis
- * to the function it names in the same file.
- *
- * What counts as a subscription and as a write is configuration: the workspace
- * names its subscription methods (an event listener's `addEventListener`
- * included) and its writers where the rule is turned on, and this file holds
- * only the matching. A writer is matched against the called name and against
- * its dotted path, so `location.replace` can be a writer while a string's
- * `replace` is not; an assignment inside the callback, such as
- * `location.hash = …`, is matched by the path it assigns.
- */
-
-const FUNCTIONS = new Set(["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"]);
-
-function pathOf(node) {
-  if (node.type === "Identifier") return node.name;
-  if (node.type === "ThisExpression") return "this";
-  if (node.type === "ChainExpression") return pathOf(node.expression);
-  if (node.type === "MemberExpression" && !node.computed && node.property.type === "Identifier") {
-    const object = pathOf(node.object);
-    return object === null ? null : `${object}.${node.property.name}`;
-  }
-  return null;
-}
-
-function calleeName(callee) {
-  if (callee.type === "Identifier") return callee.name;
-  if (
-    callee.type === "MemberExpression" &&
-    !callee.computed &&
-    callee.property.type === "Identifier"
-  ) {
-    return callee.property.name;
-  }
-  if (callee.type === "ChainExpression") return calleeName(callee.expression);
-  return null;
-}
-
-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 functionOf(context, node) {
-  if (FUNCTIONS.has(node.type)) return node;
-  if (node.type !== "Identifier") return null;
-  const variable = variableOf(context.sourceCode.getScope(node), node.name);
-  for (const definition of variable?.defs ?? []) {
-    if (definition.type === "FunctionName") return definition.node;
-    const init = definition.type === "Variable" ? definition.node.init : null;
-    if (init && FUNCTIONS.has(init.type)) return init;
-  }
-  return null;
-}
-
-function* writesIn(node, keys) {
-  if (node.type === "CallExpression") {
-    yield { node, names: [calleeName(node.callee), pathOf(node.callee)] };
-  }
-  if (node.type === "AssignmentExpression") {
-    yield { node, names: [pathOf(node.left)] };
-  }
-  for (const key of keys[node.type] ?? []) {
-    const child = node[key];
-    for (const each of Array.isArray(child) ? child : [child]) {
-      // oxlint-disable-next-line anti-slop/no-runtime-typeof -- walks the generic AST, where only an object whose type is a string is a node.
-      if (each && typeof each.type === "string") yield* writesIn(each, keys);
-    }
-  }
-}
-
-export const noWriteInSubscription = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow writes inside a callback passed to a store subscription or a watcher",
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          subscriptions: { type: "string" },
-          writers: { type: "string" },
-          reason: { type: "string" },
-        },
-        required: ["subscriptions", "writers"],
-        additionalProperties: false,
-      },
-    ],
-    messages: {
-      writeBack:
-        "`{{writer}}` writes from inside the callback `{{subscription}}` runs on every change of the state it watches. Declare the intent once and let the owner of that state apply it.{{reason}}",
-    },
-  },
-  create(context) {
-    const options = context.options?.[0];
-    if (!options) return {};
-    const subscriptions = new RegExp(options.subscriptions);
-    const writers = new RegExp(options.writers);
-    const reason = options.reason ? ` ${options.reason}` : "";
-    const keys = context.sourceCode.visitorKeys;
-    const reported = new Set();
-
-    return {
-      CallExpression(node) {
-        const subscription = calleeName(node.callee);
-        if (!subscription || !subscriptions.test(subscription)) return;
-        for (const argument of node.arguments) {
-          const callback = functionOf(context, argument);
-          if (!callback) continue;
-          for (const write of writesIn(callback.body, keys)) {
-            const writer = write.names.find((name) => name !== null && writers.test(name));
-            if (writer && !reported.has(write.node)) {
-              reported.add(write.node);
-              context.report({
-                node: write.node,
-                messageId: "writeBack",
-                data: { reason, subscription, writer },
-              });
-            }
-          }
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/one-submenu-level.js

@@ -1,43 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` descendant selector
- * matches by element name, so it cannot tell the package's
- * `DropdownMenuSub` from a local component of the same name or follow a
- * renamed import.
- */
-import { renderedImports } from "./rendered-import.js";
-
-const SUBMENUS = new Set(["DropdownMenuSub", "ContextMenuSub", "MenubarSub"]);
-const FROM_DESIGN_SYSTEM = /^(@nadicodeai\/ui(\/|$)|@\/|\.)/;
-
-export const oneSubmenuLevel = {
-  meta: {
-    type: "problem",
-    docs: { description: "A menu has one level of submenu, never a submenu inside a submenu." },
-    schema: [],
-    messages: {
-      "nested-submenu":
-        "A menu opens one submenu deep. A third level hides commands behind a pointer path that is easy to lose: flatten the inner submenu into a group of the first, or move it to its own menu.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const isSubmenu = (element) => {
-      const imported = importOf(element.openingElement.name);
-      return (
-        imported !== null && SUBMENUS.has(imported.name) && FROM_DESIGN_SYSTEM.test(imported.source)
-      );
-    };
-
-    return {
-      JSXElement(node) {
-        if (!isSubmenu(node)) return;
-        for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
-          if (ancestor.type === "JSXElement" && isSubmenu(ancestor)) {
-            context.report({ node: node.openingElement, messageId: "nested-submenu" });
-            return;
-          }
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/one-toast-per-flow.js

@@ -1,91 +0,0 @@
-/*
- * Standard tool checked first: `no-restricted-syntax` selectors match one node
- * and its ancestors, but whether two calls can both run is a question about
- * how their paths split (if/else, ?:, try/catch, switch cases, an early
- * return), which no selector can ask.
- */
-const TOAST_CALLS = new Set(["notify", "notifyError", "showMessageToast"]);
-const EXITS = new Set(["ReturnStatement", "ThrowStatement"]);
-const STATEMENT_LISTS = new Set(["BlockStatement", "SwitchCase", "Program", "StaticBlock"]);
-
-const calleeName = (callee) => {
-  if (callee.type === "Identifier") return callee.name;
-  if (callee.type === "MemberExpression" && !callee.computed) return callee.property.name;
-  return null;
-};
-
-const isToastCall = (node) => TOAST_CALLS.has(calleeName(node.callee));
-
-const chainOf = (node) => {
-  const chain = [];
-  for (let current = node; current; current = current.parent) chain.push(current);
-  return chain;
-};
-
-const branchesOf = (split) => {
-  if (split.type === "IfStatement") return [split.consequent, split.alternate];
-  if (split.type === "ConditionalExpression") return [split.consequent, split.alternate];
-  if (split.type === "TryStatement") return [split.block, split.handler];
-  if (split.type === "SwitchStatement") return split.cases;
-  return [];
-};
-
-const onDifferentBranches = (split, first, second) => {
-  const branches = branchesOf(split);
-  return branches.includes(first) && branches.includes(second) && first !== second;
-};
-
-const leavesBefore = (below, split) =>
-  below.some((node) => {
-    if (EXITS.has(node.type)) return true;
-    const list = node.parent;
-    if (!STATEMENT_LISTS.has(list.type) || list === split) return false;
-    const siblings = list.type === "SwitchCase" ? list.consequent : list.body;
-    return siblings.slice(siblings.indexOf(node) + 1).some((next) => EXITS.has(next.type));
-  });
-
-function runsAfter(earlier, later) {
-  const laterChain = chainOf(later);
-  const earlierChain = chainOf(earlier);
-  const meeting = earlierChain.findIndex((node) => laterChain.includes(node));
-  const split = earlierChain[meeting];
-  const earlierBelow = earlierChain.slice(0, meeting);
-  const laterSide = laterChain[laterChain.indexOf(split) - 1];
-  if (onDifferentBranches(split, earlierBelow.at(-1), laterSide)) return false;
-  return !leavesBefore(earlierBelow, split);
-}
-
-export const oneToastPerFlow = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A flow raises one toast when it ends, never one per step: a success and a failure on separate paths are fine.",
-    },
-    schema: [],
-    messages: {
-      "toast-per-step": "Raise one toast when the flow ends, not one per step.",
-    },
-  },
-  create(context) {
-    const scopes = [[]];
-
-    function closeScope() {
-      const calls = scopes.pop();
-      calls.forEach((call, index) => {
-        if (calls.slice(0, index).some((earlier) => runsAfter(earlier, call))) {
-          context.report({ node: call, messageId: "toast-per-step" });
-        }
-      });
-    }
-
-    return {
-      ":function": () => scopes.push([]),
-      ":function:exit": closeScope,
-      "Program:exit": closeScope,
-      CallExpression(node) {
-        if (isToastCall(node)) scopes.at(-1).push(node);
-      },
-    };
-  },
-};

package/dist/eslint/rules/option-count.js

@@ -1,167 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector can count the
- * children of one element, but not follow a renamed import to the part, count
- * the items below wrappers, or tell a literal list from one that a `map`,
- * a spread or a condition makes.
- */
-import { findBelow, renderedImports, walk } from "./rendered-import.js";
-
-const GROUPS = new Map([
-  ["RadioGroup", { item: "RadioGroupItem", min: 2, max: 6 }],
-  ["ChoiceboxGroup", { item: "ChoiceboxGroupItem", max: 6 }],
-  ["MultiSelect", { item: "MultiSelectRow", min: 2 }],
-  ["MultiSelectContent", { item: "MultiSelectRow", min: 2 }],
-]);
-const COMMAND_PROPS = new Map([
-  ["ActionMenu", "commands"],
-  ["ActionContextMenu", "commands"],
-  ["PageActions", "menu"],
-  ["PageActionsRow", "menu"],
-]);
-const MENU_TYPES = new Set(["RecordMenu", "PageMenu"]);
-const MAX_COMMANDS = 10;
-const LIST_CALLBACKS = new Set(["map", "flatMap"]);
-
-const isChildPosition = (node) =>
-  node.parent.type === "JSXElement" || node.parent.type === "JSXFragment";
-
-const withoutTypeAssertion = (node) =>
-  node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" ? node.expression : node;
-
-const keyName = (property) =>
-  property.key.type === "Identifier" ? property.key.name : property.key.value;
-
-function literalCommands(menu) {
-  const object = withoutTypeAssertion(menu);
-  if (object.type !== "ObjectExpression") return null;
-  const property = object.properties.find(
-    (candidate) =>
-      candidate.type === "Property" && !candidate.computed && keyName(candidate) === "commands",
-  );
-  return property ? literalArray(property.value) : null;
-}
-
-function literalArray(value) {
-  const array = withoutTypeAssertion(value);
-  if (array.type !== "ArrayExpression") return null;
-  return array.elements.every((element) => element && element.type !== "SpreadElement")
-    ? array
-    : null;
-}
-
-export const optionCount = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A RadioGroup holds 2 to 6 options, a Choicebox at most 6 tiles, a MultiSelect at least 2 rows, a menu about 10 commands.",
-    },
-    schema: [],
-    messages: {
-      "option-count":
-        "Keep the choice readable: a RadioGroup holds 2 to 6 options (7 or more is a Select or Combobox), a Choicebox at most 6 tiles, a MultiSelect at least 2 rows (one is a Checkbox or Switch), a menu about 10 commands (group the rest by job into a second menu or a page).",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const { visitorKeys } = context.sourceCode;
-
-    const importedName = (element) => importOf(element.openingElement.name)?.name ?? null;
-
-    const hidesItems = (container) =>
-      findBelow(
-        container,
-        visitorKeys,
-        (node) =>
-          node.type === "JSXElement" ||
-          node.type === "JSXFragment" ||
-          (node.type === "CallExpression" &&
-            node.callee.type === "MemberExpression" &&
-            LIST_CALLBACKS.has(node.callee.property.name)),
-      ) !== null;
-
-    function countLiteralItems(group, itemName) {
-      let count = 0;
-      let literal = true;
-      const tally = (node) => {
-        if (node.type === "JSXElement" && importedName(node) === itemName) count += 1;
-        if (
-          (node.type === "JSXExpressionContainer" || node.type === "JSXSpreadChild") &&
-          isChildPosition(node) &&
-          hidesItems(node)
-        ) {
-          literal = false;
-          return "stop";
-        }
-        return true;
-      };
-      for (const child of group.children) {
-        if (child.type === "JSXText" && child.value.trim() === "") continue;
-        if (child.type !== "JSXElement") return null;
-        tally(child);
-        if (walk(child, visitorKeys, tally) === "stop" || !literal) return null;
-      }
-      return count;
-    }
-
-    const ownsContent = (element) =>
-      findBelow(
-        element,
-        visitorKeys,
-        (node) => node.type === "JSXElement" && importedName(node) === "MultiSelectContent",
-      ) !== null;
-
-    function checkGroup(element, name) {
-      const { item, min = 0, max = Infinity } = GROUPS.get(name);
-      if (name === "MultiSelect" && ownsContent(element)) return;
-      const count = countLiteralItems(element, item);
-      if (!count) return;
-      if (count < min || count > max) {
-        context.report({ node: element.openingElement, messageId: "option-count" });
-      }
-    }
-
-    function checkCommands(array) {
-      if (array && array.elements.length > MAX_COMMANDS) {
-        context.report({ node: array, messageId: "option-count" });
-      }
-    }
-
-    function checkMenuAttribute(openingElement, name) {
-      const prop = COMMAND_PROPS.get(name);
-      const attribute = openingElement.attributes.find(
-        (candidate) => candidate.type === "JSXAttribute" && candidate.name.name === prop,
-      );
-      if (attribute?.value?.type !== "JSXExpressionContainer") return;
-      const { expression } = attribute.value;
-      checkCommands(prop === "commands" ? literalArray(expression) : literalCommands(expression));
-    }
-
-    const isMenuType = (annotation) =>
-      annotation?.type === "TSTypeReference" &&
-      annotation.typeName.type === "Identifier" &&
-      MENU_TYPES.has(annotation.typeName.name);
-
-    return {
-      JSXElement(node) {
-        const name = importedName(node);
-        if (GROUPS.has(name)) checkGroup(node, name);
-      },
-      JSXOpeningElement(node) {
-        const name = importOf(node.name)?.name;
-        if (COMMAND_PROPS.has(name)) checkMenuAttribute(node, name);
-      },
-      VariableDeclarator(node) {
-        if (
-          node.init?.type === "ObjectExpression" &&
-          isMenuType(node.id.typeAnnotation?.typeAnnotation)
-        ) {
-          checkCommands(literalCommands(node.init));
-        }
-      },
-      "TSAsExpression, TSSatisfiesExpression"(node) {
-        if (isMenuType(node.typeAnnotation)) checkCommands(literalCommands(node.expression));
-      },
-    };
-  },
-};

package/dist/eslint/rules/page-command-link-not-render.js

@@ -1,43 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector can match a
- * `render` property holding a `<Link>`, but not that the same object literal
- * also has a `label`, which is what tells a command (PageCommand, MenuCommand)
- * from any other object with a `render` field.
- */
-import { writtenName } from "./rendered-import.js";
-
-const ADDRESS_ELEMENTS = new Set(["a", "Link", "NextLink"]);
-
-const keyName = (property) => {
-  if (property.type !== "Property" || property.computed) return null;
-  return property.key.type === "Identifier" ? property.key.name : property.key.value;
-};
-
-const goesToAnAddress = (value) =>
-  value.type === "JSXElement" && ADDRESS_ELEMENTS.has(writtenName(value.openingElement.name));
-
-export const pageCommandLinkNotRender = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "A command that goes to an address passes it as `link`, not as `render`.",
-    },
-    schema: [],
-    messages: {
-      "link-in-render":
-        'A command that goes to an address passes it as `link: <Link href="..." />`; `render` is only for an element that is itself a command, such as a component that renders a Button.',
-    },
-  },
-  create(context) {
-    return {
-      ObjectExpression(node) {
-        if (!node.properties.some((property) => keyName(property) === "label")) return;
-        for (const property of node.properties) {
-          if (keyName(property) === "render" && goesToAnAddress(property.value)) {
-            context.report({ node: property.value, messageId: "link-in-render" });
-          }
-        }
-      },
-    };
-  },
-};