@camunda/design-system 0.62.0 → 0.64.0

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 [];
+}

package/eslint-rules/no-adhoc-typography.js

@@ -0,0 +1,77 @@
+/**
+ * Flags ad-hoc typography that should use the DS <Heading>/<Text> primitives.
+ * Moderate scope: bare <h1>-<h6>, Carbon Heading/Section imports, and elements
+ * whose className string literal combines a font-size AND a font-weight utility.
+ * Only string-literal classNames are inspected (cn()/template-literals/cva not).
+ */
+import { classLiteral } from "./class-literal.js";
+
+const SIZE = /\btext-(xs|sm|base|lg|xl|[2-9]xl|\[[^\]]+\])\b/;
+const WEIGHT =
+  /\bfont-(thin|extralight|light|normal|medium|semibold|bold|extrabold|black|\[\d+\])\b/;
+const HEADING_TAGS = new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
+const PRIMITIVE_NAMES = new Set(["Heading", "Text"]);
+const SVG_TEXT_ELEMENTS = new Set(["text", "tspan", "textPath"]);
+
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Use the DS Heading/Text primitives instead of bare headings or ad-hoc type-scale classes.",
+    },
+    messages: {
+      bareHeading:
+        'Use <Heading as="{{tag}}" variant="…"> instead of a bare <{{tag}}>.',
+      carbonImport:
+        "Use the DS <Heading> primitive; drop <Section>/<HeadingLevel> and set the level via `as`.",
+      adhocClasses:
+        "Use a <Heading>/<Text> variant instead of hand-written type-scale classes (font-size + font-weight combo).",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      JSXOpeningElement(node) {
+        if (node.name.type !== "JSXIdentifier") return;
+        const name = node.name.name;
+        if (HEADING_TAGS.has(name)) {
+          context.report({
+            node,
+            messageId: "bareHeading",
+            data: { tag: name },
+          });
+          return;
+        }
+        if (PRIMITIVE_NAMES.has(name)) return;
+        // Ad-hoc type-scale only matters on raw HTML host elements. Capitalized React
+        // components (DS *Title composites that consume typographyVariants, and consumer
+        // components) own their className semantics — an override is deliberate, like the
+        // Heading/Text allowance. SVG text nodes can't host Heading/Text.
+        if (!/^[a-z]/.test(name) || SVG_TEXT_ELEMENTS.has(name)) return;
+        const classAttr = node.attributes.find(
+          (a) => a.type === "JSXAttribute" && a.name.name === "className",
+        );
+        if (!classAttr) return;
+        const raw = classLiteral(classAttr.value);
+        if (raw && SIZE.test(raw) && WEIGHT.test(raw)) {
+          // Anchor to the opening element (like `bareHeading`) so the audit
+          // gate prints a consistent line:col for both heading findings.
+          context.report({ node, messageId: "adhocClasses" });
+        }
+      },
+      ImportDeclaration(node) {
+        if (node.source.value !== "@carbon/react") return;
+        for (const spec of node.specifiers) {
+          if (
+            spec.type === "ImportSpecifier" &&
+            (spec.imported.name === "Heading" ||
+              spec.imported.name === "Section")
+          ) {
+            context.report({ node: spec, messageId: "carbonImport" });
+          }
+        }
+      },
+    };
+  },
+};

package/eslint-rules/no-deep-import.js

