@camunda/design-system 0.63.0 → 0.64.0

package/eslint-rules/button-has-type.js

@@ -0,0 +1,56 @@
+/**
+ * Flags a native `<button>` without an explicit static `type`. The HTML
+ * default is `type="submit"`, so a plain button inside a `<form>` submits it.
+ *
+ * A dynamic value (`type={kind}`) or a spread (`{...props}`) is trusted — the
+ * type may arrive through it. Statically known non-strings (`type={null}`,
+ * `type={true}`, bare `type`) are invalid: React can't turn them into a type. Only lowercase `button` host elements are
+ * checked; components (DS `Button`, `asChild` targets) own their own default.
+ */
+import { attributeValueKind, findAttribute, hasSpread } from "./ds-imports.js";
+
+const VALID_TYPES = new Set(["button", "submit", "reset"]);
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        'Native <button> elements must set an explicit type (usually type="button").',
+    },
+    messages: {
+      missingType:
+        'Native <button> without `type` defaults to "submit" inside a <form>. Add type="button" (or "submit"/"reset" when intended).',
+      invalidType:
+        '"{{value}}" is not a valid button type. Use "button", "submit" or "reset".',
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      JSXOpeningElement(node) {
+        if (node.name.type !== "JSXIdentifier" || node.name.name !== "button") {
+          return;
+        }
+        const typeAttr = findAttribute(node, "type");
+        if (!typeAttr) {
+          if (!hasSpread(node)) {
+            context.report({ node, messageId: "missingType" });
+          }
+          return;
+        }
+        const { kind, value } = attributeValueKind(typeAttr.value);
+        if (kind === "dynamic") return;
+        if (kind === "string" && VALID_TYPES.has(value)) return;
+        context.report({
+          node: typeAttr,
+          messageId: "invalidType",
+          data: {
+            value:
+              kind === "string" ? value : context.sourceCode.getText(typeAttr),
+          },
+        });
+      },
+    };
+  },
+};

package/eslint-rules/class-literal.js

@@ -0,0 +1,20 @@
+/**
+ * Shared helper for the DS `local/*` className rules: given a JSX attribute
+ * VALUE node, returns the string when the className is a plain string literal
+ * (`"a b"` or `{"a b"}`), else null. cn()/template-literal/cva classNames are
+ * intentionally not inspected — the rules only reason about static strings.
+ */
+export function classLiteral(value) {
+  if (!value) return null;
+  if (value.type === "Literal" && typeof value.value === "string") {
+    return value.value;
+  }
+  if (
+    value.type === "JSXExpressionContainer" &&
+    value.expression.type === "Literal" &&
+    typeof value.expression.value === "string"
+  ) {
+    return value.expression.value;
+  }
+  return null;
+}

package/eslint-rules/ds-imports.js

