meno-core 1.0.53 → 1.0.54

package/lib/shared/expressionEvaluator.test.ts

@@ -0,0 +1,119 @@
+/**
+ * Expression Evaluator Tests
+ *
+ * The headline concern here is the SSOT (single-source-of-truth) invariant between
+ * `evaluateNode`'s switch and `SUPPORTED_NODE_TYPES`. `isSupportedTemplateExpression`
+ * (used by the .astro codec to decide modelable {{binding}} vs verbatim _code) trusts
+ * `SUPPORTED_NODE_TYPES` to mirror exactly the node types `evaluateNode` can actually
+ * evaluate. If they drift, the failure is silent — either evaluatable code gets emitted
+ * as verbatim _code, or un-evaluatable code gets coerced into a fake {{binding}} that
+ * shows up literally in SSR output. These tests force a contributor who touches one side
+ * to touch the other.
+ */
+
+import { describe, test, expect } from 'bun:test';
+import { safeEvaluate, isSupportedTemplateExpression, SUPPORTED_NODE_TYPES } from './expressionEvaluator';
+
+/**
+ * The complete set of jsep node types `evaluateNode` has a `case` for AND returns a
+ * value from (i.e. does NOT throw). This list is intentionally hardcoded: adding a new
+ * `case` to evaluateNode without adding it here (or vice-versa) must fail the exact-set
+ * assertion below, forcing the SSOT to be kept in lockstep.
+ *
+ * Note: `LogicalExpression` is handled defensively in the same switch case as
+ * `BinaryExpression`, but jsep classifies `&&`/`||` as `BinaryExpression` by default, so
+ * it is never produced from a parsed string — hence it has no representative expression.
+ */
+const EXPECTED_SUPPORTED_NODE_TYPES = [
+  'Identifier',
+  'Literal',
+  'MemberExpression',
+  'BinaryExpression',
+  'LogicalExpression',
+  'ConditionalExpression',
+  'UnaryExpression',
+  'ArrayExpression',
+].sort();
+
+/**
+ * A representative, parseable expression for every supported node type jsep can actually
+ * emit, paired with the value `evaluateNode` should return for it given `CONTEXT`. Each
+ * entry double-proves the SSOT: the expression both (a) is reported supported by
+ * `isSupportedTemplateExpression`, and (b) is actually evaluated (not thrown) by
+ * `safeEvaluate` — so a type listed in SUPPORTED_NODE_TYPES but missing from the switch
+ * would surface as a wrong/undefined evaluation result here.
+ */
+const CONTEXT = { a: 2, b: 3, flag: true, name: 'Meno', obj: { x: 7 }, key: 'x' };
+const REPRESENTATIVE: Array<{ nodeType: string; expr: string; expected: unknown }> = [
+  { nodeType: 'Identifier', expr: 'name', expected: 'Meno' },
+  { nodeType: 'Literal', expr: '42', expected: 42 },
+  { nodeType: 'MemberExpression', expr: 'obj.x', expected: 7 },
+  { nodeType: 'MemberExpression(computed)', expr: 'obj[key]', expected: 7 },
+  { nodeType: 'BinaryExpression', expr: 'a + b', expected: 5 },
+  { nodeType: 'BinaryExpression(&&)', expr: 'flag && name', expected: 'Meno' },
+  { nodeType: 'BinaryExpression(||)', expr: 'a || b', expected: 2 },
+  { nodeType: 'ConditionalExpression', expr: 'flag ? a : b', expected: 2 },
+  { nodeType: 'UnaryExpression', expr: '!flag', expected: false },
+  { nodeType: 'ArrayExpression', expr: '[a, b]', expected: [2, 3] },
+];
+
+/** Node types the evaluator deliberately refuses (its switch throws for these). */
+const UNSUPPORTED_EXPRESSIONS: Array<{ nodeType: string; expr: string }> = [
+  { nodeType: 'CallExpression', expr: 'obj.x.toFixed(2)' },
+  { nodeType: 'Compound', expr: 'a, b' },
+];
+
+describe('expressionEvaluator SSOT invariant', () => {
+  test('SUPPORTED_NODE_TYPES exactly equals the expected hardcoded set', () => {
+    // If this fails, evaluateNode's switch and SUPPORTED_NODE_TYPES have drifted —
+    // update the switch, SUPPORTED_NODE_TYPES, AND this test's expected list together.
+    expect([...SUPPORTED_NODE_TYPES].sort()).toEqual(EXPECTED_SUPPORTED_NODE_TYPES);
+  });
+
+  test('every representative supported expression is reported supported AND evaluated', () => {
+    for (const { nodeType, expr, expected } of REPRESENTATIVE) {
+      // (a) the codec predicate must accept it
+      expect(isSupportedTemplateExpression(expr)).toBe(true);
+      // (b) the evaluator must actually handle it (not throw -> undefined fallback)
+      expect(safeEvaluate(expr, CONTEXT)).toEqual(expected as never);
+    }
+  });
+
+  test('every representative node type (jsep-producible) is present in SUPPORTED_NODE_TYPES', () => {
+    // Maps the labelled representatives back to their base jsep node type and asserts
+    // membership — closes the "added a case to the switch but forgot the set" gap for
+    // any type that has been given a representative expression.
+    const producibleBaseTypes = new Set(REPRESENTATIVE.map((r) => r.nodeType.replace(/\(.*\)$/, '')));
+    for (const baseType of producibleBaseTypes) {
+      expect(SUPPORTED_NODE_TYPES.has(baseType)).toBe(true);
+    }
+  });
+});
+
+describe('isSupportedTemplateExpression', () => {
+  test('returns false for function/method calls (verbatim _code territory)', () => {
+    for (const { expr } of UNSUPPORTED_EXPRESSIONS) {
+      expect(isSupportedTemplateExpression(expr)).toBe(false);
+    }
+  });
+
+  test('returns false for empty / whitespace / syntactically invalid expressions', () => {
+    expect(isSupportedTemplateExpression('')).toBe(false);
+    expect(isSupportedTemplateExpression('   ')).toBe(false);
+    expect(isSupportedTemplateExpression('a +')).toBe(false);
+  });
+
+  test('rejects an expression nesting an unsupported call deep inside a supported tree', () => {
+    // The recursive walk must catch unsupported nodes that are not at the root.
+    expect(isSupportedTemplateExpression('a + obj.x.toFixed(2)')).toBe(false);
+    expect(isSupportedTemplateExpression('flag ? name : obj.x.toString()')).toBe(false);
+  });
+});
+
+describe('safeEvaluate', () => {
+  test('returns undefined (no throw) for unsupported expressions', () => {
+    for (const { expr } of UNSUPPORTED_EXPRESSIONS) {
+      expect(safeEvaluate(expr, CONTEXT)).toBeUndefined();
+    }
+  });
+});

