@atlaskit/eslint-plugin-platform 2.9.1 → 2.9.3

package/dist/es2019/rules/editor-example-type-import-required/index.js

@@ -0,0 +1,286 @@
+import fs from 'fs';
+import path from 'path';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+export const RULE_NAME = 'editor-example-type-import-required';
+
+/**
+ * Spec files that are excluded from this rule because they don't use visitExample
+ * or have their own test harness that doesn't follow the exampleName fixture pattern.
+ *
+ * Paths are matched as suffixes of the file path (platform-relative).
+ */
+const EXCLUDED_SPEC_FILES = [
+// Meta-tests for the testing infrastructure itself
+'build/test-tooling/integration-testing/src/examples/__tests__/playwright/example.spec.ts', 'build/test-tooling/integration-testing/src/matchers/__tests__/playwright/to-have-height.spec.ts', 'build/test-tooling/integration-testing/src/matchers/__tests__/playwright/to-have-width.spec.ts',
+// Tests the a11y decorator itself, no visitExample
+'packages/accessibility/axe-integration/a11y-playwright-testing/src/auto-a11y-setup/__tests__/playwright/skip-decorator.spec.ts',
+// Stub test (expect(true).toBe(true)), no visitExample
+'packages/ai-mate/rovo-content-bridge-api/__tests__/playwright/index.spec.tsx',
+// Page-object's visitExample call carries the typeof import(...) generic,
+// so the typed example reference lives in _helpers/page-object.ts rather
+// than in test.use({ exampleName }) in the spec itself.
+'packages/navigation/atlassian-switcher/src/__tests__/playwright/navigate-child-item.spec.ts', 'packages/navigation/atlassian-switcher/src/__tests__/playwright/navigate-link-item.spec.ts', 'packages/navigation/atlassian-switcher/src/__tests__/playwright/navigate-product-item.spec.ts',
+// Spec runs through a page-object (pages/generic-form-renderer.ts) whose
+// visitExample call already carries the typeof import(...) generic. The
+// typed reference therefore lives in the colocated page-object, not in
+// test.use({ exampleName }) in the spec.
+'packages/proforma/proforma-common-core/__tests__/playwright/json-test-cases.spec.ts', 'packages/proforma/proforma-form-renderer/__tests__/playwright/json-test-cases.spec.ts',
+// Spec runs through a page-object that still uses raw page.goto() against
+// /examples.html. Migrating these requires reworking the page-object to
+// route through visitExample<typeof import(...)>(...).
+'packages/proforma/proforma-form-list/__tests__/playwright/form-list.spec.ts', 'packages/proforma/proforma-form-renderer/__tests__/playwright/form-renderer.spec.ts', 'packages/proforma/proforma-translations-editor/__tests__/playwright/translations-editor-with-form.spec.ts',
+// Tests the website itself, not examples
+'website/src/__tests__/playwright/examples.spec.ts', 'website/src/__tests__/playwright/home.spec.ts',
+// react-ufo: uses an `examplePage: string` fixture where the name (e.g. 'basic') is
+// resolved to the example file internally by visitExample — the name does not match
+// the file name (e.g. '01-basic.tsx'), so a typeof import assertion is not possible
+// without refactoring the fixture to use keyof typeof import directly. Specs that
+// happen to also use the inline `visitExample<typeof import(...)>` pattern alongside
+// the fixture pass via the file-level typeof import check above and don't appear here.
+'packages/react-ufo/atlaskit/__tests__/playwright/apply-segments-threshold.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/bad-replacement-node.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/base-10-sections.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/base-100-sections.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/base-3-sections-ssr-timings.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/base-3-sections-unmount.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/css-display-contents.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/custom-cohort-data.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/custom-data.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/data-vc-ignore-if-no-layout-shift.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/full-pixel-horizontal.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/full-pixel.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/fy25_02.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/hold.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/interactions-responsiveness.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/interactions-unknown-element.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/interactions-vc.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/is-opened-in-background.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/is-tab-throttled.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/metric-variants.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/minor-interactions.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/non-visual-style.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/page-visibility-hidden-timestamp.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/payload-integrity.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/post-interaction-late-holds.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/post-interaction-log-always-send.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/replacement-node.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/revisions.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/same-attribute-value-mutation.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/speed-index.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/ssr-placeholder-v3.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/terminal-error.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/third-party-segment-extra-metrics.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/third-party-segment-iframe.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/third-party-segment-timings.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/third-party-segment.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/transition-vc.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/ttai.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/ufo-blindspot-watchdog.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/ufo-errors.spec.ts', 'packages/react-ufo/atlaskit/__tests__/playwright/vc-dirty.spec.ts',
+// editor-performance-metrics: same pattern as react-ufo — uses an `examplePage: string` fixture
+// where the name resolves internally and does not match the example file name.
+'packages/editor/editor-performance-metrics/__tests__/playwright/basic-editor-ttai.spec.ts', 'packages/editor/editor-performance-metrics/__tests__/playwright/basic-react-app.spec.ts', 'packages/editor/editor-performance-metrics/__tests__/playwright/latency-track.spec.ts', 'packages/editor/editor-performance-metrics/__tests__/playwright/ttai-timers.spec.ts', 'packages/editor/editor-performance-metrics/__tests__/playwright/vc-next-attribute-change.spec.ts', 'packages/editor/editor-performance-metrics/__tests__/playwright/vc-next-element-moving.spec.ts', 'packages/editor/editor-performance-metrics/__tests__/playwright/vc-next-moving-node.spec.ts', 'packages/editor/editor-performance-metrics/__tests__/playwright/vc-next-placeholder.spec.ts', 'packages/editor/editor-performance-metrics/__tests__/playwright/vc-next-react-remounting.spec.ts', 'packages/editor/editor-performance-metrics/__tests__/playwright/vc-next-track-user-events.spec.ts', 'packages/editor/editor-performance-metrics/__tests__/playwright/vc-next.spec.ts',
+// generative-ai-modal: the example name is passed dynamically at examplePage.goto({ example: '...' })
+// time rather than via test.use(), so a static typeof import assertion in the spec is not possible.
+'packages/editor/generative-ai-modal/src/ui/screens/Preview/__tests__/playwright/tab-navigation.spec.ts'];
+function isExcluded(filename) {
+  const normalised = filename.replace(/\\/g, '/');
+  return EXCLUDED_SPEC_FILES.some(excluded => normalised.endsWith(excluded));
+}
+const messages = {
+  missingExampleName: 'Playwright spec files must include exampleName with a ' + 'typeof import type assertion in test.use(). ' + "Add: exampleName: 'testing' as keyof typeof import('../../../examples/testing.tsx') ",
+  missingTypeAssertion: 'exampleName must include a typeof import type assertion for the static import graph. ' + "Use: exampleName: '{{ value }}' as keyof typeof import('{{ expectedPath }}') ",
+  pathMismatch: 'The import path "{{ importPath }}" does not resolve to the expected example file ' + "for exampleName '{{ exampleName }}'. Expected: {{ expectedPath }}"
+};
+function isTargetFile(filename) {
+  return (filename.endsWith('.spec.tsx') || filename.endsWith('.spec.ts')) && !isExcluded(filename);
+}
+
+/**
+ * Resolves the example file path from the spec file's location and the example name.
+ * Editor specs follow: packages/{groupId}/{packageId}/src/__tests__/playwright/*.spec.ts
+ * Examples live at:    packages/{groupId}/{packageId}/examples/{exampleName}.tsx
+ */
+function resolveExamplePath(testFilePath, exampleName) {
+  const testFileDir = path.dirname(testFilePath);
+  const segments = testFileDir.split(path.sep);
+  const packagesIndex = segments.findIndex(seg => seg === 'packages');
+  if (packagesIndex === -1) {
+    return null;
+  }
+  const groupId = segments[packagesIndex + 1];
+  const packageId = segments[packagesIndex + 2];
+  if (!groupId || !packageId) {
+    return null;
+  }
+  const basePath = path.isAbsolute(testFilePath) ? path.resolve('/', ...segments.slice(0, packagesIndex + 1)) : path.resolve(process.cwd(), ...segments.slice(0, packagesIndex + 1));
+  const examplesDir = path.resolve(basePath, groupId, packageId, 'examples');
+  const candidateRe = new RegExp(`^(?:\\d+-)?${exampleName}(?:\\.examples?)?\\.tsx$`);
+  try {
+    const match = fs.readdirSync(examplesDir).find(f => candidateRe.test(f));
+    if (match) {
+      return path.resolve(examplesDir, match);
+    }
+  } catch {
+    // Directory doesn't exist (e.g. test environments)
+  }
+  return path.resolve(examplesDir, `${exampleName}.tsx`);
+}
+function computeRelativeImportPath(fromFile, toFile) {
+  const fromDir = path.dirname(fromFile);
+  let relativePath = path.relative(fromDir, toFile);
+  relativePath = relativePath.replace(/\\/g, '/');
+  if (!relativePath.startsWith('.') && !relativePath.startsWith('/')) {
+    relativePath = `./${relativePath}`;
+  }
+  return relativePath;
+}
+
+/**
+ * Check if a property value has a `keyof typeof import(...)` type assertion.
+ * Handles both:
+ *   'name' as keyof typeof import('...')
+ */
+function extractTypeofImportPath(node) {
+  if (node.type !== AST_NODE_TYPES.TSAsExpression) {
+    return null;
+  }
+  const typeAnnotation = node.typeAnnotation;
+  if (typeAnnotation.type === AST_NODE_TYPES.TSTypeOperator && typeAnnotation.operator === 'keyof') {
+    return extractFromTypeQuery(typeAnnotation.typeAnnotation);
+  }
+  if (typeAnnotation.type === AST_NODE_TYPES.TSUnionType) {
+    for (const member of typeAnnotation.types) {
+      if (member.type === AST_NODE_TYPES.TSTypeOperator && member.operator === 'keyof') {
+        const result = extractFromTypeQuery(member.typeAnnotation);
+        if (result) {
+          return result;
+        }
+      }
+    }
+  }
+  return null;
+}
+function extractFromTypeQuery(node) {
+  if (!node || node.type !== AST_NODE_TYPES.TSTypeQuery) {
+    return null;
+  }
+  const {
+    exprName
+  } = node;
+  if (exprName.type !== AST_NODE_TYPES.TSImportType) {
+    return null;
+  }
+  const {
+    argument
+  } = exprName;
+  if (argument.type === AST_NODE_TYPES.TSLiteralType && argument.literal.type === AST_NODE_TYPES.Literal && typeof argument.literal.value === 'string') {
+    return argument.literal.value;
+  }
+  return null;
+}
+
+/**
+ * Extract the string value from a property value, ignoring type assertions.
+ */
+function getStringValue(node) {
+  if (node.type === AST_NODE_TYPES.Literal && typeof node.value === 'string') {
+    return node.value;
+  }
+  if (node.type === AST_NODE_TYPES.TSAsExpression) {
+    return getStringValue(node.expression);
+  }
+  return null;
+}
+const rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Ensures that editor spec files using @af/editor-libra include exampleName with a ' + 'typeof import type assertion in test.use() for the static import graph (factsMap).'
+    },
+    fixable: 'code',
+    messages,
+    schema: []
+  },
+  create(context) {
+    const filename = context.filename;
+    if (!isTargetFile(filename)) {
+      return {};
+    }
+    return {
+      'Program:exit'(estreeNode) {
+        const program = estreeNode;
+
+        // Single AST walk: collect all test.use() calls AND detect whether the
+        // file contains any `typeof import('...')` reference at all (a TSImportType
+        // node). Either signal is sufficient evidence that the spec ties at least
+        // one example file into its TypeScript import graph.
+        const testUseCalls = [];
+        let hasAnyTypeofImport = false;
+        const visited = new Set();
+        const queue = [program];
+        while (queue.length > 0) {
+          const node = queue.shift();
+          if (visited.has(node)) {
+            continue;
+          }
+          visited.add(node);
+          if (node.type === AST_NODE_TYPES.CallExpression && node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === 'use' && node.arguments.length > 0 && node.arguments[0].type === AST_NODE_TYPES.ObjectExpression) {
+            testUseCalls.push(node);
+          }
+          if (node.type === AST_NODE_TYPES.TSImportType) {
+            hasAnyTypeofImport = true;
+          }
+          for (const key of Object.keys(node)) {
+            if (key === 'parent') {
+              continue;
+            }
+            const child = node[key];
+            if (Array.isArray(child)) {
+              for (const item of child) {
+                if (item && typeof item.type === 'string') {
+                  queue.push(item);
+                }
+              }
+            } else if (child && typeof child.type === 'string') {
+              queue.push(child);
+            }
+          }
+        }
+
+        // Any `typeof import('...')` anywhere in the spec — including the
+        // `page.visitExample<typeof import('...')>(...)` and
+        // `page.visitMockedExample<typeof import('...')>(...)` patterns used
+        // outside of test.use() — satisfies the same goal as the canonical
+        // `test.use({ exampleName: '...' as keyof typeof import('...') })`
+        // pattern: the example file is referenced from the spec's TypeScript
+        // import graph.
+        if (hasAnyTypeofImport) {
+          return;
+        }
+
+        // Check if any test.use() call anywhere in the file has exampleName with a typeof import assertion
+        const fileHasExampleName = testUseCalls.some(call => {
+          const obj = call.arguments[0];
+          return obj.properties.some(prop => {
+            if (prop.type !== AST_NODE_TYPES.Property || prop.key.type !== AST_NODE_TYPES.Identifier || prop.key.name !== 'exampleName') {
+              return false;
+            }
+            return extractTypeofImportPath(prop.value) !== null;
+          });
+        });
+        if (fileHasExampleName) {
+          return;
+        }
+
+        // Find the first test.use() call that has exampleName without the typeof import assertion
+        // (if any), otherwise use the first test.use() call
+        let targetCall = testUseCalls[0];
+        let existingExampleNameProp = null;
+        for (const call of testUseCalls) {
+          const obj = call.arguments[0];
+          const prop = obj.properties.find(p => p.type === AST_NODE_TYPES.Property && p.key.type === AST_NODE_TYPES.Identifier && p.key.name === 'exampleName');
+          if (prop) {
+            targetCall = call;
+            existingExampleNameProp = prop;
+            break;
+          }
+        }
+        if (!targetCall) {
+          return;
+        }
+        const objectArg = targetCall.arguments[0];
+
+        // Determine the example name to use for the import path
+        const exampleNameValue = existingExampleNameProp ? getStringValue(existingExampleNameProp.value) : null;
+        const defaultName = exampleNameValue !== null && exampleNameValue !== void 0 ? exampleNameValue : 'testing';
+        const examplePath = resolveExamplePath(filename, defaultName);
+        if (!examplePath) {
+          return;
+        }
+        const importPath = computeRelativeImportPath(filename, examplePath);
+        context.report({
+          node: targetCall,
+          messageId: 'missingExampleName',
+          fix(fixer) {
+            // If exampleName exists but lacks typeof import, replace its value
+            if (existingExampleNameProp) {
+              return fixer.replaceText(existingExampleNameProp.value, `'${defaultName}' as keyof typeof import('${importPath}') `);
+            }
+            // Otherwise insert exampleName as the first property
+            const firstProp = objectArg.properties[0];
+            if (!firstProp) {
+              return fixer.replaceText(targetCall.arguments[0], `{\n\texampleName: '${defaultName}' as keyof typeof import('${importPath}'),\n}`);
+            }
+            const sourceCode = context.sourceCode;
+            const token = sourceCode.getFirstToken(firstProp);
+            const indent = token ? '\t'.repeat(token.loc.start.column) : '\t';
+            return fixer.insertTextBefore(firstProp, `exampleName: '${defaultName}' as keyof typeof import('${importPath}') ,\n${indent}`);
+          }
+        });
+      }
+    };
+  }
+};
+export default rule;