@@ -0,0 +1,131 @@
+/**
+ * Shared helper for rules that target specific DS components: tracks which
+ * local JSX names were imported from a DS module, so a consumer's own
+ * `Button`/`DataTable` never trips a rule meant for the DS one. Handles
+ * aliased imports (`import { Button as DsButton } ...`).
+ *
+ * `importSources` matches a module specifier exactly or as a path prefix
+ * (`"@camunda/design-system"` also matches `".../carbon-compat"`). The icon
+ * proxy subpath (`…/icons`) is never tracked: it re-exports every Lucide
+ * glyph, and glyphs such as `Link` or `Table` must not be mistaken for the DS
+ * components of the same name.
+ */
+export const DEFAULT_IMPORT_SOURCES = ["@camunda/design-system"];
+
+export const importSourcesSchema = {
+  type: "object",
+  properties: {
+    importSources: {
+      type: "array",
+      items: { type: "string" },
+      minItems: 1,
+      uniqueItems: true,
+    },
+  },
+  additionalProperties: false,
+};
+
+export function matchesSource(source, importSources) {
+  return importSources.some(
+    (s) =>
+      source === s ||
+      (source.startsWith(`${s}/`) &&
+        !/^icons(\/|$)/.test(source.slice(s.length + 1))),
+  );
+}
+
+// Returns { ImportDeclaration, importedName(jsxNameNode), importedCallee(name) }
+// — the visitor records imports; the lookups resolve a local JSX/callee name
+// back to the name it was exported under, or null when it isn't a DS import.
+export function trackDsImports(context) {
+  const importSources =
+    context.options[0]?.importSources ?? DEFAULT_IMPORT_SOURCES;
+  const locals = new Map();
+  return {
+    ImportDeclaration(node) {
+      if (!matchesSource(node.source.value, importSources)) return;
+      for (const spec of node.specifiers) {
+        if (spec.type !== "ImportSpecifier") continue;
+        const imported =
+          spec.imported.type === "Identifier"
+            ? spec.imported.name
+            : spec.imported.value;
+        locals.set(spec.local.name, imported);
+      }
+    },
+    importedName(nameNode) {
+      if (nameNode.type !== "JSXIdentifier") return null;
+      return locals.get(nameNode.name) ?? null;
+    },
+    importedCallee(localName) {
+      return locals.get(localName) ?? null;
+    },
+  };
+}
+
+// JSX attribute lookup by name on an opening element; spread attributes are
+// skipped (callers treat an element with a spread as "may carry the prop").
+export function findAttribute(openingElement, name) {
+  return openingElement.attributes.find(
+    (a) =>
+      a.type === "JSXAttribute" &&
+      a.name.type === "JSXIdentifier" &&
+      a.name.name === name,
+  );
+}
+
+// True when the prop is set to something that can be truthy: bare (`asChild`
+// = true), a string, or a dynamic expression. Statically disabled values —
+// `{false}`, `{null}`, `{undefined}`, `{}` — count as absent.
+export function hasActiveAttribute(openingElement, name) {
+  const attr = findAttribute(openingElement, name);
+  if (!attr) return false;
+  if (attr.value == null) return true;
+  if (attr.value.type !== "JSXExpressionContainer") return true;
+  const e = attr.value.expression;
+  if (e.type === "JSXEmptyExpression") return false;
+  if (e.type === "Identifier" && e.name === "undefined") return false;
+  return !(e.type === "Literal" && (e.value === false || e.value === null));
+}
+
+export function hasSpread(openingElement) {
+  return openingElement.attributes.some((a) => a.type === "JSXSpreadAttribute");
+}
+
+// Classifies a JSX attribute value:
+//   { kind: "string", value } — statically known string (`"x"`, `{"x"}`, `{`x`}`)
+//   { kind: "invalid" }       — statically known non-string: bare attribute
+//                               (`<b attr>` = true), `{null}`, `{true}`, `{42}`,
+//                               `{undefined}`, `{}`
+//   { kind: "dynamic" }       — anything else (identifier, call, ternary, …)
+export function attributeValueKind(value) {
+  if (value == null) return { kind: "invalid" };
+  const text = staticString(value);
+  if (text !== null) return { kind: "string", value: text };
+  if (value.type !== "JSXExpressionContainer") return { kind: "dynamic" };
+  const e = value.expression;
+  if (
+    e.type === "JSXEmptyExpression" ||
+    e.type === "Literal" ||
+    (e.type === "Identifier" && e.name === "undefined")
+  ) {
+    return { kind: "invalid" };
+  }
+  return { kind: "dynamic" };
+}
+
+// String value of a JSX attribute when statically known (`"x"`, `{"x"}`,
+// `{`x`}` without expressions), else null.
+export function staticString(value) {
+  if (!value) return null;
+  if (value.type === "Literal" && typeof value.value === "string") {
+    return value.value;
+  }
+  if (value.type !== "JSXExpressionContainer") return null;
+  const e = value.expression;
+  if (e.type === "Literal" && typeof e.value === "string") return e.value;
+  if (e.type === "TemplateLiteral" && e.expressions.length === 0) {
+    return e.quasis[0].value.cooked;
+  }
+  return null;
+}

package/eslint-rules/icon-button-needs-label.js

