@atlaskit/eslint-plugin-platform 2.9.2 → 2.9.3

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

@@ -0,0 +1,321 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.RULE_NAME = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _utils = require("@typescript-eslint/utils");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var RULE_NAME = exports.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).
+ */
+var 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) {
+  var normalised = filename.replace(/\\/g, '/');
+  return EXCLUDED_SPEC_FILES.some(function (excluded) {
+    return normalised.endsWith(excluded);
+  });
+}
+var 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) {
+  var testFileDir = _path.default.dirname(testFilePath);
+  var segments = testFileDir.split(_path.default.sep);
+  var packagesIndex = segments.findIndex(function (seg) {
+    return seg === 'packages';
+  });
+  if (packagesIndex === -1) {
+    return null;
+  }
+  var groupId = segments[packagesIndex + 1];
+  var packageId = segments[packagesIndex + 2];
+  if (!groupId || !packageId) {
+    return null;
+  }
+  var basePath = _path.default.isAbsolute(testFilePath) ? _path.default.resolve.apply(_path.default, ['/'].concat((0, _toConsumableArray2.default)(segments.slice(0, packagesIndex + 1)))) : _path.default.resolve.apply(_path.default, [process.cwd()].concat((0, _toConsumableArray2.default)(segments.slice(0, packagesIndex + 1))));
+  var examplesDir = _path.default.resolve(basePath, groupId, packageId, 'examples');
+  var candidateRe = new RegExp("^(?:\\d+-)?".concat(exampleName, "(?:\\.examples?)?\\.tsx$"));
+  try {
+    var match = _fs.default.readdirSync(examplesDir).find(function (f) {
+      return candidateRe.test(f);
+    });
+    if (match) {
+      return _path.default.resolve(examplesDir, match);
+    }
+  } catch (_unused) {
+    // Directory doesn't exist (e.g. test environments)
+  }
+  return _path.default.resolve(examplesDir, "".concat(exampleName, ".tsx"));
+}
+function computeRelativeImportPath(fromFile, toFile) {
+  var fromDir = _path.default.dirname(fromFile);
+  var relativePath = _path.default.relative(fromDir, toFile);
+  relativePath = relativePath.replace(/\\/g, '/');
+  if (!relativePath.startsWith('.') && !relativePath.startsWith('/')) {
+    relativePath = "./".concat(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 !== _utils.AST_NODE_TYPES.TSAsExpression) {
+    return null;
+  }
+  var typeAnnotation = node.typeAnnotation;
+  if (typeAnnotation.type === _utils.AST_NODE_TYPES.TSTypeOperator && typeAnnotation.operator === 'keyof') {
+    return extractFromTypeQuery(typeAnnotation.typeAnnotation);
+  }
+  if (typeAnnotation.type === _utils.AST_NODE_TYPES.TSUnionType) {
+    var _iterator = _createForOfIteratorHelper(typeAnnotation.types),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var member = _step.value;
+        if (member.type === _utils.AST_NODE_TYPES.TSTypeOperator && member.operator === 'keyof') {
+          var result = extractFromTypeQuery(member.typeAnnotation);
+          if (result) {
+            return result;
+          }
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  return null;
+}
+function extractFromTypeQuery(node) {
+  if (!node || node.type !== _utils.AST_NODE_TYPES.TSTypeQuery) {
+    return null;
+  }
+  var exprName = node.exprName;
+  if (exprName.type !== _utils.AST_NODE_TYPES.TSImportType) {
+    return null;
+  }
+  var argument = exprName.argument;
+  if (argument.type === _utils.AST_NODE_TYPES.TSLiteralType && argument.literal.type === _utils.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 === _utils.AST_NODE_TYPES.Literal && typeof node.value === 'string') {
+    return node.value;
+  }
+  if (node.type === _utils.AST_NODE_TYPES.TSAsExpression) {
+    return getStringValue(node.expression);
+  }
+  return null;
+}
+var 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: messages,
+    schema: []
+  },
+  create: function create(context) {
+    var filename = context.filename;
+    if (!isTargetFile(filename)) {
+      return {};
+    }
+    return {
+      'Program:exit': function ProgramExit(estreeNode) {
+        var 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.
+        var testUseCalls = [];
+        var hasAnyTypeofImport = false;
+        var visited = new Set();
+        var queue = [program];
+        while (queue.length > 0) {
+          var node = queue.shift();
+          if (visited.has(node)) {
+            continue;
+          }
+          visited.add(node);
+          if (node.type === _utils.AST_NODE_TYPES.CallExpression && node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && node.callee.property.type === _utils.AST_NODE_TYPES.Identifier && node.callee.property.name === 'use' && node.arguments.length > 0 && node.arguments[0].type === _utils.AST_NODE_TYPES.ObjectExpression) {
+            testUseCalls.push(node);
+          }
+          if (node.type === _utils.AST_NODE_TYPES.TSImportType) {
+            hasAnyTypeofImport = true;
+          }
+          for (var _i = 0, _Object$keys = Object.keys(node); _i < _Object$keys.length; _i++) {
+            var key = _Object$keys[_i];
+            if (key === 'parent') {
+              continue;
+            }
+            var child = node[key];
+            if (Array.isArray(child)) {
+              var _iterator2 = _createForOfIteratorHelper(child),
+                _step2;
+              try {
+                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                  var item = _step2.value;
+                  if (item && typeof item.type === 'string') {
+                    queue.push(item);
+                  }
+                }
+              } catch (err) {
+                _iterator2.e(err);
+              } finally {
+                _iterator2.f();
+              }
+            } 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
+        var fileHasExampleName = testUseCalls.some(function (call) {
+          var obj = call.arguments[0];
+          return obj.properties.some(function (prop) {
+            if (prop.type !== _utils.AST_NODE_TYPES.Property || prop.key.type !== _utils.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
+        var targetCall = testUseCalls[0];
+        var existingExampleNameProp = null;
+        for (var _i2 = 0, _testUseCalls = testUseCalls; _i2 < _testUseCalls.length; _i2++) {
+          var call = _testUseCalls[_i2];
+          var obj = call.arguments[0];
+          var prop = obj.properties.find(function (p) {
+            return p.type === _utils.AST_NODE_TYPES.Property && p.key.type === _utils.AST_NODE_TYPES.Identifier && p.key.name === 'exampleName';
+          });
+          if (prop) {
+            targetCall = call;
+            existingExampleNameProp = prop;
+            break;
+          }
+        }
+        if (!targetCall) {
+          return;
+        }
+        var objectArg = targetCall.arguments[0];
+
+        // Determine the example name to use for the import path
+        var exampleNameValue = existingExampleNameProp ? getStringValue(existingExampleNameProp.value) : null;
+        var defaultName = exampleNameValue !== null && exampleNameValue !== void 0 ? exampleNameValue : 'testing';
+        var examplePath = resolveExamplePath(filename, defaultName);
+        if (!examplePath) {
+          return;
+        }
+        var importPath = computeRelativeImportPath(filename, examplePath);
+        context.report({
+          node: targetCall,
+          messageId: 'missingExampleName',
+          fix: function fix(fixer) {
+            // If exampleName exists but lacks typeof import, replace its value
+            if (existingExampleNameProp) {
+              return fixer.replaceText(existingExampleNameProp.value, "'".concat(defaultName, "' as keyof typeof import('").concat(importPath, "') "));
+            }
+            // Otherwise insert exampleName as the first property
+            var firstProp = objectArg.properties[0];
+            if (!firstProp) {
+              return fixer.replaceText(targetCall.arguments[0], "{\n\texampleName: '".concat(defaultName, "' as keyof typeof import('").concat(importPath, "'),\n}"));
+            }
+            var sourceCode = context.sourceCode;
+            var token = sourceCode.getFirstToken(firstProp);
+            var indent = token ? '\t'.repeat(token.loc.start.column) : '\t';
+            return fixer.insertTextBefore(firstProp, "exampleName: '".concat(defaultName, "' as keyof typeof import('").concat(importPath, "') ,\n").concat(indent));
+          }
+        });
+      }
+    };
+  }
+};
+var _default = exports.default = rule;

package/dist/es2019/index.js

@@ -26,6 +26,8 @@ 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';
@@ -37,6 +39,7 @@ 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';
@@ -97,7 +100,10 @@ const rules = {
   'no-conversation-assistant-barrel-imports': noConversationAssistantBarrelImports,
   'visit-example-type-import-required': visitExampleTypeImportRequired,
   'no-xcss-in-cx': noXcssInCx,
-  'ensure-use-sync-external-store-server-snapshot': ensureUseSyncExternalStoreServerSnapshot
+  'editor-example-type-import-required': editorExampleTypeImportRequired,
+  'ensure-use-sync-external-store-server-snapshot': ensureUseSyncExternalStoreServerSnapshot,
+  'use-motion-token-values': useMotionTokenValues,
+  'expand-motion-shorthand': expandMotionShorthand
 };
 const commonConfig = {
   '@atlaskit/platform/ensure-test-runner-arguments': 'error',
@@ -115,6 +121,8 @@ const commonConfig = {
   '@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,

package/dist/es2019/rules/compiled/expand-motion-shorthand/index.js

@@ -0,0 +1,239 @@
+const EASING_KEYWORDS = ['ease', 'ease-in', 'ease-out', 'ease-in-out', 'linear', 'step-start', 'step-end'];
+const KEYWORD_VALUES = ['none', 'all', 'inherit', 'initial', 'unset'];
+const isDuration = token => /^\d+(?:\.\d+)?m?s$/.test(token);
+const isEasing = token => EASING_KEYWORDS.includes(token) || token.startsWith('cubic-bezier(') || token.startsWith('steps(');
+/**
+ * Tokenizes a CSS shorthand value string, respecting function boundaries.
+ * e.g. 'opacity 200ms cubic-bezier(0.4, 0, 0, 1) 0ms' →
+ *      ['opacity', '200ms', 'cubic-bezier(0.4, 0, 0, 1)', '0ms']
+ * Splits on whitespace only when not inside parentheses.
+ */
+const tokenizeShorthand = value => {
+  const tokens = [];
+  let depth = 0;
+  let current = '';
+  for (let i = 0; i < value.length; i++) {
+    const ch = value[i];
+    if (ch === '(') {
+      depth++;
+      current += ch;
+    } else if (ch === ')') {
+      depth--;
+      current += ch;
+    } else if (/\s/.test(ch) && depth === 0) {
+      if (current.length > 0) {
+        tokens.push(current);
+        current = '';
+      }
+    } else {
+      current += ch;
+    }
+  }
+  if (current.length > 0) {
+    tokens.push(current);
+  }
+  return tokens;
+};
+
+// Splits on top-level commas (outside function parens) — preserves cubic-bezier(...) commas.
+const splitOnTopLevelCommas = value => {
+  const parts = [];
+  let depth = 0;
+  let current = '';
+  for (const ch of value) {
+    if (ch === '(') {
+      depth++;
+      current += ch;
+    } else if (ch === ')') {
+      depth--;
+      current += ch;
+    } else if (ch === ',' && depth === 0) {
+      parts.push(current.trim());
+      current = '';
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim().length > 0) {
+    parts.push(current.trim());
+  }
+  return parts;
+};
+const parseTransition = value => {
+  const parts = tokenizeShorthand(value.trim());
+  const result = {};
+  let durationCount = 0;
+  for (const part of parts) {
+    if (isDuration(part)) {
+      if (durationCount === 0) {
+        result.transitionDuration = part;
+      } else {
+        result.transitionDelay = part;
+      }
+      durationCount++;
+    } else if (isEasing(part)) {
+      result.transitionTimingFunction = part;
+    } else {
+      result.transitionProperty = part;
+    }
+  }
+  return result;
+};
+const parseAnimation = value => {
+  const parts = tokenizeShorthand(value.trim());
+  const result = {};
+  let durationCount = 0;
+  for (const part of parts) {
+    if (isDuration(part)) {
+      if (durationCount === 0) {
+        result.animationDuration = part;
+      } else {
+        result.animationDelay = part;
+      }
+      durationCount++;
+    } else if (isEasing(part)) {
+      result.animationTimingFunction = part;
+    } else if (part === 'infinite' || /^\d+(\.\d+)?$/.test(part)) {
+      result.animationIterationCount = part;
+    } else if (['normal', 'reverse', 'alternate', 'alternate-reverse'].includes(part)) {
+      result.animationDirection = part;
+    } else if (['none', 'forwards', 'backwards', 'both'].includes(part)) {
+      result.animationFillMode = part;
+    } else if (['running', 'paused'].includes(part)) {
+      result.animationPlayState = part;
+    } else {
+      result.animationName = part;
+    }
+  }
+  return result;
+};
+
+// Combine sub-property values across comma-separated transitions/animations.
+// If no segment explicitly set this sub-property, omit it entirely.
+// Otherwise, fill missing slots with the CSS spec default to preserve positional alignment.
+const combineSubPropertyValues = (segments, subProperty, defaultValue) => {
+  if (segments.every(s => s[subProperty] === undefined)) {
+    return undefined;
+  }
+  return segments.map(s => {
+    var _s$subProperty;
+    return (_s$subProperty = s[subProperty]) !== null && _s$subProperty !== void 0 ? _s$subProperty : defaultValue;
+  }).join(', ');
+};
+const buildTransitionFix = (segments, indent) => {
+  const lines = [];
+  const property = combineSubPropertyValues(segments, 'transitionProperty', 'all');
+  const duration = combineSubPropertyValues(segments, 'transitionDuration', '0s');
+  const timing = combineSubPropertyValues(segments, 'transitionTimingFunction', 'ease');
+  const delay = combineSubPropertyValues(segments, 'transitionDelay', '0s');
+  if (property !== undefined) lines.push(`transitionProperty: '${property}'`);
+  if (duration !== undefined) lines.push(`transitionDuration: '${duration}'`);
+  if (timing !== undefined) lines.push(`transitionTimingFunction: '${timing}'`);
+  if (delay !== undefined) lines.push(`transitionDelay: '${delay}'`);
+  return lines.join(`,\n${indent}`);
+};
+const buildAnimationFix = (segments, indent) => {
+  const lines = [];
+  const name = combineSubPropertyValues(segments, 'animationName', 'none');
+  const duration = combineSubPropertyValues(segments, 'animationDuration', '0s');
+  const timing = combineSubPropertyValues(segments, 'animationTimingFunction', 'ease');
+  const delay = combineSubPropertyValues(segments, 'animationDelay', '0s');
+  const iter = combineSubPropertyValues(segments, 'animationIterationCount', '1');
+  const direction = combineSubPropertyValues(segments, 'animationDirection', 'normal');
+  const fill = combineSubPropertyValues(segments, 'animationFillMode', 'none');
+  const playState = combineSubPropertyValues(segments, 'animationPlayState', 'running');
+  if (name !== undefined) lines.push(`animationName: '${name}'`);
+  if (duration !== undefined) lines.push(`animationDuration: '${duration}'`);
+  if (timing !== undefined) lines.push(`animationTimingFunction: '${timing}'`);
+  if (delay !== undefined) lines.push(`animationDelay: '${delay}'`);
+  if (iter !== undefined) lines.push(`animationIterationCount: '${iter}'`);
+  if (direction !== undefined) lines.push(`animationDirection: '${direction}'`);
+  if (fill !== undefined) lines.push(`animationFillMode: '${fill}'`);
+  if (playState !== undefined) lines.push(`animationPlayState: '${playState}'`);
+  return lines.join(`,\n${indent}`);
+};
+const TRANSITION_SUB_PROPERTIES = ['transitionProperty', 'transitionDuration', 'transitionTimingFunction', 'transitionDelay'];
+const ANIMATION_SUB_PROPERTIES = ['animationName', 'animationDuration', 'animationTimingFunction', 'animationDelay', 'animationIterationCount', 'animationDirection', 'animationFillMode', 'animationPlayState'];
+const executeExpandTransitionRule = (context, node, property) => {
+  var _context$sourceCode, _node$loc;
+  if (node.value.type === 'CallExpression') {
+    return;
+  }
+  if (node.value.type === 'TemplateLiteral') {
+    return;
+  }
+  if (node.value.type !== 'Literal' || typeof node.value.value !== 'string') {
+    return;
+  }
+  const rawValue = node.value.value;
+  if (KEYWORD_VALUES.includes(rawValue)) {
+    return;
+  }
+  const subProperties = property === 'transition' ? TRANSITION_SUB_PROPERTIES : ANIMATION_SUB_PROPERTIES;
+
+  // Extract leading whitespace to preserve indentation style (tabs vs spaces)
+  const sourceCode = (_context$sourceCode = context.sourceCode) !== null && _context$sourceCode !== void 0 ? _context$sourceCode : context.getSourceCode();
+  const nodeStart = (_node$loc = node.loc) === null || _node$loc === void 0 ? void 0 : _node$loc.start;
+  let indent = '\t';
+  if (nodeStart) {
+    var _sourceCode$lines;
+    const lineText = (_sourceCode$lines = sourceCode.lines[nodeStart.line - 1]) !== null && _sourceCode$lines !== void 0 ? _sourceCode$lines : '';
+    const leadingWhitespace = lineText.match(/^(\s*)/);
+    if (leadingWhitespace) {
+      indent = leadingWhitespace[1];
+    }
+  }
+  const segmentStrings = splitOnTopLevelCommas(rawValue);
+  if (property === 'transition') {
+    const segments = segmentStrings.map(parseTransition);
+    const fixText = buildTransitionFix(segments, indent);
+    context.report({
+      node,
+      messageId: 'expandTransitionShorthand',
+      data: {
+        property,
+        subProperties: subProperties.join(', ')
+      },
+      fix(fixer) {
+        return fixer.replaceText(node, fixText);
+      }
+    });
+  } else {
+    const segments = segmentStrings.map(parseAnimation);
+    const fixText = buildAnimationFix(segments, indent);
+    context.report({
+      node,
+      messageId: 'expandTransitionShorthand',
+      data: {
+        property,
+        subProperties: subProperties.join(', ')
+      },
+      fix(fixer) {
+        return fixer.replaceText(node, fixText);
+      }
+    });
+  }
+};
+export const expandTransitionShorthand = {
+  meta: {
+    type: 'suggestion',
+    fixable: 'code',
+    docs: {
+      url: 'https://bitbucket.org/atlassian/atlassian-frontend-monorepo/src/master/platform/packages/platform/eslint-plugin/src/rules/compiled/expand-transition-shorthand/'
+    },
+    messages: {
+      expandTransitionShorthand: "Use {{ subProperties }} instead of the '{{ property }}' shorthand so that individual values can be replaced with motion tokens."
+    }
+  },
+  create(context) {
+    return {
+      'Property[key.name="transition"]': function (node) {
+        executeExpandTransitionRule(context, node, 'transition');
+      },
+      'Property[key.name="animation"]': function (node) {
+        executeExpandTransitionRule(context, node, 'animation');
+      }
+    };
+  }
+};
+export default expandTransitionShorthand;