package/lib/shared/expressionEvaluator.ts

@@ -6,8 +6,8 @@
  * Supports: ternary, binary, logical, unary operators, member access, arrays
  */
 
-import jsep from 'jsep';
 import type { Expression } from 'jsep';
+import jsep from 'jsep';
 
 /**
  * Safely evaluates a jsep AST node against a context object
@@ -73,18 +73,32 @@ function evaluateNode(node: Expression, context: Record<string, unknown>): unkno
             return String(left ?? '') + String(right ?? '');
           }
           return (left as number) + (right as number);
-        case '-': return (left as number) - (right as number);
-        case '*': return (left as number) * (right as number);
-        case '/': return (left as number) / (right as number);
-        case '%': return (left as number) % (right as number);
-        case '===': return left === right;
-        case '!==': return left !== right;
-        case '==': return left == right;
-        case '!=': return left != right;
-        case '<': return (left as number) < (right as number);
-        case '>': return (left as number) > (right as number);
-        case '<=': return (left as number) <= (right as number);
-        case '>=': return (left as number) >= (right as number);
+        case '-':
+          return (left as number) - (right as number);
+        case '*':
+          return (left as number) * (right as number);
+        case '/':
+          return (left as number) / (right as number);
+        case '%':
+          return (left as number) % (right as number);
+        case '===':
+          return left === right;
+        case '!==':
+          return left !== right;
+        case '==':
+          // biome-ignore lint/suspicious/noDoubleEquals: loose equality IS the semantics of the `==` operator in template expressions
+          return left == right;
+        case '!=':
+          // biome-ignore lint/suspicious/noDoubleEquals: loose inequality IS the semantics of the `!=` operator in template expressions
+          return left != right;
+        case '<':
+          return (left as number) < (right as number);
+        case '>':
+          return (left as number) > (right as number);
+        case '<=':
+          return (left as number) <= (right as number);
+        case '>=':
+          return (left as number) >= (right as number);
         default:
           throw new Error(`Unsupported operator: ${binaryNode.operator}`);
       }
@@ -94,9 +108,7 @@ function evaluateNode(node: Expression, context: Record<string, unknown>): unkno
       // Ternary: condition ? consequent : alternate
       const condNode = node as jsep.ConditionalExpression;
       const test = evaluateNode(condNode.test, context);
-      return test
-        ? evaluateNode(condNode.consequent, context)
-        : evaluateNode(condNode.alternate, context);
+      return test ? evaluateNode(condNode.consequent, context) : evaluateNode(condNode.alternate, context);
     }
 
     case 'UnaryExpression': {
@@ -105,9 +117,12 @@ function evaluateNode(node: Expression, context: Record<string, unknown>): unkno
       const arg = evaluateNode(unaryNode.argument, context);
 
       switch (unaryNode.operator) {
-        case '!': return !arg;
-        case '-': return -(arg as number);
-        case '+': return +(arg as number);
+        case '!':
+          return !arg;
+        case '-':
+          return -(arg as number);
+        case '+':
+          return +(arg as number);
         default:
           throw new Error(`Unsupported unary operator: ${unaryNode.operator}`);
       }
@@ -116,9 +131,7 @@ function evaluateNode(node: Expression, context: Record<string, unknown>): unkno
     case 'ArrayExpression': {
       // Array literals: [1, 2, 3]
       const arrayNode = node as jsep.ArrayExpression;
-      return arrayNode.elements.map(el =>
-        el ? evaluateNode(el, context) : undefined
-      );
+      return arrayNode.elements.map((el) => (el ? evaluateNode(el, context) : undefined));
     }
 
     case 'CallExpression': {
@@ -160,8 +173,14 @@ export function isComplexExpression(expression: string): boolean {
   return /[?:+\-*/%<>=!&|]/.test(expression);
 }
 