@@ -0,0 +1,110 @@
+/**
+ * Flags a DS `<Button size="icon…">` with no accessible name: no `aria-label`
+ * / `aria-labelledby` on it or on a descendant (the `asChild` link case), and
+ * no text among its children. Icon-only buttons
+ * without a name are the most common a11y violation in consumer apps.
+ *
+ * Only `Button` imported from a DS module is checked (see ds-imports.js).
+ * Conservative by design — it stays silent whenever the name may come from
+ * somewhere it cannot see: a spread, a dynamic `size`, or any `{expression}`
+ * child (a translated string, a label variable, a conditional).
+ */
+import {
+  attributeValueKind,
+  findAttribute,
+  hasSpread,
+  importSourcesSchema,
+  staticString,
+  trackDsImports,
+} from "./ds-imports.js";
+
+const HAS_WORDS = /\p{L}/u;
+
+// A name attribute counts unless it is statically empty: `aria-label=""`,
+// `aria-label={null}`, bare `aria-label`. Dynamic values are trusted.
+function hasNameAttribute(opening) {
+  return ["aria-label", "aria-labelledby"].some((name) => {
+    const attr = findAttribute(opening, name);
+    if (!attr) return false;
+    const { kind, value } = attributeValueKind(attr.value);
+    return kind === "dynamic" || (kind === "string" && value.trim() !== "");
+  });
+}
+
+function isAriaHidden(opening) {
+  const attr = findAttribute(opening, "aria-hidden");
+  if (!attr) return false;
+  const { kind, value } = attributeValueKind(attr.value);
+  return (
+    (kind === "string" && value === "true") ||
+    attr.value == null ||
+    (attr.value.type === "JSXExpressionContainer" &&
+      attr.value.expression.type === "Literal" &&
+      attr.value.expression.value === true)
+  );
+}
+
+// true when some descendant may provide the name: a letter-bearing JSXText,
+// any expression container (its value is unknown statically), or an element
+// carrying aria-label/aria-labelledby (the `asChild` link/anchor case).
+function mayProvideName(children) {
+  return children.some((child) => {
+    if (child.type === "JSXText") return HAS_WORDS.test(child.value);
+    if (child.type === "JSXExpressionContainer") {
+      const e = child.expression;
+      if (e.type === "JSXEmptyExpression") return false;
+      // {null} / {false} / {true} / {undefined} render nothing; a string
+      // literal names only if it has letters. Anything dynamic is trusted.
+      if (e.type === "Identifier" && e.name === "undefined") return false;
+      if (e.type === "Literal") {
+        return typeof e.value === "string"
+          ? HAS_WORDS.test(e.value)
+          : typeof e.value === "number";
+      }
+      return true;
+    }
+    if (child.type === "JSXElement") {
+      // An aria-hidden subtree is excluded from the accessible name.
+      if (isAriaHidden(child.openingElement)) return false;
+      return (
+        hasNameAttribute(child.openingElement) || mayProvideName(child.children)
+      );
+    }
+    if (child.type === "JSXFragment") return mayProvideName(child.children);
+    return true;
+  });
+}
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        'A DS <Button size="icon…"> must have an accessible name (aria-label or aria-labelledby).',
+    },
+    messages: {
+      missingLabel:
+        'Icon-only <Button size="{{size}}"> has no accessible name. Add aria-label="…" (or use <IconButton label="…">, which also renders a tooltip).',
+    },
+    schema: [importSourcesSchema],
+  },
+  create(context) {
+    const ds = trackDsImports(context);
+    return {
+      ImportDeclaration: ds.ImportDeclaration,
+      JSXElement(node) {
+        const opening = node.openingElement;
+        if (ds.importedName(opening.name) !== "Button") return;
+        const size = staticString(findAttribute(opening, "size")?.value);
+        if (!size?.startsWith("icon")) return;
+        if (hasSpread(opening)) return;
+        if (hasNameAttribute(opening) || mayProvideName(node.children)) return;
+        context.report({
+          node: opening,
+          messageId: "missingLabel",
+          data: { size },
+        });
+      },
+    };
+  },
+};

package/eslint-rules/index.js