@@ -0,0 +1,59 @@
+/**
+ * Flags imports of `@camunda/design-system/<subpath>` where the subpath is not
+ * a public entry point (e.g. `/dist/src/icons`, `/src/components/ui/button`).
+ * Deep paths are internal layout and break on any refactor.
+ *
+ * The allowed subpaths are read from this package's own `exports` map at load
+ * time, so a new public entry point is allowed without touching this rule.
+ */
+import { createRequire } from "node:module";
+
+const PACKAGE = "@camunda/design-system";
+const pkg = createRequire(import.meta.url)("../package.json");
+const PUBLIC_SUBPATHS = new Set(
+  Object.keys(pkg.exports)
+    .filter((k) => k !== ".")
+    .map((k) => k.slice(2)),
+);
+
+function publicList() {
+  return [PACKAGE, ...[...PUBLIC_SUBPATHS].map((s) => `${PACKAGE}/${s}`)]
+    .map((s) => `"${s}"`)
+    .join(", ");
+}
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: `Import ${PACKAGE} only through its public entry points.`,
+    },
+    messages: {
+      deepImport: `"{{source}}" is not a public entry point of ${PACKAGE}. Import from one of: {{allowed}}.`,
+    },
+    schema: [],
+  },
+  create(context) {
+    function checkSource(node) {
+      const source = node.source?.value;
+      if (typeof source !== "string" || !source.startsWith(`${PACKAGE}/`)) {
+        return;
+      }
+      if (PUBLIC_SUBPATHS.has(source.slice(PACKAGE.length + 1))) return;
+      context.report({
+        node: node.source,
+        messageId: "deepImport",
+        data: { source, allowed: publicList() },
+      });
+    }
+
+    return {
+      ImportDeclaration: checkSource,
+      ExportNamedDeclaration: checkSource,
+      ExportAllDeclaration: checkSource,
+      ImportExpression(node) {
+        if (node.source.type === "Literal") checkSource(node);
+      },
+    };
+  },
+};

package/eslint-rules/no-direct-lucide-import.js

@@ -0,0 +1,67 @@
+/**
+ * Flags any import or re-export sourced directly from "lucide-react" (or one of
+ * its subpaths). Glyphs must flow through the DS icon proxy instead, so the
+ * concrete glyph behind a name can be swapped centrally.
+ *
+ * Two variants share one implementation and differ only in the proxy path:
+ *   - default export: DS repo source, proxy is the internal "icons/lucide"
+ *     alias. The proxy module itself (src/icons/lucide.ts) is exempted via an
+ *     eslint.config.js block, not via logic in this rule.
+ *   - `consumerNoDirectLucideImport`: product repos, proxy is the public
+ *     "@camunda/design-system/icons" subpath. Shipped in the ESLint plugin.
+ *
+ * Autofix rewrites a bare "lucide-react" source to the proxy path — safe
+ * because the proxy re-exports the whole lucide-react surface (`export *`).
+ * Subpath sources ("lucide-react/dynamic", …) are reported but not fixed: the
+ * proxy only mirrors the package root.
+ */
+function createNoDirectLucideImport(proxyPath) {
+  return {
+    meta: {
+      type: "problem",
+      docs: {
+        description: `Import Lucide glyphs from the DS icon proxy (${proxyPath}), not lucide-react directly.`,
+      },
+      fixable: "code",
+      messages: {
+        noDirectLucideImport: `Import glyphs from the DS icon proxy ("${proxyPath}"), not lucide-react directly.`,
+      },
+      schema: [],
+    },
+    create(context) {
+      function checkSource(node) {
+        const source = node.source?.value;
+        if (typeof source !== "string") return;
+        if (source !== "lucide-react" && !source.startsWith("lucide-react/")) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "noDirectLucideImport",
+          fix:
+            source === "lucide-react"
+              ? (fixer) => {
+                  const quote = node.source.raw[0];
+                  return fixer.replaceText(
+                    node.source,
+                    `${quote}${proxyPath}${quote}`,
+                  );
+                }
+              : null,
+        });
+      }
+
+      return {
+        ImportDeclaration: checkSource,
+        ExportNamedDeclaration: checkSource,
+        ExportAllDeclaration: checkSource,
+      };
+    },
+  };
+}
+
+export const consumerNoDirectLucideImport = createNoDirectLucideImport(
+  "@camunda/design-system/icons",
+);
+
+export default createNoDirectLucideImport("icons/lucide");