package/dist/es2019/rules/no-xcss-in-cx/index.js

@@ -0,0 +1,187 @@
+import { getImportSources, isCxFunction, isXcss } from '@atlaskit/eslint-utils/is-supported-import';
+import { getScope } from '../util/context-compat';
+
+/**
+ * Disallows passing xcss() results into cx() when used in an xcss prop.
+ *
+ * xcss() from @atlaskit/primitives and cx() from @atlaskit/css / @compiled/react
+ * are incompatible — xcss() produces an opaque StyleRule object, while cx()
+ * expects Compiled atomic class name strings. Mixing them causes runtime errors.
+ * xcss() results must never be passed to cx(), whether inline or pre-defined.
+ *
+ * ❌ Wrong — xcss() called inline inside cx():
+ *   xcss={cx(xcss({ color: 'red' }), xcss({ fontWeight: 'bold' }))}
+ *
+ * ❌ Also wrong — xcss() results pre-defined but still passed into cx():
+ *   const baseStyles = xcss({ color: 'red' });
+ *   const boldStyles = xcss({ fontWeight: 'bold' });
+ *   xcss={cx(baseStyles, boldStyles)}
+ *
+ * ✅ Correct — pass xcss() results directly to the xcss prop (no cx()):
+ *   const baseStyles = xcss({ color: 'red' });
+ *   xcss={baseStyles}
+ *
+ * ✅ Correct — use cssMap() + cx() (cssMap is compatible with cx()):
+ *   const styles = cssMap({ base: { color: 'red' } });
+ *   xcss={cx(styles.base, condition && styles.focused)}
+ *
+ * This rule is import-aware: it only flags xcss() calls (inline or via variable)
+ * imported from @atlaskit/primitives inside cx() calls imported from @atlaskit/css
+ * or @compiled/react that appear inside an xcss prop.
+ */
+const rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow calling xcss() inline inside cx() in an xcss prop. Define styles at module level instead.'
+    },
+    messages: {
+      noXcssInCx: 'Do not pass xcss() results into cx(). ' + 'xcss() produces a StyleRule object that is incompatible with cx(), which expects Compiled atomic class names. ' + 'Pass xcss() results directly to the xcss prop instead: xcss={myStyles}. ' + 'To conditionally combine styles, use cssMap() + cx(): const styles = cssMap({...}); xcss={cx(styles.base, cond && styles.active)}'
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      JSXAttribute(node) {
+        // Narrow Rule.Node to JSXAttribute (estree-jsx augments the `estree` Node
+        // union with JSX members, so this discriminated narrowing is safe).
+        if (node.type !== 'JSXAttribute') {
+          return;
+        }
+
+        // Only check `xcss` props
+        if (node.name.type !== 'JSXIdentifier' || node.name.name !== 'xcss') {
+          return;
+        }
+        if (!node.value || node.value.type !== 'JSXExpressionContainer') {
+          return;
+        }
+        const expression = node.value.expression;
+        if (expression.type === 'JSXEmptyExpression') {
+          return;
+        }
+
+        // Early-return if the expression cannot possibly contain a cx() call —
+        // avoids the cost of getImportSources/getScope on simple references like xcss={baseStyles}.
+        const isCallOrArray = expression.type === 'CallExpression' || expression.type === 'ArrayExpression';
+        if (!isCallOrArray) {
+          return;
+        }
+        const importSources = getImportSources(context);
+        const {
+          references
+        } = getScope(context, node);
+
+        /**
+         * Returns true if an Identifier node resolves to a variable whose
+         * initializer is a call to xcss() imported from @atlaskit/primitives.
+         *
+         * Walks up the scope chain from the current JSXAttribute scope to find
+         * the variable definition, since module-level variables are not in the
+         * local scope's references list.
+         *
+         * e.g. `const baseStyles = xcss({ color: 'red' })` — passing `baseStyles`
+         * here returns true.
+         */
+        const isXcssVariable = identNode => {
+          if (identNode.type !== 'Identifier') {
+            return false;
+          }
+          const name = identNode.name;
+          // Walk up the scope chain to find the variable definition
+          let currentScope = getScope(context, node);
+          while (currentScope) {
+            const variable = currentScope.set.get(name);
+            if (variable) {
+              for (const def of variable.defs) {
+                var _def$node$init;
+                if (def.type === 'Variable' && def.node.type === 'VariableDeclarator' && ((_def$node$init = def.node.init) === null || _def$node$init === void 0 ? void 0 : _def$node$init.type) === 'CallExpression') {
+                  // isXcss checks the callee identifier against referencesInScope to
+                  // find the import binding. The callee lives in the same scope as the
+                  // variable definition, so use all references from that scope.
+                  const defScopeRefs = currentScope.references;
+                  if (isXcss(def.node.init.callee, defScopeRefs, importSources)) {
+                    return true;
+                  }
+                }
+              }
+              // Found the variable but it's not an xcss() call
+              return false;
+            }
+            currentScope = currentScope.upper;
+          }
+          return false;
+        };
+
+        /**
+         * Recursively check a node that is an argument to cx() for xcss() results —
+         * both inline calls and references to variables initialised with xcss().
+         * Recurses into LogicalExpression (&&, ||) and ConditionalExpression (? :) so that
+         * patterns like cx(cond && xcss({...})) and cx(cond ? baseStyles : a) are caught.
+         */
+        const checkArgForXcss = argNode => {
+          if (!argNode) {
+            return;
+          }
+          // Inline: cx(xcss({ color: 'red' }))
+          if (argNode.type === 'CallExpression' && isXcss(argNode.callee, references, importSources)) {
+            context.report({
+              node: argNode,
+              messageId: 'noXcssInCx'
+            });
+            return;
+          }
+          // Variable reference: cx(baseStyles) where baseStyles = xcss({...})
+          if (isXcssVariable(argNode)) {
+            context.report({
+              node: argNode,
+              messageId: 'noXcssInCx'
+            });
+            return;
+          }
+          // Recurse into `cond && xcss({...})` or `cond || xcss({...})`
+          if (argNode.type === 'LogicalExpression') {
+            checkArgForXcss(argNode.left);
+            checkArgForXcss(argNode.right);
+          }
+          // Recurse into `cond ? xcss({...}) : fallback`
+          if (argNode.type === 'ConditionalExpression') {
+            checkArgForXcss(argNode.consequent);
+            checkArgForXcss(argNode.alternate);
+          }
+        };
+
+        /**
+         * Check all arguments of a cx() call for inline xcss() calls.
+         * Reports each xcss() call found as a violation.
+         */
+        const checkCxArgs = callNode => {
+          if (callNode.type !== 'CallExpression') {
+            return;
+          }
+          if (!isCxFunction(callNode.callee, references, importSources)) {
+            return;
+          }
+          for (const arg of callNode.arguments) {
+            if (arg) {
+              checkArgForXcss(arg.type === 'SpreadElement' ? arg.argument : arg);
+            }
+          }
+        };
+
+        // Case 1: xcss={cx(...)} — cx() directly as the xcss value
+        checkCxArgs(expression);
+
+        // Case 2: xcss={[..., cx(...), ...]} — cx() inside an xcss array
+        if (expression.type === 'ArrayExpression') {
+          for (const element of expression.elements) {
+            if (element) {
+              checkCxArgs(element.type === 'SpreadElement' ? element.argument : element);
+            }
+          }
+        }
+      }
+    };
+  }
+};
+export default rule;