@@ -0,0 +1,31 @@
+// Registry of the `local/*` convention rules this repo's own lint enables
+// (eslint.config.js). Rules that also make sense in product repos are shipped,
+// from the same implementation files, by the consumer plugin in
+// eslint-plugin/index.js — that plugin (not this registry) is what product
+// repos extend and what scripts/audit-conventions.mjs runs on agent output.
+import buttonHasType from "./button-has-type.js";
+import iconButtonNeedsLabel from "./icon-button-needs-label.js";
+import requireBrowsableLink from "./require-browsable-link.js";
+import noPrimitiveTailwindColors from "./no-primitive-tailwind-colors.js";
+import noRawColorInClassName from "./no-raw-color-in-classname.js";
+import noAdhocTypography from "./no-adhoc-typography.js";
+import requireSharedSidebarProvider from "./require-shared-sidebar-provider.js";
+import noHardcodedUserFacingString from "./no-hardcoded-user-facing-string.js";
+
+export const rules = {
+  "button-has-type": buttonHasType,
+  "icon-button-needs-label": iconButtonNeedsLabel,
+  "require-browsable-link": requireBrowsableLink,
+  "no-primitive-tailwind-colors": noPrimitiveTailwindColors,
+  "no-raw-color-in-classname": noRawColorInClassName,
+  "no-adhoc-typography": noAdhocTypography,
+  "require-shared-sidebar-provider": requireSharedSidebarProvider,
+  "no-hardcoded-user-facing-string": noHardcodedUserFacingString,
+};
+
+// ESLint flat-config plugin object. A SINGLE shared reference is required:
+// flat config rejects redefining a plugin key with a different object when
+// blocks' `files` overlap, so every config block must reuse this one object.
+export const localPlugin = { rules };
+
+export default localPlugin;

package/eslint-rules/navigation.js

