@nadicodeai/ui 12.1.165 → 12.1.166

package/dist/eslint/rules/page-composition.js

@@ -1,232 +0,0 @@
-/*
- * Standard tool checked first: `no-restricted-imports` bans a module or a
- * name, but a part may be imported for a type or by its owner, and what is
- * wrong is rendering it; `no-restricted-syntax` matches an element by the name
- * the file wrote, which an import alias (`PageHeader as Header`) slips past.
- * This rule joins the import binding to the element that renders it.
- */
-import {
-  findBelow,
-  isRenderedChild,
-  packageModules,
-  partOf,
-  renderedImports,
-  staticAttribute,
-  walk,
-} from "./rendered-import.js";
-
-const PART_FIX = {
-  PageHeader: "PageHeader belongs to the product's chrome or a composition's `title`.",
-  ReadingColumn: "A page's column is its composition's: SettingsPage, or the product's page frame.",
-  TableCard:
-    "A list of records is CollectionPage or RecordList; a comparison is a DataTable, which brings its card.",
-  CollectionToolbar: "The toolbar is CollectionPage's: `search`, `filters`, `sort`.",
-  CollectionSort: "The toolbar is CollectionPage's: `search`, `filters`, `sort`.",
-};
-
-const PACKAGE_MODULE = {
-  PageHeader: "page-header",
-  ReadingColumn: "reading-column",
-  TableCard: "table-card",
-  CollectionToolbar: "collection-toolbar",
-  CollectionSort: "collection-sort",
-  DataTable: "data-table",
-  FormDrawer: "form-drawer",
-  SettingsSection: "settings-section",
-  TabsTrigger: "tabs",
-  TabsLink: "tabs",
-  Badge: "badge",
-  StatusBadge: "status-badge",
-  Tag: "tag",
-};
-
-const TABS = new Set(["TabsTrigger", "TabsLink"]);
-const COUNT_MARKS = new Set(["Badge", "StatusBadge", "Tag"]);
-const countName = (name) =>
-  /(?:^|_)(?:count|total|length|size|unread|number)$/i.test(name) ||
-  /[a-z0-9](?:Count|Total|Length|Size|Unread)$/.test(name);
-
-function exportersOf(modules) {
-  const parts = new Map();
-  const add = (name, from, part) => parts.set(name, [...(parts.get(name) ?? []), { from, part }]);
-  for (const [part, module] of Object.entries(PACKAGE_MODULE)) {
-    for (const from of packageModules(module)) add(part, from, part);
-    for (const adapter of modules[part] ?? []) {
-      // oxlint-disable-next-line anti-slop/no-runtime-typeof -- a composition's adapter list holds a module path or a { name, from } pair; only typeof tells them apart.
-      if (typeof adapter === "string") add(part, adapter, part);
-      else add(adapter.name, adapter.from, part);
-    }
-  }
-  return parts;
-}
-
-const isObjectKey = (node) =>
-  node.parent.type === "Property" && node.parent.key === node && !node.parent.computed;
-
-function readsACount(expression, visitorKeys) {
-  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- ESTree types Literal.value as string | number | boolean | RegExp | bigint | null; only typeof picks the number.
-  if (expression.type === "Literal" && typeof expression.value === "number") return true;
-  if (expression.type === "Identifier" && countName(expression.name)) return true;
-  let found = false;
-  walk(expression, visitorKeys, (node) => {
-    if (node.type === "JSXElement" || node.type === "JSXFragment") return false;
-    if (node.type === "Identifier" && countName(node.name) && !isObjectKey(node)) {
-      found = true;
-      return "stop";
-    }
-    return true;
-  });
-  return found;
-}
-
-export const pageComposition = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "A product page renders a composition, never the parts a composition owns.",
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          allow: {
-            type: "array",
-            items: { enum: Object.keys(PART_FIX) },
-            uniqueItems: true,
-          },
-          modules: {
-            type: "object",
-            propertyNames: { enum: Object.keys(PACKAGE_MODULE) },
-            additionalProperties: {
-              type: "array",
-              items: {
-                oneOf: [
-                  { type: "string" },
-                  {
-                    type: "object",
-                    properties: { from: { type: "string" }, name: { type: "string" } },
-                    required: ["from", "name"],
-                    additionalProperties: false,
-                  },
-                ],
-              },
-            },
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    defaultOptions: [{ allow: [], modules: {} }],
-    messages: {
-      part: "{{fix}}",
-      "entity-table": "Rows that name themselves are CollectionPage or RecordList.",
-      "catalog-drawer": "A catalogue is CatalogDrawer.",
-      "settings-form": "A settings section saves through its `save`; no form around or inside it.",
-      "step-marker":
-        "A sequence of steps is NumberedSteps, which owns the marker, the current step and the step's action.",
-      "tab-count": "A tab names its view; the count belongs to the list's footer.",
-    },
-  },
-  create(context) {
-    const [{ allow, modules }] = context.options;
-    const allowed = new Set(allow);
-    const parts = exportersOf(modules);
-    const importOf = renderedImports(context);
-    const { visitorKeys } = context.sourceCode;
-    const partRendered = (openingElement) =>
-      partOf(importOf(openingElement.name), parts, context.filename);
-    const isForm = (node) =>
-      node.type === "JSXOpeningElement" &&
-      node.name.type === "JSXIdentifier" &&
-      node.name.name === "form";
-
-    function checkSettingsSection(element) {
-      const opening = element.openingElement;
-      if (findBelow(element, visitorKeys, isForm)) {
-        context.report({ node: opening, messageId: "settings-form" });
-        return;
-      }
-      const footer = opening.attributes.find(
-        (attribute) => attribute.type === "JSXAttribute" && attribute.name.name === "footer",
-      );
-      const submits =
-        footer?.value &&
-        findBelow(
-          footer.value,
-          visitorKeys,
-          (node) => node.type === "JSXOpeningElement" && staticAttribute(node, "type") === "submit",
-        );
-      if (submits) context.report({ node: opening, messageId: "settings-form" });
-    }
-
-    const showsACount = (node) =>
-      (node.type === "JSXOpeningElement" && COUNT_MARKS.has(partRendered(node))) ||
-      (node.type === "JSXExpressionContainer" &&
-        isRenderedChild(node) &&
-        readsACount(node.expression, visitorKeys));
-
-    function checkTab(element) {
-      for (const child of element.children) {
-        const offence = showsACount(child) ? child : findBelow(child, visitorKeys, showsACount);
-        if (offence) {
-          context.report({ node: offence, messageId: "tab-count" });
-          return;
-        }
-      }
-    }
-
-    return {
-      JSXElement(element) {
-        const opening = element.openingElement;
-        if (isForm(opening)) {
-          const section = findBelow(
-            element,
-            visitorKeys,
-            (node) => node.type === "JSXOpeningElement" && partRendered(node) === "SettingsSection",
-          );
-          if (section) context.report({ node: opening, messageId: "settings-form" });
-          return;
-        }
-        const part = partRendered(opening);
-        if (!part) return;
-        if (Object.hasOwn(PART_FIX, part)) {
-          if (!allowed.has(part)) {
-            context.report({ node: opening, messageId: "part", data: { fix: PART_FIX[part] } });
-          }
-        } else if (part === "DataTable") {
-          if (staticAttribute(opening, "showColumnHeaders") === false) {
-            context.report({ node: opening, messageId: "entity-table" });
-          }
-        } else if (part === "FormDrawer") {
-          if (staticAttribute(opening, "job") === "catalog") {
-            context.report({ node: opening, messageId: "catalog-drawer" });
-          }
-        } else if (part === "SettingsSection") {
-          checkSettingsSection(element);
-        } else if (TABS.has(part)) {
-          checkTab(element);
-        }
-      },
-      JSXExpressionContainer(container) {
-        if (!isRenderedChild(container)) return;
-        const { expression } = container;
-        const addsOne =
-          expression.type === "BinaryExpression" &&
-          expression.operator === "+" &&
-          expression.right.type === "Literal" &&
-          expression.right.value === 1;
-        if (!addsOne) return;
-        for (let current = container.parent; current; current = current.parent) {
-          if (
-            current.type === "JSXElement" &&
-            current.openingElement.name.type === "JSXIdentifier" &&
-            current.openingElement.name.name === "li"
-          ) {
-            context.report({ node: container, messageId: "step-marker" });
-            return;
-          }
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/progress-needs-name.js

@@ -1,57 +0,0 @@
-/*
- * Standard tool checked first: `jsx-a11y` has no rule for a progressbar's name,
- * and a `no-restricted-syntax` selector cannot tell that the package's Progress
- * is meant rather than a local one, nor look for a ProgressLabel anywhere in
- * its children. Those need the import bindings and the element's subtree read
- * together.
- */
-import { findBelow, packageModules, partOf, renderedImports } from "./rendered-import.js";
-
-const partsIn = (module, names) =>
-  names.map((name) => [
-    name,
-    [...packageModules(module), `@/components/${module}`].map((from) => ({ from, part: name })),
-  ]);
-
-const PROGRESS = new Map(partsIn("progress", ["Progress"]));
-const PROGRESS_LABEL = new Map(partsIn("progress", ["ProgressLabel"]));
-
-const NAMING_ATTRIBUTES = new Set(["aria-label", "aria-labelledby"]);
-
-export const progressNeedsName = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A Progress is named by an aria-label, an aria-labelledby or a ProgressLabel among its children.",
-    },
-    schema: [],
-    messages: {
-      unnamed:
-        "Name the work: add <ProgressLabel> (Uploading files) or aria-label, and print the count in ProgressValue.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const isPart = (parts, openingElement) =>
-      Boolean(partOf(importOf(openingElement.name), parts, context.filename));
-
-    return {
-      JSXElement(node) {
-        const { openingElement } = node;
-        if (!isPart(PROGRESS, openingElement)) return;
-        const namedByAttribute = openingElement.attributes.some(
-          (attribute) =>
-            attribute.type === "JSXSpreadAttribute" || NAMING_ATTRIBUTES.has(attribute.name.name),
-        );
-        if (namedByAttribute) return;
-        const label = findBelow(
-          node,
-          context.sourceCode.visitorKeys,
-          (child) => child.type === "JSXElement" && isPart(PROGRESS_LABEL, child.openingElement),
-        );
-        if (!label) context.report({ node: openingElement, messageId: "unnamed" });
-      },
-    };
-  },
-};

package/dist/eslint/rules/rendered-import.js

@@ -1,121 +0,0 @@
-import { dirname, resolve, sep } from "node:path";
-
-export const PACKAGE_BARREL = "@nadicodeai/ui";
-
-export const packageModules = (module) => [`@nadicodeai/ui/components/${module}`, PACKAGE_BARREL];
-
-const withoutExtension = (path) => path.replace(/\.[cm]?[jt]sx?$/, "").replace(/\/index$/, "");
-
-export function sourceMatches(source, specifier, filename) {
-  if (source === specifier) return true;
-  if (!specifier.startsWith("@/") || !source.startsWith(".")) return false;
-  const target = withoutExtension(resolve(dirname(filename), source).split(sep).join("/"));
-  return target.endsWith(`/src/${withoutExtension(specifier.slice(2))}`);
-}
-
-/**
- * Reads the file's value imports once and returns, for a JSX element's name,
- * the `{ source, name }` of the export it renders, or null. A namespace import
- * renders `<ns.Part>` as the export `Part`.
- */
-export function renderedImports(context) {
-  const named = new Map();
-  const namespaces = new Map();
-  for (const statement of context.sourceCode.ast.body) {
-    if (statement.type !== "ImportDeclaration" || statement.importKind === "type") continue;
-    const source = statement.source.value;
-    for (const specifier of statement.specifiers) {
-      if (specifier.importKind === "type") continue;
-      if (specifier.type === "ImportSpecifier") {
-        const name = specifier.imported.name ?? specifier.imported.value;
-        named.set(specifier.local.name, { source, name });
-      } else if (specifier.type === "ImportNamespaceSpecifier") {
-        namespaces.set(specifier.local.name, source);
-      } else {
-        named.set(specifier.local.name, { source, name: "default" });
-      }
-    }
-  }
-  return (elementName) => {
-    if (elementName.type === "JSXIdentifier") return named.get(elementName.name) ?? null;
-    if (
-      elementName.type === "JSXMemberExpression" &&
-      elementName.object.type === "JSXIdentifier" &&
-      namespaces.has(elementName.object.name)
-    ) {
-      return { source: namespaces.get(elementName.object.name), name: elementName.property.name };
-    }
-    return null;
-  };
-}
-
-/**
- * The part an import renders, when `parts` (a Map from an export's name to the
- * `{ from, part }` modules that export it, a product's adapter under its own
- * name included) lists that export under a matching specifier.
- */
-export function partOf(imported, parts, filename) {
-  if (!imported) return null;
-  const exporter = parts
-    .get(imported.name)
-    ?.find(({ from }) => sourceMatches(imported.source, from, filename));
-  return exporter?.part ?? null;
-}
-
-export function writtenName(elementName) {
-  if (elementName.type === "JSXIdentifier") return elementName.name;
-  if (elementName.type === "JSXMemberExpression") return elementName.property.name;
-  return null;
-}
-
-/** An attribute's value when the source states it: `true` for a bare attribute, else a literal string, number or boolean. */
-export function staticAttribute(openingElement, attributeName) {
-  const attribute = openingElement.attributes.find(
-    (candidate) => candidate.type === "JSXAttribute" && candidate.name.name === attributeName,
-  );
-  if (!attribute) return undefined;
-  const { value } = attribute;
-  if (value === null) return true;
-  if (value.type === "Literal") return value.value;
-  if (value.type === "JSXExpressionContainer") {
-    const { expression } = value;
-    if (expression.type === "Literal") return expression.value;
-    if (expression.type === "TemplateLiteral" && expression.expressions.length === 0) {
-      return expression.quasis[0].value.cooked;
-    }
-  }
-  return undefined;
-}
-
-export const isRenderedChild = (node) =>
-  node.parent?.type === "JSXElement" || node.parent?.type === "JSXFragment";
-
-/**
- * Visits every node under `node`, depth first, `node` excluded. `visit`
- * returning `false` skips that node's subtree; returning `"stop"` ends the walk.
- */
-export function walk(node, visitorKeys, visit) {
-  const keys = visitorKeys[node.type] ?? [];
-  for (const key of keys) {
-    const value = node[key];
-    for (const child of Array.isArray(value) ? value : [value]) {
-      // 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 (!child || typeof child.type !== "string") continue;
-      const verdict = visit(child);
-      if (verdict === "stop") return "stop";
-      if (verdict === false) continue;
-      if (walk(child, visitorKeys, visit) === "stop") return "stop";
-    }
-  }
-  return undefined;
-}
-
-export function findBelow(node, visitorKeys, matches) {
-  let found = null;
-  walk(node, visitorKeys, (child) => {
-    if (!matches(child)) return true;
-    found = child;
-    return "stop";
-  });
-  return found;
-}

package/dist/eslint/rules/server-action-discipline.js

@@ -1,233 +0,0 @@
-/**
- * A Next.js server action is a POST endpoint with a function's syntax: anything
- * on the internet can call it with any arguments. So an exported server action
- * must resolve its viewer before it acts, and must parse whatever the client
- * sent before it trusts it.
- *
- * Standard tools checked first. `@next/eslint-plugin-next` is already on
- * through `eslint-config-next`, and none of its rules read a server action's
- * body — the set is script, head, font and image hygiene. `typescript-eslint`
- * can type the argument but cannot require that a call happened. The tier-1
- * option — a `defineAction` wrapper that makes an unvalidated or unauthorized
- * action untypeable — was tried and rejected for this change: Next binds the
- * exported function itself, so adopting it rewrites every exported action in
- * the same diff that retires the guard.
- *
- * The rule reads one function at a time — no whole-tree scan, no cross-file
- * dataflow, no exception ledger. A deliberately public action carries an inline
- * `eslint-disable-next-line` with its reason, which is reviewed in the diff that
- * adds it rather than in a list somewhere else.
- */
-
-/** Every helper that resolves the viewer and refuses an unauthorized one. */
-const AUTH_CALLS = new Set([
-  "actionActor",
-  "accountActionContext",
-  "companyActionContext",
-  "getPortalSession",
-  "installationActionContext",
-  "pageActor",
-  "requirePortalAdmin",
-  "requirePortalViewer",
-  "requireViewerForPage",
-  "resolveDeviceApprover",
-  "resolvePortalAccessState",
-]);
-
-/**
- * A schema's `parse`/`safeParse`. `JSON.parse` turns a string into an object
- * and asserts nothing about its shape, so it is not validation and is excluded
- * by name.
- */
-const VALIDATION_CALLS = new Set(["parse", "safeParse"]);
-
-const FUNCTION_TYPES = new Set([
-  "FunctionDeclaration",
-  "FunctionExpression",
-  "ArrowFunctionExpression",
-]);
-
-function hasUseServer(body) {
-  return (body ?? []).some(
-    (statement) =>
-      statement.type === "ExpressionStatement" &&
-      statement.expression.type === "Literal" &&
-      statement.expression.value === "use server",
-  );
-}
-
-function calleeName(node) {
-  if (node.callee.type === "Identifier") return node.callee.name;
-  if (node.callee.type === "MemberExpression" && node.callee.property.type === "Identifier") {
-    if (node.callee.object.type === "Identifier" && node.callee.object.name === "JSON") {
-      return undefined;
-    }
-    return node.callee.property.name;
-  }
-  return undefined;
-}
-
-/**
- * How a module-level function reaches the outside, which is what decides
- * whether Next binds it as a POST endpoint. All five spellings bind the same
- * way, so the rule reads all five: `export async function a`, `export default
- * async function a`, `export const a = async () => {}`, `export const a =
- * async function () {}`, and a bare declaration later named in `export { a }`.
- * Returns the identifier to report on, or undefined when the function is not a
- * module-level export.
- */
-function exportedIdentifier(node) {
-  const parent = node.parent;
-  if (!parent) return undefined;
-  // export [default] async function a() {}
-  if (parent.type === "ExportNamedDeclaration" || parent.type === "ExportDefaultDeclaration") {
-    return node.id ?? node;
-  }
-  // export const a = async () => {} / async function () {}
-  if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier") {
-    const declaration = parent.parent;
-    if (declaration?.parent?.type === "ExportNamedDeclaration") return parent.id;
-    // A bare `const a = async () => {}` that a later `export { a }` names.
-    if (declaration?.parent?.type === "Program") return parent.id;
-    return undefined;
-  }
-  // A bare `async function a() {}` that a later `export { a }` names.
-  if (parent.type === "Program") return node.id ?? undefined;
-  return undefined;
-}
-
-function inServerActionCode(node, moduleIsServer) {
-  if (moduleIsServer) return true;
-  for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
-    if (FUNCTION_TYPES.has(ancestor.type) && hasUseServer(ancestor.body?.body)) return true;
-  }
-  return false;
-}
-
-function inlineRejectionHandler(node) {
-  const handler = node.arguments[0];
-  if (node.callee.type !== "MemberExpression" || node.callee.property.type !== "Identifier") {
-    return undefined;
-  }
-  if (node.callee.property.name !== "catch" || !FUNCTION_TYPES.has(handler?.type)) return undefined;
-  return handler;
-}
-
-function dropsTheError(sourceCode, node, bindings) {
-  if (bindings.length === 0) return true;
-  return sourceCode
-    .getDeclaredVariables(node)
-    .filter((variable) =>
-      variable.defs.some((def) => def.type === "CatchClause" || def.type === "Parameter"),
-    )
-    .every((variable) => variable.references.length === 0);
-}
-
-/** @type {import("eslint").Rule.RuleModule} */
-export const serverActionDiscipline = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "An exported server action resolves its viewer and parses its client input, and server-action code never drops an error it catches.",
-    },
-    schema: [],
-    messages: {
-      missingAuth:
-        "Server action '{{name}}' calls no viewer check. Resolve the viewer first (actionActor, requirePortalViewer, companyActionContext, …), or disable this rule inline with the reason it is public.",
-      missingValidation:
-        "Server action '{{name}}' takes client input and never parses it. Run the Zod schema's parse/safeParse before trusting the argument.",
-      droppedError:
-        "This catch drops the error it handles, so an outage reaches the form as an ordinary answer and leaves no log line. Name the error and translate it, answer the form's unavailable state with actionUnavailable, which logs it once, or rethrow it.",
-    },
-  },
-  create(context) {
-    const { sourceCode } = context;
-    const moduleIsServer = hasUseServer(sourceCode.ast.body);
-    /**
-     * One frame per function, holding only the calls written in that function's
-     * own body. A call parked inside a nested callback is not a call the action
-     * itself makes, so it does not count for the action.
-     * @type {Array<Set<string>>}
-     */
-    const callStack = [];
-    /**
-     * Candidates are judged at `Program:exit` rather than when each function
-     * closes, because `export { a }` can name a declaration written above it.
-     * @type {Array<{ identifier: object, name: string, calls: Set<string>, hasParams: boolean, inlineExported: boolean }>}
-     */
-    const candidates = [];
-    /** Names an `export { … }` specifier list makes public. @type {Set<string>} */
-    const specifierExports = new Set();
-
-    function enter() {
-      callStack.push(new Set());
-    }
-
-    function exit(node) {
-      const calls = callStack.pop() ?? new Set();
-      if (!node.async) return;
-      if (!(moduleIsServer || hasUseServer(node.body?.body))) return;
-      const identifier = exportedIdentifier(node);
-      if (!identifier) return;
-      const parent = node.parent;
-      const inlineExported =
-        parent?.type === "ExportNamedDeclaration" ||
-        parent?.type === "ExportDefaultDeclaration" ||
-        parent?.parent?.parent?.type === "ExportNamedDeclaration";
-      candidates.push({
-        identifier,
-        name: identifier.name ?? "default",
-        calls,
-        hasParams: node.params.length > 0,
-        inlineExported,
-      });
-    }
-
-    return {
-      FunctionDeclaration: enter,
-      "FunctionDeclaration:exit": exit,
-      FunctionExpression: enter,
-      "FunctionExpression:exit": exit,
-      ArrowFunctionExpression: enter,
-      "ArrowFunctionExpression:exit": exit,
-      ExportNamedDeclaration(node) {
-        for (const specifier of node.specifiers ?? []) {
-          const local = specifier.local;
-          if (local?.type === "Identifier") specifierExports.add(local.name);
-        }
-      },
-      CatchClause(node) {
-        const bindings = node.param ? [node.param] : [];
-        if (inServerActionCode(node, moduleIsServer) && dropsTheError(sourceCode, node, bindings)) {
-          context.report({ node, messageId: "droppedError" });
-        }
-      },
-      CallExpression(node) {
-        const handler = inlineRejectionHandler(node);
-        if (
-          handler &&
-          inServerActionCode(node, moduleIsServer) &&
-          dropsTheError(sourceCode, handler, handler.params)
-        ) {
-          context.report({ node: handler, messageId: "droppedError" });
-        }
-        const name = calleeName(node);
-        if (!name) return;
-        callStack.at(-1)?.add(name);
-      },
-      "Program:exit"() {
-        for (const candidate of candidates) {
-          if (!candidate.inlineExported && !specifierExports.has(candidate.name)) continue;
-          const { identifier, name, calls, hasParams } = candidate;
-          if (![...AUTH_CALLS].some((call) => calls.has(call))) {
-            context.report({ node: identifier, messageId: "missingAuth", data: { name } });
-          }
-          if (hasParams && ![...VALIDATION_CALLS].some((call) => calls.has(call))) {
-            context.report({ node: identifier, messageId: "missingValidation", data: { name } });
-          }
-        }
-      },
-    };
-  },
-};