@ekanos/sdk 0.5.0 → 0.7.0

package/eslint.design-preset.mjs

@@ -0,0 +1,226 @@
+/**
+ * @ekanos/sdk/eslint/design — the partner STYLE preset.
+ *
+ * This is a style preset, and it is deliberately a SEPARATE export from
+ * `@ekanos/sdk/eslint`. That one is a security control: it bans the escapes
+ * that route around the capability layer, it sets `noInlineConfig` so partner
+ * source cannot silence it, and every rule in it is core ESLint so it adds
+ * nothing to the SDK's build. Mixing a style rule into that file would make a
+ * load-bearing control look negotiable, and a partner who disabled the preset
+ * over a `<button>` complaint would have disabled the control with it.
+ *
+ * So the two ship apart, and a partner may adopt this one and not the other
+ * (never the reverse — the capability preset is not optional for a
+ * submission).
+ *
+ * ── What it enforces ─────────────────────────────────────────────────────
+ * Nine rules. One is local to this file: no raw interactive HTML element
+ * where `@ekanos/ui` publishes the host's component. A hand-rolled `<button>`
+ * is not a styling nit — it misses the kit's focus ring, its disabled and
+ * loading states, its size scale, and every per-Source retint that reaches a
+ * widget through the component rather than through a class. The same goes for
+ * inputs, selects, textareas and labels, each of which carries accessibility
+ * wiring a bare element does not.
+ *
+ * The other eight are the host's own `design/*` rules — palette-adjacent
+ * white/black utilities, Badge tone variants, overlay widths, rounded row
+ * hovers, faded muted text, viewport breakpoints in widgets, tinted chips,
+ * toolbar tabs — imported from `./eslint.design-rules.mjs`, the single
+ * implementation the host repo's oxlint plugin also loads (through the
+ * two-line re-export the host's lint config keeps). There is
+ * exactly one copy of each rule, so a partner is held to what the host holds
+ * itself to and the two cannot drift.
+ *
+ * `ekanos validate` still reports its own `design/*` findings from a
+ * parser-less text scan (`@ekanos/integration-schema`'s
+ * `collectDesignSourceFindings`). That is a different mechanism for a
+ * different place — the admission gate scans a submitted archive with no
+ * ESLint and no AST — not a second copy of these rules.
+ *
+ * ── Severity: warn, everywhere ───────────────────────────────────────────
+ * Every rule here reports `warn`, never `error`, for the same reason
+ * `collectDesignSourceFindings` does: off-system UI is a cohesion defect a
+ * reviewer weighs, not an unbuildable submission. The scaffold wires this
+ * preset up on day one, and a lint that fails a new partner's very first run
+ * teaches them to delete the config. The host lints itself at `error` — see
+ * `.oxlintrc.json` — which is the asymmetry we want.
+ *
+ * ── Dependency-free, like its sibling ────────────────────────────────────
+ * `react/forbid-elements` would need `eslint-plugin-react`, a runtime
+ * dependency this package does not have and should not grow for a lint
+ * preset. The rule below is the same check, the same option shape
+ * (`{ forbid: [{ element, message }] }`), implemented in ~20 lines against
+ * ESLint's own JSX AST.
+ *
+ * ── Usage (a partner's eslint.config.mjs) ────────────────────────────────
+ *
+ *   import capabilityPreset from '@ekanos/sdk/eslint';
+ *   import designPreset from '@ekanos/sdk/eslint/design';
+ *
+ *   export default [
+ *     ...someBaseConfig,
+ *     ...capabilityPreset,
+ *     ...designPreset,
+ *   ];
+ *
+ * Inline disables DO work here, unlike the capability preset: a style rule
+ * with a real exception should be disabled at the line that needs it, where a
+ * reviewer reads the reason, rather than argued about.
+ */
+import designRulesPlugin from './eslint.design-rules.mjs';
+
+/**
+ * `.ts` as well as `.tsx`. The JSX-shaped rules find nothing in a `.ts`
+ * module and cost nothing there, but the class-string rules must see it: a
+ * `.ts` module can build UI with `createElement` and a `className` string,
+ * which the starter scaffold itself does.
+ */
+const COMPONENT_GLOB = ['src/**/*.ts', 'src/**/*.tsx'];
+
+/**
+ * The raw elements `@ekanos/ui` replaces, each with the module a partner
+ * imports instead. Kept equal to the host repo's own
+ * `react/forbid-elements` list for the example integrations by a parity test
+ * in `src/context/__tests__/design-preset-oxlint-parity.test.ts`.
+ */
+export const FORBIDDEN_ELEMENTS = [
+  {
+    element: 'button',
+    message:
+      'Use <Button> from @ekanos/ui/button. A bare <button> misses the focus ' +
+      'ring, the disabled and loading states, the size scale, and the ' +
+      'per-Source retint that only reaches a widget through the component.',
+  },
+  {
+    element: 'input',
+    message:
+      'Use <Input> from @ekanos/ui/input, inside a <FormField> from ' +
+      '@ekanos/ui/form when it is part of a form.',
+  },
+  {
+    element: 'select',
+    message: 'Use <Select> from @ekanos/ui/select.',
+  },
+  {
+    element: 'textarea',
+    message: 'Use <Textarea> from @ekanos/ui/textarea.',
+  },
+  {
+    element: 'label',
+    message:
+      'Use <Label> from @ekanos/ui/label, which wires itself to the control ' +
+      'it names.',
+  },
+  {
+    element: 'table',
+    message:
+      'Use <Table> from @ekanos/ui/table only for genuinely tabular data. ' +
+      'For a list, prefer edge-to-edge rows: a container with no horizontal ' +
+      'padding, each row `px-5 py-3` with a flat `hover:bg-accent/50`, ' +
+      'separated by <Separator> from @ekanos/ui/separator. See ' +
+      "the design system's widget rules.",
+  },
+];
+
+const FORBIDDEN_BY_ELEMENT = new Map(
+  FORBIDDEN_ELEMENTS.map((entry) => [entry.element, entry.message]),
+);
+
+/**
+ * ESLint's own `react/forbid-elements`, minus the plugin. A JSX element whose
+ * name is a lowercase HTML tag is a `JSXIdentifier`; a component reference is
+ * capitalised or a member expression, so neither can collide with this list.
+ */
+const designPlugin = {
+  meta: { name: 'ekanos-design' },
+  rules: {
+    'forbid-elements': {
+      meta: {
+        type: 'problem',
+        docs: {
+          description:
+            'Disallow raw interactive HTML elements that @ekanos/ui publishes a component for.',
+        },
+        schema: [
+          {
+            type: 'object',
+            properties: {
+              forbid: {
+                type: 'array',
+                items: {
+                  type: 'object',
+                  properties: {
+                    element: { type: 'string' },
+                    message: { type: 'string' },
+                  },
+                  required: ['element'],
+                  additionalProperties: false,
+                },
+              },
+            },
+            additionalProperties: false,
+          },
+        ],
+      },
+      /**
+       * Typed in JSDoc because a test imports this module, which pulls it
+       * into the package's TypeScript program (`eslint.preset.mjs` needs none
+       * — it declares no callbacks of its own).
+       *
+       * @param {{
+       *   options?: Array<{ forbid?: Array<{ element: string; message?: string }> }>;
+       *   report: (descriptor: { node: unknown; message: string }) => void;
+       * }} context
+       */
+      create(context) {
+        const configured = context.options?.[0]?.forbid;
+        const forbidden = Array.isArray(configured)
+          ? new Map(
+              configured.map((entry) => [
+                entry.element,
+                entry.message ?? `<${entry.element}> is forbidden.`,
+              ]),
+            )
+          : FORBIDDEN_BY_ELEMENT;
+
+        return {
+          /** @param {{ name?: { type: string; name: string } }} node */
+          JSXOpeningElement(node) {
+            if (node.name?.type !== 'JSXIdentifier') return;
+
+            const message = forbidden.get(node.name.name);
+            if (message) context.report({ node, message });
+          },
+        };
+      },
+    },
+  },
+};
+
+/**
+ * Every rule the shared plugin publishes, at `warn`. Derived from the plugin
+ * rather than listed, so a rule added to `eslint.design-rules.mjs` for the
+ * host reaches partners in the same commit — the drift this preset's whole
+ * arrangement exists to prevent.
+ */
+const sharedDesignRules = Object.fromEntries(
+  Object.keys(designRulesPlugin.rules).map((rule) => [
+    `${designRulesPlugin.meta.name}/${rule}`,
+    'warn',
+  ]),
+);
+
+export default [
+  {
+    name: '@ekanos/sdk/eslint/design',
+    files: COMPONENT_GLOB,
+    plugins: {
+      'ekanos-design': designPlugin,
+      [designRulesPlugin.meta.name]: designRulesPlugin,
+    },
+    rules: {
+      ...sharedDesignRules,
+      'ekanos-design/forbid-elements': ['warn', { forbid: FORBIDDEN_ELEMENTS }],
+    },
+  },
+];