package/dist/es2019/rules/visit-example-type-import-required/index.js

@@ -91,8 +91,8 @@ function resolveVariableToConstant(programBody, variableName, cache) {
  * Each argument may be a string literal or a reference to a top-level const string variable.
  * Returns null for any argument that can't be statically resolved.
  */
-function extractCallArgs(node, programBody, variableCache) {
-  if (node.arguments.length < 3) {
+function extractCallArgs(node, programBody, variableCache, argOffset = 0) {
+  if (node.arguments.length < argOffset + 3) {
     return null;
   }
   function resolveArg(arg) {
@@ -104,9 +104,9 @@ function extractCallArgs(node, programBody, variableCache) {
     }
     return null;
   }
-  const groupId = resolveArg(node.arguments[0]);
-  const packageId = resolveArg(node.arguments[1]);
-  const exampleId = resolveArg(node.arguments[2]);
+  const groupId = resolveArg(node.arguments[argOffset]);
+  const packageId = resolveArg(node.arguments[argOffset + 1]);
+  const exampleId = resolveArg(node.arguments[argOffset + 2]);
   if (!groupId || !packageId || !exampleId) {
     return null;
   }
@@ -152,8 +152,13 @@ function resolveExamplePathFromArgs(groupId, packageId, exampleId, testFilePath)
   const examplesDir = path.resolve(packagesBase.basePath, groupId, packageId, 'examples');
   const fallback = path.resolve(examplesDir, `${exampleId}.tsx`);
 
-  // Match: exact name OR numeric-prefixed variant, with optional `.examples` infix
-  const candidateRe = new RegExp(`^(?:\\d+-)?${exampleId}(?:\\.examples?)?\\.tsx$`);
+  // Phase 4: loosen candidateRe to match both pre- and post-rename filename shapes.
+  // Pre-rename:  ^(\d+-)?<id>(\.(examples?))?\.tsx$
+  // Post-rename: ^(\d+-)?<id>(\.<ident>){0,3}\.tsx$   (Volt prefix, optional .dup<N>, optional role)
+  // The {0,3} cap prevents matching arbitrary strings (e.g. 4-component names).
+  // Escape regex metacharacters in exampleId (ids are kebab-case today, but defensive).
+  const escapedId = exampleId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const candidateRe = new RegExp(`^(?:\\d+-)?${escapedId}(?:\\.[A-Za-z][A-Za-z0-9_]*){0,3}\\.tsx$`);
   try {
     const match = fs.readdirSync(examplesDir).find(f => candidateRe.test(f));
     if (match) {
@@ -248,20 +253,24 @@ const rule = {
           return;
         }
         const node = estreeNode;
-        // Only handle `<anything>.visitExample(...)` calls
-        if (node.callee.type !== AST_NODE_TYPES.MemberExpression || node.callee.property.type !== AST_NODE_TYPES.Identifier || node.callee.property.name !== 'visitExample') {
+        let calleeIdentifier = null;
+        let argOffset = 0;
+        if (node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === 'visitExample') {
+          calleeIdentifier = node.callee.property;
+        } else if (node.callee.type === AST_NODE_TYPES.Identifier && node.callee.name === 'visitMockedExample') {
+          calleeIdentifier = node.callee;
+          argOffset = 1; // first arg is `page`
+        } else {
           return;
         }
 
-        // Narrow callee — we've confirmed property is an Identifier above
-        const callee = node.callee;
         // reportCallee is typed as estree.Node for context.report compatibility
         const reportCallee = estreeNode.callee;
         const genericType = extractGenericType(node);
 
         // ── Case 1: No generic type parameter ────────────────────────────────
         if (genericType === null) {
-          const args = extractCallArgs(node, programBody, variableCache);
+          const args = extractCallArgs(node, programBody, variableCache, argOffset);
           context.report({
             node: reportCallee,
             messageId: 'missingTypeofImport',
@@ -274,7 +283,7 @@ const rule = {
                 return null;
               }
               const importPath = computeRelativeImportPath(filename, examplePath);
-              const [start, end] = callee.property.range;
+              const [start, end] = calleeIdentifier.range;
               return fixer.insertTextAfterRange([start, end], `<typeof import('${importPath}')>`);
             }
           });
@@ -333,7 +342,7 @@ const rule = {
         }
 
         // Validate that the import path matches the arguments
-        const args = extractCallArgs(node, programBody, variableCache);
+        const args = extractCallArgs(node, programBody, variableCache, argOffset);
         if (!args) {
           // Dynamic arguments — can't validate statically
           return;

package/dist/esm/index.js

@@ -28,6 +28,9 @@ import useRecommendedUtils from './rules/feature-gating/use-recommended-utils';
 import validGateName from './rules/feature-gating/valid-gate-name';
 import expandBackgroundShorthand from './rules/compiled/expand-background-shorthand';
 import expandSpacingShorthand from './rules/compiled/expand-spacing-shorthand';
+import noCssPropInObjectSpread from './rules/compiled/no-css-prop-in-object-spread';
+import useMotionTokenValues from './rules/compiled/use-motion-token-values';
+import expandMotionShorthand from './rules/compiled/expand-motion-shorthand';
 import noSparseCheckout from './rules/no-sparse-checkout';
 import noDirectDocumentUsage from './rules/no-direct-document-usage';
 import noSetImmediate from './rules/no-set-immediate';
@@ -39,7 +42,9 @@ import noJestMockBarrelFiles from './rules/import/no-jest-mock-barrel-files';
 import noRelativeBarrelFileImports from './rules/import/no-relative-barrel-file-imports';
 import noConversationAssistantBarrelImports from './rules/import/no-conversation-assistant-barrel-imports';
 import visitExampleTypeImportRequired from './rules/visit-example-type-import-required';
+import editorExampleTypeImportRequired from './rules/editor-example-type-import-required';
 import ensureUseSyncExternalStoreServerSnapshot from './rules/ensure-use-sync-external-store-server-snapshot';
+import noXcssInCx from './rules/no-xcss-in-cx';
 import { join, normalize } from 'node:path';
 import { readFileSync } from 'node:fs';
 var jiraRoot;
@@ -70,6 +75,7 @@ var rules = {
   'expand-border-shorthand': expandBorderShorthand,
   'expand-background-shorthand': expandBackgroundShorthand,
   'expand-spacing-shorthand': expandSpacingShorthand,
+  'no-css-prop-in-object-spread': noCssPropInObjectSpread,
   'no-duplicate-dependencies': noDuplicateDependencies,
   'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
   'no-pre-post-install-scripts': noPreAndPostInstallScripts,
@@ -96,7 +102,11 @@ var rules = {
   'no-relative-barrel-file-imports': noRelativeBarrelFileImports,
   'no-conversation-assistant-barrel-imports': noConversationAssistantBarrelImports,
   'visit-example-type-import-required': visitExampleTypeImportRequired,
-  'ensure-use-sync-external-store-server-snapshot': ensureUseSyncExternalStoreServerSnapshot
+  'no-xcss-in-cx': noXcssInCx,
+  'editor-example-type-import-required': editorExampleTypeImportRequired,
+  'ensure-use-sync-external-store-server-snapshot': ensureUseSyncExternalStoreServerSnapshot,
+  'use-motion-token-values': useMotionTokenValues,
+  'expand-motion-shorthand': expandMotionShorthand
 };
 var commonConfig = {
   '@atlaskit/platform/ensure-test-runner-arguments': 'error',
@@ -108,10 +118,14 @@ var commonConfig = {
   '@atlaskit/platform/no-module-level-eval-nav4': 'error',
   '@atlaskit/platform/no-direct-document-usage': 'warn',
   '@atlaskit/platform/no-set-immediate': 'error',
+  '@atlaskit/platform/no-xcss-in-cx': 'error',
   // Compiled: rules that are not included via `@compiled/recommended
   '@atlaskit/platform/expand-border-shorthand': 'error',
   '@atlaskit/platform/expand-background-shorthand': 'error',
   '@atlaskit/platform/expand-spacing-shorthand': 'error',
+  '@atlaskit/platform/no-css-prop-in-object-spread': 'error',
+  '@atlaskit/platform/use-motion-token-values': 'warn',
+  '@atlaskit/platform/expand-motion-shorthand': 'warn',
   '@compiled/jsx-pragma': ['error', {
     importSources: ['@atlaskit/css'],
     onlyRunIfImportingCompiled: true,
@@ -153,7 +167,6 @@ var plugin = {
         get '@atlaskit/platform'() {
           return plugin;
         },
-        // @ts-expect-error there's an issue with the types for @compiled/eslint-plugin ('no-css-prop-without-css-function' specifically)
         '@compiled': {
           meta: compiledPlugin.meta,
           rules: compiledPlugin.rules
@@ -170,7 +183,6 @@ var plugin = {
         get '@atlaskit/platform'() {
           return plugin;
         },
-        // @ts-expect-error there's an issue with the types for @compiled/eslint-plugin ('no-css-prop-without-css-function' specifically)
         '@compiled': {
           meta: compiledPlugin.meta,
           rules: compiledPlugin.rules