-/** jsep node types `evaluateNode` (above) can evaluate — the rest throw at runtime. */
-const SUPPORTED_NODE_TYPES = new Set([
+/**
+ * jsep node types `evaluateNode` (above) can evaluate — the rest throw at runtime.
+ *
+ * SSOT: this set MUST stay in lockstep with the `case` labels in `evaluateNode`'s
+ * switch. Drift is silent (lost code or literal `{{…}}` in SSR output), so the
+ * invariant is pinned by expressionEvaluator.test.ts — update both together.
+ */
+export const SUPPORTED_NODE_TYPES = new Set([
   'Identifier',
   'Literal',
   'MemberExpression',

package/lib/shared/fontLoader.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, afterAll } from 'bun:test';
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
 import { join } from 'path';
 import { mkdirSync, writeFileSync, rmSync } from 'fs';
 import { tmpdir } from 'os';
@@ -13,10 +13,23 @@ const testDir = join(tmpdir(), `fontLoader-test-${Date.now()}`);
 mkdirSync(testDir, { recursive: true });
 setProjectRoot(testDir);
 
+// fontLoader keeps a module-level config cache that survives across test
+// files in a single `bun test` process. Earlier files (e.g. anything pulling
+// in the SSR htmlGenerator) may already have populated it with `{ fonts: [] }`,
+// which would make loadProjectConfig() return that stale cache instead of
+// reading our test config. Reset on both ends so this file neither inherits
+// nor leaks cached config.
+beforeAll(() => {
+  resetFontConfig();
+});
+
 // Restore original project root after all tests in this file
 afterAll(() => {
   setProjectRoot(originalProjectRoot);
-  try { rmSync(testDir, { recursive: true, force: true }); } catch {}
+  resetFontConfig();
+  try {
+    rmSync(testDir, { recursive: true, force: true });
+  } catch {}
 });
 
 // Helper to write a project.config.json in the test directory
@@ -99,6 +112,7 @@ import {
   generateFontCSS,
   generateFontPreloadTags,
   getFontFamilies,
+  resetFontConfig,
 } from './fontLoader';
 
 describe('fontLoader', () => {
@@ -215,7 +229,7 @@ describe('fontLoader', () => {
   test('generateFontCSS omits font-display when not specified', () => {
     const css = generateFontCSS();
     // The Roboto bold entry has no fontDisplay
-    const robotoBlock = css.split('\n\n').find(b => b.includes('roboto-bold.ttf'))!;
+    const robotoBlock = css.split('\n\n').find((b) => b.includes('roboto-bold.ttf'))!;
     expect(robotoBlock).toBeDefined();
     expect(robotoBlock).not.toContain('font-display');
   });
@@ -277,7 +291,7 @@ describe('fontLoader', () => {
 
   test('generateFontPreloadTags defaults to font/ttf for unknown extension', () => {
     const tags = generateFontPreloadTags();
-    const mysteryTag = tags.split('\n  ').find(t => t.includes('mystery.xyz'))!;
+    const mysteryTag = tags.split('\n  ').find((t) => t.includes('mystery.xyz'))!;
     expect(mysteryTag).toContain('type="font/ttf"');
   });
 
@@ -297,7 +311,7 @@ describe('fontLoader', () => {
   test('generateFontPreloadTags produces correct link tag format', () => {
     const tags = generateFontPreloadTags();
     expect(tags).toContain(
-      '<link rel="preload" href="/fonts/inter-variable.woff2" as="font" type="font/woff2" crossorigin>'
+      '<link rel="preload" href="/fonts/inter-variable.woff2" as="font" type="font/woff2" crossorigin>',
     );
   });
 

package/lib/shared/friendlyError.ts

@@ -83,7 +83,7 @@ const RULES: Rule[] = [
     test: /Cannot find module|Failed to resolve module|Failed to load module|Error loading dynamically imported module/i,
     build: () => ({
       title: "A required file couldn't be loaded",
-      friendlyMessage: 'An import or module reference couldn\'t be found.',
+      friendlyMessage: "An import or module reference couldn't be found.",
       hint: 'Check the import path.',
     }),
   },
@@ -114,8 +114,7 @@ export function toFriendlyError(input: unknown): FriendlyError {
 
   return {
     title: 'This section ran into a problem',
-    friendlyMessage:
-      'Something went wrong while rendering this part of the page. The rest of the page is fine.',
+    friendlyMessage: 'Something went wrong while rendering this part of the page. The rest of the page is fine.',
     raw,
   };
 }

package/lib/shared/gradientUtils.test.ts

@@ -1,9 +1,5 @@
 import { describe, test, expect } from 'bun:test';
-import {
-  isGradientValue,
-  parseGradient,
-  buildGradientCss,
-} from './gradientUtils';
+import { isGradientValue, parseGradient, buildGradientCss } from './gradientUtils';
 
 describe('isGradientValue', () => {
   test('identifies gradient values', () => {

package/lib/shared/gradientUtils.ts

@@ -22,9 +22,7 @@ const CONIC_RE = /^conic-gradient\((.+)\)$/i;
 export function isGradientValue(value: string): boolean {
   if (!value) return false;
   const v = value.trim().toLowerCase();
-  return v.startsWith('linear-gradient(') ||
-    v.startsWith('radial-gradient(') ||
-    v.startsWith('conic-gradient(');
+  return v.startsWith('linear-gradient(') || v.startsWith('radial-gradient(') || v.startsWith('conic-gradient(');
 }
 
 /** Parse a CSS gradient string into a GradientConfig */
@@ -94,9 +92,7 @@ export function parseGradient(cssValue: string): GradientConfig | null {
 
 /** Build a CSS gradient string from a GradientConfig */
 export function buildGradientCss(config: GradientConfig): string {
-  const stopStrings = config.stops.map(
-    s => `${s.color} ${Math.round(s.position)}%`
-  );
+  const stopStrings = config.stops.map((s) => `${s.color} ${Math.round(s.position)}%`);
 
   switch (config.type) {
     case 'linear': {

package/lib/shared/hrefRefs.ts

@@ -16,11 +16,7 @@
 
 function rewriteHref(value: string, oldHref: string, newHref: string): string | null {
   if (value === oldHref) return newHref;
-  if (
-    value.startsWith(oldHref + '/') ||
-    value.startsWith(oldHref + '?') ||
-    value.startsWith(oldHref + '#')
-  ) {
+  if (value.startsWith(oldHref + '/') || value.startsWith(oldHref + '?') || value.startsWith(oldHref + '#')) {
     return newHref + value.substring(oldHref.length);
   }
   return null;
@@ -34,11 +30,7 @@ function rewriteHref(value: string, oldHref: string, newHref: string): string |
  * Walks `children` recursively (array or single object) and any object-valued
  * field on the node (covers component-prop-trees, nested structure, etc.).
  */
-export function rewriteHrefRefs(
-  node: unknown,
-  oldHref: string,
-  newHref: string,
-): boolean {
+export function rewriteHrefRefs(node: unknown, oldHref: string, newHref: string): boolean {
   if (!node || typeof node !== 'object') return false;
   if (!oldHref || oldHref === newHref) return false;
 

package/lib/shared/i18n.test.ts

@@ -199,7 +199,7 @@ describe('i18n', () => {
     test('should return empty array if no translation available for list i18n', () => {
       const listValue = {
         _i18n: true,
-        en: [],  // Add empty array to make it a list i18n
+        en: [], // Add empty array to make it a list i18n
       } as I18nValue;
       // Remove the empty array to test empty fallback detection
       delete (listValue as any).en;

package/lib/shared/i18n.ts

@@ -10,9 +10,7 @@ import type { I18nValue, I18nConfig, LocaleConfig } from './types/components';
  */
 export const DEFAULT_I18N_CONFIG: I18nConfig = {
   defaultLocale: 'en',
-  locales: [
-    { code: 'en', name: 'English', nativeName: 'English', langTag: 'en-US' }
-  ],
+  locales: [{ code: 'en', name: 'English', nativeName: 'English', langTag: 'en-US' }],
 };
 
 // ============================================
@@ -23,21 +21,21 @@ export const DEFAULT_I18N_CONFIG: I18nConfig = {
  * Get array of locale codes from config
  */
 export function getLocaleCodes(config: I18nConfig): string[] {
-  return config.locales.map(loc => loc.code);
+  return config.locales.map((loc) => loc.code);
 }
 
 /**
  * Find a locale config by its code
  */
 export function findLocaleByCode(config: I18nConfig, code: string): LocaleConfig | undefined {
-  return config.locales.find(loc => loc.code === code);
+  return config.locales.find((loc) => loc.code === code);
 }
 
 /**
  * Check if a locale code is valid/exists in config
  */
 export function isValidLocaleCode(config: I18nConfig, code: string): boolean {
-  return config.locales.some(loc => loc.code === code);
+  return config.locales.some((loc) => loc.code === code);
 }
 
 // ============================================
@@ -112,11 +110,7 @@ export function isI18nValue(value: unknown): value is I18nValue {
  * Fallback order: exact locale -> default locale -> first available -> empty
  * Works with any value type (strings, arrays for list props, etc.)
  */
-export function resolveTranslation(
-  value: I18nValue,
-  locale: string,
-  config: I18nConfig
-): unknown {
+export function resolveTranslation(value: I18nValue, locale: string, config: I18nConfig): unknown {
   // Try exact locale match (any type - string, array, etc.)
   if (locale in value && value[locale] !== undefined && locale !== '_i18n') {
     return value[locale];
@@ -136,9 +130,7 @@ export function resolveTranslation(
 
   // Return empty string for string i18n, empty array for list i18n
   // Check if any value is an array to determine the type
-  const hasArrayValue = Object.entries(value).some(
-    ([k, v]) => k !== '_i18n' && Array.isArray(v)
-  );
+  const hasArrayValue = Object.entries(value).some(([k, v]) => k !== '_i18n' && Array.isArray(v));
   return hasArrayValue ? [] : '';
 }
 
@@ -146,11 +138,7 @@ export function resolveTranslation(
  * Resolve a value that might be an I18nValue or a regular value
  * Returns the original value if not an I18nValue
  */
-export function resolveI18nValue(
-  value: unknown,
-  locale: string,
-  config: I18nConfig
-): unknown {
+export function resolveI18nValue(value: unknown, locale: string, config: I18nConfig): unknown {
   if (isI18nValue(value)) {
     return resolveTranslation(value, locale, config);
   }
@@ -163,7 +151,7 @@ export function resolveI18nValue(
 export function resolveI18nInProps(
   props: Record<string, unknown>,
   locale: string,
-  config: I18nConfig
+  config: I18nConfig,
 ): Record<string, unknown> {
   const resolved: Record<string, unknown> = {};
 
@@ -171,16 +159,10 @@ export function resolveI18nInProps(
     if (isI18nValue(value)) {
       resolved[key] = resolveTranslation(value, locale, config);
     } else if (Array.isArray(value)) {
-      resolved[key] = value.map((item) =>
-        isI18nValue(item) ? resolveTranslation(item, locale, config) : item
-      );
+      resolved[key] = value.map((item) => (isI18nValue(item) ? resolveTranslation(item, locale, config) : item));
     } else if (typeof value === 'object' && value !== null) {
       // Recursively resolve nested objects (but not I18nValue which is already handled)
-      resolved[key] = resolveI18nInProps(
-        value as Record<string, unknown>,
-        locale,
-        config
-      );
+      resolved[key] = resolveI18nInProps(value as Record<string, unknown>, locale, config);
     } else {
       resolved[key] = value;
     }
@@ -195,7 +177,7 @@ export function resolveI18nInProps(
  */
 export function extractLocaleFromPath(
   path: string,
-  config: I18nConfig
+  config: I18nConfig,
 ): { locale: string | null; pathWithoutLocale: string } {
   // Remove leading slash and split
   const cleanPath = path.startsWith('/') ? path.slice(1) : path;
@@ -235,17 +217,14 @@ export interface LocaleContext {
  * Parse locale from path and return full context with effective locale
  * Combines extractLocaleFromPath + defaultLocale resolution in one call
  */
-export function parseLocaleFromPath(
-  path: string,
-  config: I18nConfig
-): LocaleContext {
+export function parseLocaleFromPath(path: string, config: I18nConfig): LocaleContext {
   const { locale, pathWithoutLocale } = extractLocaleFromPath(path, config);
   const effectiveLocale = locale || config.defaultLocale;
 
   return {
     locale: effectiveLocale,
     pathWithoutLocale,
-    isDefaultLocale: effectiveLocale === config.defaultLocale
+    isDefaultLocale: effectiveLocale === config.defaultLocale,
   };
 }
 

package/lib/shared/index.ts

@@ -116,6 +116,10 @@ export { isSupportedTemplateExpression } from './expressionEvaluator';
 // Path security utilities
 export * from './pathSecurity';
 
+// Netlify locale-scoped 404 rules + the managed netlify.toml block (shared by
+// every netlify.toml producer and the studio save-config sync)
+export * from './netlifyLocale404';
+
 // Interactive style mapping utilities
 export * from './interactiveStyleMappings';
 

package/lib/shared/inlineSvgStyleRules.ts

@@ -59,9 +59,7 @@ function rewriteSvgBlock(svgBlock: string): string {
     const rawContent = m[1];
     // Strip CDATA wrapper if present (DOMPurify already unwraps it, but the
     // pre-sanitize call path may see one).
-    const content = stripCssComments(
-      rawContent.replace(/^\s*<!\[CDATA\[/, '').replace(/\]\]>\s*$/, '')
-    );
+    const content = stripCssComments(rawContent.replace(/^\s*<!\[CDATA\[/, '').replace(/\]\]>\s*$/, ''));
 
     // Pull out every simple `.cls { ... }` rule we can match.
     const localClasses = new Map<string, string>();
@@ -99,7 +97,7 @@ function rewriteSvgBlock(svgBlock: string): string {
   for (const [className, decls] of classDeclarations) {
     const elementRe = new RegExp(
       `(<[A-Za-z][\\w-]*\\b[^>]*?\\sclass="[^"]*\\b${escapeForRegex(className)}\\b[^"]*"[^>]*?)(/?>)`,
-      'g'
+      'g',
     );
     out = out.replace(elementRe, (_full, openHead: string, closing: string) => {
       const styleAttrMatch = openHead.match(/\sstyle="([^"]*)"/);

package/lib/shared/interactiveStyleMappings.test.ts

@@ -46,9 +46,7 @@ describe('interactiveStyleMappings', () => {
     });
 
     it('returns false when no mappings present', () => {
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { backgroundColor: '#0070f3' } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { backgroundColor: '#0070f3' } } }];
       expect(hasInteractiveStyleMappings(styles)).toBe(false);
     });
 
@@ -89,9 +87,7 @@ describe('interactiveStyleMappings', () => {
 
   describe('extractInteractiveStyleMappings', () => {
     it('returns unchanged styles when no mappings', () => {
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { backgroundColor: '#0070f3' } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { backgroundColor: '#0070f3' } } }];
 
       const { resolvedStyles, mappings } = extractInteractiveStyleMappings(styles);
 
@@ -106,9 +102,7 @@ describe('interactiveStyleMappings', () => {
         values: { primary: '#0070f3', secondary: '#gray' },
       };
 
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { backgroundColor: mapping } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { backgroundColor: mapping } }];
 
       const { resolvedStyles, mappings } = extractInteractiveStyleMappings(styles);
 
@@ -133,9 +127,7 @@ describe('interactiveStyleMappings', () => {
         values: { primary: '#0070f3' },
       };
 
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { backgroundColor: mapping } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { backgroundColor: mapping } } }];
 
       const { resolvedStyles, mappings } = extractInteractiveStyleMappings(styles);
 
@@ -287,9 +279,7 @@ describe('interactiveStyleMappings', () => {
         values: { primary: '#0070f3' },
       };
 
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { backgroundColor: mapping } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { backgroundColor: mapping } } }];
 
       const { resolvedStyles } = extractInteractiveStyleMappings(styles);
 
@@ -305,9 +295,7 @@ describe('interactiveStyleMappings', () => {
         values: { primary: '#0070f3', secondary: '#gray' },
       };
 
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { backgroundColor: mapping } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { backgroundColor: mapping } } }];
 
       const { mappings } = extractInteractiveStyleMappings(styles);
       const cssVariables = resolveExtractedMappings(mappings, { variant: 'primary' });
@@ -351,9 +339,7 @@ describe('interactiveStyleMappings', () => {
         values: { primary: '#0070f3', secondary: '#gray' },
       };
 
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { backgroundColor: mapping } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { backgroundColor: mapping } } }];
 
       const { mappings } = extractInteractiveStyleMappings(styles);
       const cssVariables = resolveExtractedMappings(mappings, { variant: 'purple' });
@@ -368,9 +354,7 @@ describe('interactiveStyleMappings', () => {
         values: { primary: '#0070f3' },
       };
 
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { backgroundColor: mapping } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { backgroundColor: mapping } } }];
 
       const { mappings } = extractInteractiveStyleMappings(styles);
       const cssVariables = resolveExtractedMappings(mappings, {});
@@ -385,9 +369,7 @@ describe('interactiveStyleMappings', () => {
         values: { primary: '#0070f3' },
       };
 
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { backgroundColor: mapping } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { backgroundColor: mapping } } }];
 
       const { mappings } = extractInteractiveStyleMappings(styles);
       const cssVariables = resolveExtractedMappings(mappings, { variant: null });
@@ -402,9 +384,7 @@ describe('interactiveStyleMappings', () => {
         values: { true: '0.5', false: '1' },
       };
 
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { opacity: mapping } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { opacity: mapping } } }];
 
       const { mappings } = extractInteractiveStyleMappings(styles);
       const cssVariables = resolveExtractedMappings(mappings, { disabled: true });
@@ -419,9 +399,7 @@ describe('interactiveStyleMappings', () => {
         values: { '1': '10px', '2': '20px', '3': '30px' },
       };
 
-      const styles: InteractiveStyles = [
-        { postfix: ':hover', style: { base: { padding: mapping } } },
-      ];
+      const styles: InteractiveStyles = [{ postfix: ':hover', style: { base: { padding: mapping } } }];
 
       const { mappings } = extractInteractiveStyleMappings(styles);
       const cssVariables = resolveExtractedMappings(mappings, { size: 2 });