package/eslint.design-rules.mjs

@@ -0,0 +1,437 @@
+/**
+ * The design-system rules the shadcn linter does not cover — eight of them,
+ * as one lint plugin object. The rules and their reasoning live in the design system's
+ * rules; each message names the rule.
+ *
+ * ── Why this file sits in a published package ────────────────────────────
+ * Two consumers need the same eight rules and neither may fork them:
+ *
+ *   - the host repo's own lint, as an oxlint JS plugin. `.oxlintrc.json`
+ *     still loads this plugin through a
+ *     two-line re-export of this file, so the plugin name, the rule names
+ *     and their severities are untouched.
+ *   - a partner's own lint, as an ESLint plugin, through
+ *     `@ekanos/sdk/eslint/design` (`eslint.design-preset.mjs`, its sibling
+ *     here), which a scaffolded project wires up by default.
+ *
+ * The host's tooling is not published, so the import can only run this
+ * direction: the rules live in the package a partner installs and the host
+ * repo's tooling reaches in. The host's capability lint already reads its
+ * preset out of `eslint.preset.mjs` the same way, only for the plugin rather
+ * than the config.
+ *
+ * ── What it may depend on ────────────────────────────────────────────────
+ * Nothing. Every rule below is plain JS over the ESTree/JSX AST with
+ * `context.report`, no oxlint-only API and no import of any kind, which is
+ * what lets one implementation satisfy both linters. Keep it that way: a
+ * dependency here would either break oxlint's plugin loader or grow the
+ * SDK's install for a lint plugin.
+ */
+
+/**
+ * The AST these rules read, typed in JSDoc because `eslint.design-preset.mjs`
+ * imports this file and that pulls it into the package's TypeScript program.
+ * Deliberately loose: a lint rule is handed whatever the parser produced and
+ * narrows on `type` itself, so one node type stands in for several families
+ * and every field is optional.
+ *
+ * @typedef {{ type?: string, name?: string }} AstName
+ *
+ * @typedef {object} Expression
+ * @property {string} [type]
+ * @property {string | number | boolean | null} [value]
+ * @property {Expression} [expression]
+ * @property {Expression[]} [arguments]
+ * @property {TemplateChunk[]} [quasis]
+ * @property {Expression} [left]
+ * @property {Expression} [right]
+ * @property {Expression} [consequent]
+ * @property {Expression} [alternate]
+ *
+ * @typedef {{ value: { cooked?: string | null } }} TemplateChunk
+ * @typedef {{ value?: string | number | boolean | null }} StringLiteral
+ *
+ * @typedef {object} JsxAttribute
+ * @property {string} [type]
+ * @property {AstName} [name]
+ * @property {Expression | null} [value]
+ *
+ * @typedef {object} JsxElement
+ * @property {AstName} [name]
+ * @property {JsxAttribute[]} [attributes]
+ * @property {JsxElement} [openingElement]
+ * @property {JsxElement} [parent]
+ * @property {string} [type]
+ *
+ * @typedef {{ report: (descriptor: { node: unknown, message: string }) => void }} RuleContext
+ */
+
+const FADED_MUTED = /(?:^|[\s:'"`])(?:[\w-]+:)*text-muted-foreground\/\d+/;
+
+/** `bg-white`, `text-black/50`, `dark:border-white`… — @shadcn/lint's
+ *  no-raw-colors covers the palette scales but not these two. */
+const ABSOLUTE_COLOR =
+  /(?:^|[\s'"`])(?:[\w-]+:)*(?:bg|text|border|ring|outline|divide|fill|stroke|from|via|to|decoration|placeholder|caret|accent|shadow)-(?:white|black)(?:\/\d+)?(?=$|[\s'"`])/;
+
+/**
+ * Visits every string and template chunk, so class names in `cn()`, cva
+ * maps and plain constants are all checked, not only `className=`.
+ *
+ * @param {RegExp} test
+ * @param {string} message
+ */
+function stringVisitors(test, message) {
+  /** @param {RuleContext} context */
+  return (context) => {
+    /** @param {unknown} node @param {unknown} value */
+    const check = (node, value) => {
+      if (typeof value === 'string' && test.test(value)) {
+        context.report({ node, message });
+      }
+    };
+
+    return {
+      /** @param {StringLiteral} node */
+      Literal: (node) => check(node, node.value),
+      /** @param {TemplateChunk} node */
+      TemplateElement: (node) => check(node, node.value.cooked),
+    };
+  };
+}
+
+const BADGE_TONES = new Set(['success', 'warning', 'info']);
+
+const TONE_BADGE_MESSAGE =
+  'A tone is not a Badge variant. A record\u2019s state is <StatusBadge tone="…"> from @kit/ui/status-badge, whose dot carries the tone so meaning never rides on hue alone; Badge is for counts, categories and short labels (design-system status-badge rule).';
+
+/** @param {Expression | null | undefined} value */
+function literalValue(value) {
+  if (!value) return null;
+  if (value.type === 'Literal') return value.value;
+  if (
+    value.type === 'JSXExpressionContainer' &&
+    value.expression?.type === 'Literal'
+  ) {
+    return value.expression.value;
+  }
+  return null;
+}
+
+/** @param {AstName | undefined} name */
+function jsxName(name) {
+  return name?.type === 'JSXIdentifier' ? name.name : null;
+}
+
+const OVERLAY_CONTENT = new Set([
+  'DialogContent',
+  'SheetContent',
+  'AlertDialogContent',
+  'DrawerContent',
+]);
+
+/**
+ * `max-w-md`, `sm:w-[560px]`… but not the mobile-width `w-full` / `w-auto`.
+ *
+ * A variant prefix may itself contain brackets (`data-[swipe-direction=right]:`),
+ * so the prefix group has to allow them — `[\w-]+:` alone stopped at the `[`
+ * and let `data-[swipe-direction=right]:sm:max-w-xl` through on two drawer
+ * shells for as long as the rule has existed.
+ */
+const OVERLAY_WIDTH =
+  /(?:^|\s)(?:(?:[\w-]+|\[[^\]]*\]|[\w-]+\[[^\]]*\])+:)*(?:max-w|min-w|w)-(?!full\b|auto\b)\S+/;
+
+const OVERLAY_WIDTH_MESSAGE =
+  'Never set an overlay’s width in className. Dialog, Sheet and Drawer take size="sm|md|lg|xl|2xl|3xl|full" from @kit/ui/overlay-size; AlertDialog takes size="sm" (design-system overlay rule).';
+
+/**
+ * Every string literal in a className value, including inside `cn(...)`.
+ *
+ * @param {Expression | null | undefined} value
+ * @returns {StringLiteral[]}
+ */
+function classNameStrings(value) {
+  if (!value) return [];
+  if (value.type === 'Literal') return [value];
+  if (value.type === 'JSXExpressionContainer') {
+    return classNameStrings(value.expression);
+  }
+  if (value.type === 'CallExpression') {
+    return (value.arguments ?? []).flatMap(classNameStrings);
+  }
+  if (value.type === 'TemplateLiteral') {
+    return (value.quasis ?? []).map((quasi) => ({
+      ...quasi,
+      value: quasi.value.cooked,
+    }));
+  }
+  if (value.type === 'LogicalExpression' || value.type === 'BinaryExpression') {
+    return [...classNameStrings(value.left), ...classNameStrings(value.right)];
+  }
+  if (value.type === 'ConditionalExpression') {
+    return [
+      ...classNameStrings(value.consequent),
+      ...classNameStrings(value.alternate),
+    ];
+  }
+  return [];
+}
+
+/** A rounded hover band with side padding: a row drawn as a pill. Square
+ *  icon buttons (`size-8`, `h-6 w-6`) are a different shape and pass, and so
+ *  does a bordered or filled tile, which is a card rather than a row. */
+/** @param {string} value */
+function isRoundedRowHover(value) {
+  if (/(?:^|\s)border(?=$|\s)/.test(value) || /(?:^|\s)bg-/.test(value)) {
+    return false;
+  }
+
+  if (
+    !/\brounded-(?:md|lg|xl)\b/.test(value) ||
+    !/(?:^|\s)hover:bg-/.test(value) ||
+    !/(?:^|\s)(?:[\w-]+:)*px-/.test(value) ||
+    !/(?:^|\s)(?:w-full|justify-between)(?=$|\s)/.test(value)
+  ) {
+    return false;
+  }
+
+  if (/(?:^|\s)(?:[\w-]+:)*size-/.test(value)) return false;
+
+  const height = /(?:^|\s)h-([\w.[\]]+)(?=$|\s)/.exec(value);
+  const width = /(?:^|\s)w-([\w.[\]]+)(?=$|\s)/.exec(value);
+
+  return !(height && width && height[1] === width[1]);
+}
+
+const CHIP_TONES = ['success', 'primary', 'warning', 'destructive', 'info'];
+
+const CHIP_SMALL_TEXT = /(?:^|\s)(?:[\w-]+:)*text-(?:xs|sm)(?=$|\s)/;
+
+/** Base-tone small text on a tint of the same tone. */
+/** @param {string} value */
+function isWeakTintedChip(value) {
+  if (!CHIP_SMALL_TEXT.test(value)) return false;
+
+  return CHIP_TONES.some(
+    (tone) =>
+      new RegExp(`(?:^|\\s)(?:[\\w-]+:)*bg-${tone}/\\d+`).test(value) &&
+      new RegExp(`(?:^|\\s)(?:[\\w-]+:)*text-${tone}(?![\\w-])`).test(value),
+  );
+}
+
+/**
+ * @param {(value: string) => boolean} predicate
+ * @param {string} message
+ */
+function predicateVisitors(predicate, message) {
+  /** @param {RuleContext} context */
+  return (context) => {
+    /** @param {unknown} node @param {unknown} value */
+    const check = (node, value) => {
+      if (typeof value === 'string' && predicate(value)) {
+        context.report({ node, message });
+      }
+    };
+
+    return {
+      /** @param {StringLiteral} node */
+      Literal: (node) => check(node, node.value),
+      /** @param {TemplateChunk} node */
+      TemplateElement: (node) => check(node, node.value.cooked),
+    };
+  };
+}
+
+/**
+ * A viewport breakpoint variant anywhere in a class token's variant chain:
+ * `sm:grid-cols-2`, `hover:md:flex`, `max-lg:hidden`. Container variants
+ * (`@sm/widget:`) start with `@` and pass.
+ */
+const VIEWPORT_BREAKPOINT =
+  /(?:^|\s)(?:[\w-]+:)*(?:max-)?(?:sm|md|lg|xl|2xl):[^\s:]/;
+
+const TOOLBAR_TAB_ELEMENTS = new Set(['TabsList', 'ScopePills', 'ScopeLinks']);
+const TOOLBARS = new Set(['PageToolbar', 'PageToolbarActions']);
+
+export default {
+  meta: { name: 'design' },
+  rules: {
+    'no-tone-badge-variant': {
+      meta: {
+        type: 'problem',
+        docs: {
+          description:
+            'Disallow a status tone as a Badge variant; a record state is StatusBadge.',
+        },
+      },
+      /** @param {RuleContext} context */
+      create(context) {
+        return {
+          /** @param {JsxElement} node */
+          JSXOpeningElement(node) {
+            if (
+              node.name?.type !== 'JSXIdentifier' ||
+              node.name.name !== 'Badge'
+            ) {
+              return;
+            }
+
+            for (const attribute of node.attributes ?? []) {
+              if (
+                attribute.type !== 'JSXAttribute' ||
+                attribute.name?.name !== 'variant'
+              ) {
+                continue;
+              }
+
+              const value = literalValue(attribute.value);
+
+              if (typeof value === 'string' && BADGE_TONES.has(value)) {
+                context.report({
+                  node: attribute,
+                  message: TONE_BADGE_MESSAGE,
+                });
+              }
+            }
+          },
+        };
+      },
+    },
+    'no-faded-muted-text': {
+      meta: {
+        type: 'problem',
+        docs: {
+          description:
+            'Disallow an opacity modifier on text-muted-foreground; every step below 100 fails contrast somewhere.',
+        },
+      },
+      create: stringVisitors(
+        FADED_MUTED,
+        'Opacity on text-muted-foreground fails WCAG AA: even /90 measures 4.18:1 on a dark card. Use plain text-muted-foreground, a smaller size if it must recede, or text-border for a decorative separator (design-system opacity-on-muted rule).',
+      ),
+    },
+    'no-absolute-colors': {
+      meta: {
+        type: 'problem',
+        docs: {
+          description:
+            'Disallow white/black color utilities; they ignore the theme, dark mode and Source branding.',
+        },
+      },
+      create: stringVisitors(
+        ABSOLUTE_COLOR,
+        'white/black color utilities ignore the theme, dark mode and Source branding. Use a token: bg-card or bg-background for surfaces, text-foreground / text-primary-foreground for text. A modal scrim may stay black with a disable comment saying so (design-system theming rule).',
+      ),
+    },
+    'no-overlay-width-class': {
+      meta: {
+        type: 'problem',
+        docs: {
+          description:
+            'Disallow width classes on overlay content; overlays take a size from the overlay-size scale.',
+        },
+      },
+      /** @param {RuleContext} context */
+      create(context) {
+        return {
+          /** @param {JsxElement} node */
+          JSXOpeningElement(node) {
+            if (!OVERLAY_CONTENT.has(jsxName(node.name) ?? '')) return;
+
+            for (const attribute of node.attributes ?? []) {
+              if (
+                attribute.type !== 'JSXAttribute' ||
+                attribute.name?.name !== 'className'
+              ) {
+                continue;
+              }
+
+              const flagged = classNameStrings(attribute.value).some(
+                (literal) =>
+                  typeof literal.value === 'string' &&
+                  OVERLAY_WIDTH.test(literal.value),
+              );
+
+              if (flagged) {
+                context.report({
+                  node: attribute,
+                  message: OVERLAY_WIDTH_MESSAGE,
+                });
+              }
+            }
+          },
+        };
+      },
+    },
+    'no-rounded-row-hover': {
+      meta: {
+        type: 'problem',
+        docs: {
+          description:
+            'Disallow a rounded hover pill on a padded row; rows are flat edge-to-edge bands.',
+        },
+      },
+      create: predicateVisitors(
+        isRoundedRowHover,
+        'Rows are flat edge-to-edge bands: padding on the row (px-5 py-3), a flat hover:bg-accent/50, never a rounded pill with side padding (design-system edge-to-edge rows rule).',
+      ),
+    },
+    'tinted-chip-strong': {
+      meta: {
+        type: 'problem',
+        docs: {
+          description:
+            'Require the -strong text step for small text on a tint of its own colour.',
+        },
+      },
+      create: predicateVisitors(
+        isWeakTintedChip,
+        'Small text on a tint of its own colour takes the -strong step: text-success-strong on bg-success/10, text-primary-strong on bg-primary/10. The base token fails AA once it sits on its own wash; it stays right for the fill and for icons (design-system tinted-chip rule).',
+      ),
+    },
+    'no-viewport-breakpoints-in-widgets': {
+      meta: {
+        type: 'problem',
+        docs: {
+          description:
+            'Disallow viewport breakpoints in widget code; a widget sizes to its own container.',
+        },
+      },
+      create: stringVisitors(
+        VIEWPORT_BREAKPOINT,
+        'A widget sits in a half-width column, a full row or a tile, whatever the viewport, so sm:/md:/lg: misfire. Size to the card with container queries: Widget.Card is @container/widget, so write @sm/widget:grid-cols-2 (design-system widget rules).',
+      ),
+    },
+    'no-toolbar-tabs': {
+      meta: {
+        type: 'problem',
+        docs: {
+          description: 'Disallow tabs or scope pills inside a PageToolbar.',
+        },
+      },
+      /** @param {RuleContext} context */
+      create(context) {
+        return {
+          /** @param {JsxElement} node */
+          JSXOpeningElement(node) {
+            if (!TOOLBAR_TAB_ELEMENTS.has(jsxName(node.name) ?? '')) return;
+
+            for (let parent = node.parent; parent; parent = parent.parent) {
+              if (
+                parent.type === 'JSXElement' &&
+                parent !== node.parent &&
+                TOOLBARS.has(jsxName(parent.openingElement?.name) ?? '')
+              ) {
+                context.report({
+                  node,
+                  message:
+                    'No tabs inside a PageToolbar. View tabs go in PageTitleSection’s `tabs` prop; a filter over one list goes in that card’s ListMasthead (page-layout view-tabs rule).',
+                });
+                return;
+              }
+            }
+          },
+        };
+      },
+    },
+  },
+};