@@ -0,0 +1,295 @@
+/**
+ * Shared helpers for the link rules (require-browsable-link, prefer-link-props):
+ * decide whether a click handler visibly navigates, and find the DS
+ * "descriptor" objects (sidebar items, breadcrumb segments, …) that carry
+ * their own click/link props.
+ *
+ * "Navigates" = the handler (or a same-file function it calls, a few levels
+ * deep) calls `navigate(url)`, `router.push/replace`, `history.push/replace`
+ * (also nested: `props.history.push`, `store.router.push`),
+ * `location.assign/replace`, `window.open`, or assigns `location`/
+ * `location.href`. Not a destination a link could carry, so ignored:
+ *   - `navigate(-1)` (history back);
+ *   - navigation after an `await` in the same function (create, then open the
+ *     new item — the URL doesn't exist before the click);
+ *   - navigation inside a nested callback the handler only creates or passes
+ *     on (`openConfirm({ onConfirm: () => navigate(url) })`, `.then(…)`).
+ *
+ * `navigationFunctions` adds app helpers: a bare name (`"goTo"`) matches
+ * `goTo(…)`; a dotted name (`"router.goTo"`) matches any `….router.goTo(…)`.
+ */
+export const navigationSchemaProperties = {
+  navigationFunctions: {
+    type: "array",
+    items: { type: "string" },
+    uniqueItems: true,
+  },
+};
+
+const NAV_OBJECTS = new Set(["router", "history", "navigation"]);
+const NAV_METHODS = new Set(["push", "replace", "navigate"]);
+const LOCATION_METHODS = new Set(["assign", "replace"]);
+const MAX_DEPTH = 3;
+const FUNCTION_TYPES = new Set([
+  "ArrowFunctionExpression",
+  "FunctionExpression",
+  "FunctionDeclaration",
+]);
+
+function isLocation(node) {
+  if (node.type === "Identifier") return node.name === "location";
+  return (
+    node.type === "MemberExpression" &&
+    !node.computed &&
+    node.property.name === "location" &&
+    node.object.type === "Identifier" &&
+    (node.object.name === "window" || node.object.name === "document")
+  );
+}
+
+function isHistoryBack(call) {
+  const arg = call.arguments[0];
+  return (
+    arg &&
+    ((arg.type === "Literal" && typeof arg.value === "number") ||
+      (arg.type === "UnaryExpression" && arg.argument.type === "Literal"))
+  );
+}
+
+// The navigating call's destination node, when it has one (`navigate(url)`).
+function navigationTarget(node, navFns) {
+  if (node.type === "AssignmentExpression") {
+    const left = node.left;
+    if (isLocation(left)) return node;
+    if (
+      left.type === "MemberExpression" &&
+      !left.computed &&
+      left.property.name === "href" &&
+      isLocation(left.object)
+    ) {
+      return node;
+    }
+    return null;
+  }
+  if (node.type !== "CallExpression") return null;
+  const callee = node.callee;
+  if (callee.type === "Identifier") {
+    if (callee.name === "navigate" || navFns.has(callee.name)) {
+      return isHistoryBack(node) ? null : node;
+    }
+    return null;
+  }
+  if (callee.type !== "MemberExpression" || callee.computed) return null;
+  const method = callee.property.name;
+  const obj = callee.object;
+  // Last segment of the receiver: `history` in both `history.push` and
+  // `props.history.push`, `router` in `store.router.goTo`.
+  const objName =
+    obj.type === "Identifier"
+      ? obj.name
+      : obj.type === "MemberExpression" && !obj.computed
+        ? obj.property.name
+        : null;
+  if (objName && navFns.has(`${objName}.${method}`)) {
+    return isHistoryBack(node) ? null : node;
+  }
+  if (objName && NAV_OBJECTS.has(objName)) {
+    return NAV_METHODS.has(method) && !isHistoryBack(node) ? node : null;
+  }
+  if (obj.type === "Identifier" && obj.name === "window" && method === "open") {
+    return node;
+  }
+  if (isLocation(obj) && LOCATION_METHODS.has(method)) return node;
+  return null;
+}
+
+// True when `node` navigates through a built-in navigator (`navigate`,
+// `history`/`router` push/replace, `window.open`, `location`), whose first
+// argument is a URL — unlike an app helper (`goTo(route, params)`).
+export function isBuiltinNavigation(node) {
+  return navigationTarget(node, new Set()) === node;
+}
+
+function findVariableInit(context, identifier) {
+  let scope = context.sourceCode.getScope(identifier);
+  while (scope) {
+    const variable = scope.set.get(identifier.name);
+    if (variable) {
+      const def = variable.defs[0];
+      if (!def) return null;
+      if (def.node.type === "FunctionDeclaration") return def.node;
+      if (def.node.type === "VariableDeclarator") return def.node.init;
+      return null;
+    }
+    scope = scope.upper;
+  }
+  return null;
+}
+
+// `useCallback(fn, deps)` / `useMemo(() => value, deps)` → their first arg.
+function unwrapHook(node) {
+  if (
+    node?.type === "CallExpression" &&
+    node.callee.type === "Identifier" &&
+    (node.callee.name === "useCallback" || node.callee.name === "useMemo") &&
+    node.arguments[0]
+  ) {
+    return node.arguments[0];
+  }
+  return node;
+}
+
+// Resolves an expression to the function it denotes (inline, or a same-file
+// identifier, optionally wrapped in useCallback), else null.
+export function resolveFunction(context, expr) {
+  let node = expr;
+  if (node?.type === "Identifier") node = findVariableInit(context, node);
+  node = unwrapHook(node);
+  return node && FUNCTION_TYPES.has(node.type) ? node : null;
+}
+
+// Depth-first walk. `visit` returns true to stop, "skip" to not descend into
+// the node's children, anything else to continue.
+function walk(node, visit) {
+  if (!node || typeof node.type !== "string") return false;
+  const verdict = visit(node);
+  if (verdict === true) return true;
+  if (verdict === "skip") return false;
+  for (const key of Object.keys(node)) {
+    if (key === "parent") continue;
+    const child = node[key];
+    if (Array.isArray(child)) {
+      if (child.some((c) => walk(c, visit))) return true;
+    } else if (child && typeof child.type === "string") {
+      if (walk(child, visit)) return true;
+    }
+  }
+  return false;
+}
+
+// Returns the first navigating node reachable from `expr` (a handler
+// expression), or null. Follows calls to same-file functions up to MAX_DEPTH.
+export function findNavigation(context, expr, depth = 0, seen = new Set()) {
+  const fn = resolveFunction(context, expr);
+  if (!fn || seen.has(fn) || depth > MAX_DEPTH) return null;
+  seen.add(fn);
+  const navFns = new Set(context.options[0]?.navigationFunctions ?? []);
+  // Nested function bodies are deferred work (callbacks passed on, `.then`),
+  // not something this handler runs — skip them; called same-file functions
+  // are still followed through the Identifier-callee branch below.
+  const skipNested = (node) =>
+    node !== fn.body && FUNCTION_TYPES.has(node.type);
+  const awaitEnds = [];
+  walk(fn.body, (node) => {
+    if (skipNested(node)) return "skip";
+    if (node.type === "AwaitExpression") awaitEnds.push(node.range[1]);
+    return false;
+  });
+  let found = null;
+  walk(fn.body, (node) => {
+    if (skipNested(node)) return "skip";
+    const target = navigationTarget(node, navFns);
+    if (target) {
+      if (awaitEnds.some((end) => end <= target.range[0])) return false;
+      found = target;
+      return true;
+    }
+    if (node.type === "CallExpression" && node.callee.type === "Identifier") {
+      found = findNavigation(context, node.callee, depth + 1, seen);
+      return Boolean(found);
+    }
+    return false;
+  });
+  return found;
+}
+
+// Navigation found through a JSX attribute's handler, or null.
+export function attributeNavigation(context, attr) {
+  const value = attr?.value;
+  if (value?.type !== "JSXExpressionContainer") return null;
+  return findNavigation(context, value.expression);
+}
+
+// DS components whose props take descriptor objects carrying their own
+// `onClick`/`navigate` + `linkProps`/`href` (sidebar items, breadcrumb
+// segments and switcher entries, notifications).
+const DESCRIPTOR_COMPONENTS = new Set([
+  "AppSidebar",
+  "NavBreadcrumb",
+  "NavBreadcrumbOverflow",
+  "NavBreadcrumbSwitcher",
+  "NavSwitcher",
+  "NotificationBell",
+  "NotificationsPanel",
+]);
+const DESCRIPTOR_FACTORY = /^create[A-Za-z]*Descriptor$/;
+const DESCRIPTOR_CLICK_PROPS = ["onClick", "navigate"];
+const DESCRIPTOR_LINK_PROPS = new Set(["linkProps", "href", "to"]);
+// Descriptor fields holding objects with a click but no link API
+// (`BreadcrumbAction` under `actions`) — never descriptors to lint.
+const NON_LINK_FIELDS = new Set(["actions"]);
+
+function propertyName(prop) {
+  if (prop.type !== "Property" || prop.computed) return null;
+  if (prop.key.type === "Identifier") return prop.key.name;
+  return prop.key.type === "Literal" ? String(prop.key.value) : null;
+}
+
+// Visits every object literal reachable from `expr` (arrays, nested objects,
+// `.map(() => ({…}))` callbacks, a same-file `const items = […]`, useMemo).
+// Calls onDescriptor(object, clickProperty) for objects that have a click
+// prop and no link prop; spreads count as "may carry the link prop".
+export function forEachLinklessDescriptor(context, expr, onDescriptor) {
+  let root = expr;
+  if (root?.type === "Identifier") root = findVariableInit(context, root);
+  root = unwrapHook(root);
+  if (
+    root &&
+    FUNCTION_TYPES.has(root.type) &&
+    root.body.type !== "BlockStatement"
+  ) {
+    root = root.body;
+  }
+  walk(root, (node) => {
+    if (node.type === "Property" && NON_LINK_FIELDS.has(propertyName(node))) {
+      return "skip";
+    }
+    if (node.type !== "ObjectExpression") return false;
+    if (node.properties.some((p) => p.type === "SpreadElement")) return false;
+    // A link field set to null/false/undefined carries no link.
+    const hasLink = node.properties.some(
+      (p) =>
+        DESCRIPTOR_LINK_PROPS.has(propertyName(p)) &&
+        !(p.value.type === "Identifier" && p.value.name === "undefined") &&
+        !(
+          p.value.type === "Literal" &&
+          (p.value.value === null || p.value.value === false)
+        ),
+    );
+    if (hasLink) return false;
+    const click = node.properties.find((p) =>
+      DESCRIPTOR_CLICK_PROPS.includes(propertyName(p)),
+    );
+    if (click) onDescriptor(node, click);
+    return false;
+  });
+}
+
+// Every descriptor root in a JSX element / factory call from a DS module.
+export function descriptorRoots(ds, node) {
+  if (node.type === "JSXOpeningElement") {
+    if (!DESCRIPTOR_COMPONENTS.has(ds.importedName(node.name) ?? "")) return [];
+    return node.attributes
+      .filter(
+        (a) =>
+          a.type === "JSXAttribute" &&
+          a.value?.type === "JSXExpressionContainer",
+      )
+      .map((a) => a.value.expression);
+  }
+  if (node.type === "CallExpression" && node.callee.type === "Identifier") {
+    const imported = ds.importedCallee(node.callee.name);
+    return imported && DESCRIPTOR_FACTORY.test(imported) ? node.arguments : [];
+  }
+  return [];
+}