meno-core 1.0.53 → 1.1.0

package/lib/shared/propResolver.test.ts

@@ -1,19 +1,15 @@
-import { test, expect, describe, beforeEach } from "bun:test";
-import {
-  resolveComponentProps,
-  resolvePropsFromDefinition,
-  isRichTextMarker
-} from "./propResolver";
-import type { StructuredComponentDefinition, ComponentNode, I18nConfig, PropDefinition } from "./types";
-
-describe("Prop Resolver - resolveComponentProps", () => {
-  describe("Default values", () => {
-    test("should apply default value when prop not provided", () => {
+import { test, expect, describe } from 'bun:test';
+import { resolveComponentProps, resolvePropsFromDefinition, isRichTextMarker } from './propResolver';
+import type { StructuredComponentDefinition, ComponentNode, I18nConfig, PropDefinition } from './types';
+
+describe('Prop Resolver - resolveComponentProps', () => {
+  describe('Default values', () => {
+    test('should apply default value when prop not provided', () => {
       const propDefs: Record<string, PropDefinition> = {
         variant: {
-          type: "select",
-          default: "primary"
-        }
+          type: 'select',
+          default: 'primary',
+        },
       };
       const passedProps = {};
       const children: (ComponentNode | string)[] = [];
@@ -21,37 +17,37 @@ describe("Prop Resolver - resolveComponentProps", () => {
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
-      expect(result.variant).toBe("primary");
+      expect(result.variant).toBe('primary');
     });
 
-    test("should override default with passed prop", () => {
+    test('should override default with passed prop', () => {
       const propDefs: Record<string, PropDefinition> = {
         variant: {
-          type: "select",
-          default: "primary"
-        }
+          type: 'select',
+          default: 'primary',
+        },
       };
-      const passedProps = { variant: "secondary" };
+      const passedProps = { variant: 'secondary' };
       const children: (ComponentNode | string)[] = [];
 
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
-      expect(result.variant).toBe("secondary");
+      expect(result.variant).toBe('secondary');
     });
 
-    test("should handle undefined passed prop value (should use default)", () => {
+    test('should handle undefined passed prop value (should use default)', () => {
       const propDefs: Record<string, PropDefinition> = {
         variant: {
-          type: "select",
-          default: "primary"
-        }
+          type: 'select',
+          default: 'primary',
+        },
       };
       const passedProps = { variant: undefined };
       const children: (ComponentNode | string)[] = [];
@@ -59,22 +55,22 @@ describe("Prop Resolver - resolveComponentProps", () => {
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
-      expect(result.variant).toBe("primary");
+      expect(result.variant).toBe('primary');
     });
 
-    test("should apply multiple defaults", () => {
+    test('should apply multiple defaults', () => {
       const propDefs: Record<string, PropDefinition> = {
         variant: {
-          type: "select",
-          default: "primary"
+          type: 'select',
+          default: 'primary',
         },
         size: {
-          type: "select",
-          default: "medium"
-        }
+          type: 'select',
+          default: 'medium',
+        },
       };
       const passedProps = {};
       const children: (ComponentNode | string)[] = [];
@@ -82,19 +78,19 @@ describe("Prop Resolver - resolveComponentProps", () => {
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
-      expect(result.variant).toBe("primary");
-      expect(result.size).toBe("medium");
+      expect(result.variant).toBe('primary');
+      expect(result.size).toBe('medium');
     });
 
-    test("should handle null default value", () => {
+    test('should handle null default value', () => {
       const propDefs: Record<string, PropDefinition> = {
         optional: {
-          type: "select",
-          default: undefined
-        }
+          type: 'select',
+          default: undefined,
+        },
       };
       const passedProps = {};
       const children: (ComponentNode | string)[] = [];
@@ -102,21 +98,21 @@ describe("Prop Resolver - resolveComponentProps", () => {
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
       expect(result.optional).toBeUndefined();
     });
   });
 
-  describe("Prop types", () => {
-    test("should handle select type with default", () => {
+  describe('Prop types', () => {
+    test('should handle select type with default', () => {
       const propDefs: Record<string, PropDefinition> = {
         variant: {
-          type: "select",
-          options: ["primary", "secondary"],
-          default: "primary"
-        }
+          type: 'select',
+          options: ['primary', 'secondary'],
+          default: 'primary',
+        },
       };
       const passedProps = {};
       const children: (ComponentNode | string)[] = [];
@@ -124,18 +120,18 @@ describe("Prop Resolver - resolveComponentProps", () => {
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
-      expect(result.variant).toBe("primary");
+      expect(result.variant).toBe('primary');
     });
 
-    test("should handle boolean type with default true", () => {
+    test('should handle boolean type with default true', () => {
       const propDefs: Record<string, PropDefinition> = {
         disabled: {
-          type: "boolean",
-          default: true
-        }
+          type: 'boolean',
+          default: true,
+        },
       };
       const passedProps = {};
       const children: (ComponentNode | string)[] = [];
@@ -143,18 +139,18 @@ describe("Prop Resolver - resolveComponentProps", () => {
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
       expect(result.disabled).toBe(true);
     });
 
-    test("should handle boolean type with default false", () => {
+    test('should handle boolean type with default false', () => {
       const propDefs: Record<string, PropDefinition> = {
         disabled: {
-          type: "boolean",
-          default: false
-        }
+          type: 'boolean',
+          default: false,
+        },
       };
       const passedProps = {};
       const children: (ComponentNode | string)[] = [];
@@ -162,18 +158,18 @@ describe("Prop Resolver - resolveComponentProps", () => {
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
       expect(result.disabled).toBe(false);
     });
 
-    test("should handle slot type with default", () => {
+    test('should handle slot type with default', () => {
       const propDefs: Record<string, PropDefinition> = {
         children: {
-          type: "string",
-          default: "Click me"
-        }
+          type: 'string',
+          default: 'Click me',
+        },
       };
       const passedProps = {};
       const children: (ComponentNode | string)[] = [];
@@ -181,37 +177,37 @@ describe("Prop Resolver - resolveComponentProps", () => {
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
-      expect(result.children).toBe("Click me");
+      expect(result.children).toBe('Click me');
     });
 
-    test("should handle props without defaults", () => {
+    test('should handle props without defaults', () => {
       const propDefs: Record<string, PropDefinition> = {
         customProp: {
-          type: "string"
+          type: 'string',
           // No default
-        }
+        },
       };
-      const passedProps = { customProp: "value" };
+      const passedProps = { customProp: 'value' };
       const children: (ComponentNode | string)[] = [];
 
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
-      expect(result.customProp).toBe("value");
+      expect(result.customProp).toBe('value');
     });
 
-    test("should return undefined for props without defaults when not passed", () => {
+    test('should return undefined for props without defaults when not passed', () => {
       const propDefs: Record<string, PropDefinition> = {
         customProp: {
-          type: "string"
+          type: 'string',
           // No default
-        }
+        },
       };
       const passedProps = {};
       const children: (ComponentNode | string)[] = [];
@@ -219,39 +215,39 @@ describe("Prop Resolver - resolveComponentProps", () => {
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
       expect(result.customProp).toBeUndefined();
     });
   });
 
-  describe("Children handling", () => {
-    test("should use passed children when provided", () => {
+  describe('Children handling', () => {
+    test('should use passed children when provided', () => {
       const propDefs: Record<string, PropDefinition> = {
         children: {
-          type: "string",
-          default: "Default text"
-        }
+          type: 'string',
+          default: 'Default text',
+        },
       };
       const passedProps = {};
-      const children: (ComponentNode | string)[] = ["Custom text"];
+      const children: (ComponentNode | string)[] = ['Custom text'];
 
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
-      expect(result.children).toEqual(["Custom text"]);
+      expect(result.children).toEqual(['Custom text']);
     });
 
-    test("should use default children when no children provided", () => {
+    test('should use default children when no children provided', () => {
       const propDefs: Record<string, PropDefinition> = {
         children: {
-          type: "string",
-          default: "Default text"
-        }
+          type: 'string',
+          default: 'Default text',
+        },
       };
       const passedProps = {};
       const children: (ComponentNode | string)[] = [];
@@ -259,18 +255,18 @@ describe("Prop Resolver - resolveComponentProps", () => {
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
-      expect(result.children).toBe("Default text");
+      expect(result.children).toBe('Default text');
     });
 
-    test("should use default children when children array is empty", () => {
+    test('should use default children when children array is empty', () => {
       const propDefs: Record<string, PropDefinition> = {
         children: {
-          type: "string",
-          default: "Click me"
-        }
+          type: 'string',
+          default: 'Click me',
+        },
       };
       const passedProps = {};
       const children: (ComponentNode | string)[] = [];
@@ -278,18 +274,18 @@ describe("Prop Resolver - resolveComponentProps", () => {
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
-      expect(result.children).toBe("Click me");
+      expect(result.children).toBe('Click me');
     });
 
-    test("should handle empty children array when no default", () => {
+    test('should handle empty children array when no default', () => {
       const propDefs: Record<string, PropDefinition> = {
         children: {
-          type: "string"
+          type: 'string',
           // No default
-        }
+        },
       };
       const passedProps = {};
       const children: (ComponentNode | string)[] = [];
@@ -297,62 +293,62 @@ describe("Prop Resolver - resolveComponentProps", () => {
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
       expect(result.children).toBeUndefined();
     });
 
-    test("should handle children with multiple elements", () => {
+    test('should handle children with multiple elements', () => {
       const propDefs: Record<string, PropDefinition> = {
         children: {
-          type: "string",
-          default: "Default"
-        }
+          type: 'string',
+          default: 'Default',
+        },
       };
       const passedProps = {};
       const children: (ComponentNode | string)[] = [
-        { type: "node", tag: "span", children: ["First"] },
-        { type: "node", tag: "span", children: ["Second"] }
+        { type: 'node', tag: 'span', children: ['First'] },
+        { type: 'node', tag: 'span', children: ['Second'] },
       ];
 
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
       expect(Array.isArray(result.children)).toBe(true);
       expect((result.children as ComponentNode[]).length).toBe(2);
     });
 
-    test("should handle string children", () => {
+    test('should handle string children', () => {
       const propDefs: Record<string, PropDefinition> = {
         children: {
-          type: "string",
-          default: "Default"
-        }
+          type: 'string',
+          default: 'Default',
+        },
       };
       const passedProps = {};
-      const children: string = "String child";
+      const children: string = 'String child';
 
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
       // String children are not arrays, so default is used
       // (Implementation only uses passed children if Array.isArray(children) && children.length > 0)
-      expect(result.children).toBe("Default");
+      expect(result.children).toBe('Default');
     });
 
-    test("should handle null children", () => {
+    test('should handle null children', () => {
       const propDefs: Record<string, PropDefinition> = {
         children: {
-          type: "string",
-          default: "Default"
-        }
+          type: 'string',
+          default: 'Default',
+        },
       };
       const passedProps = {};
       const children = null;
@@ -360,89 +356,89 @@ describe("Prop Resolver - resolveComponentProps", () => {
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
       // null is not an array with length > 0, so should use default
-      expect(result.children).toBe("Default");
+      expect(result.children).toBe('Default');
     });
   });
 
-  describe("Mixed scenarios", () => {
-    test("should resolve Button component props (from Button.json example)", () => {
+  describe('Mixed scenarios', () => {
+    test('should resolve Button component props (from Button.json example)', () => {
       const propDefs: Record<string, PropDefinition> = {
         variant: {
-          type: "select",
-          options: ["primary", "secondary"],
-          default: "primary"
+          type: 'select',
+          options: ['primary', 'secondary'],
+          default: 'primary',
         },
         children: {
-          type: "string",
-          default: "Click me"
+          type: 'string',
+          default: 'Click me',
         },
         size: {
-          type: "select",
-          default: "medium",
-          options: ["medium", "large"]
-        }
+          type: 'select',
+          default: 'medium',
+          options: ['medium', 'large'],
+        },
       };
-      const passedProps = { variant: "secondary" };
+      const passedProps = { variant: 'secondary' };
       const children: (ComponentNode | string)[] = [];
 
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
-      expect(result.variant).toBe("secondary"); // Overridden
-      expect(result.children).toBe("Click me"); // Default used
-      expect(result.size).toBe("medium"); // Default used
+      expect(result.variant).toBe('secondary'); // Overridden
+      expect(result.children).toBe('Click me'); // Default used
+      expect(result.size).toBe('medium'); // Default used
     });
 
-    test("should resolve Button component with all props provided", () => {
+    test('should resolve Button component with all props provided', () => {
       const propDefs: Record<string, PropDefinition> = {
         variant: {
-          type: "select",
-          default: "primary"
+          type: 'select',
+          default: 'primary',
         },
         children: {
-          type: "string",
-          default: "Click me"
+          type: 'string',
+          default: 'Click me',
         },
         size: {
-          type: "select",
-          default: "medium"
-        }
+          type: 'select',
+          default: 'medium',
+        },
       };
-      const passedProps = { variant: "secondary", size: "large" };
-      const children: (ComponentNode | string)[] = ["Custom Button"];
+      const passedProps = { variant: 'secondary', size: 'large' };
+      const children: (ComponentNode | string)[] = ['Custom Button'];
 
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
-      expect(result.variant).toBe("secondary");
-      expect(result.children).toEqual(["Custom Button"]);
-      expect(result.size).toBe("large");
+      expect(result.variant).toBe('secondary');
+      expect(result.children).toEqual(['Custom Button']);
+      expect(result.size).toBe('large');
     });
 
-    test("should handle props with different types mixed", () => {
+    test('should handle props with different types mixed', () => {
       const propDefs: Record<string, PropDefinition> = {
         title: {
-          type: "string",
-          default: "Default Title"
+          type: 'string',
+          default: 'Default Title',
         },
         count: {
-          type: "number",
-          default: 0
+          type: 'number',
+          default: 0,
         },
         isActive: {
-          type: "boolean",
-          default: false
-        }
+          type: 'boolean',
+          default: false,
+        },
       };
       const passedProps = { count: 10 };
       const children: (ComponentNode | string)[] = [];
@@ -450,37 +446,37 @@ describe("Prop Resolver - resolveComponentProps", () => {
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
-      expect(result.title).toBe("Default Title");
+      expect(result.title).toBe('Default Title');
       expect(result.count).toBe(10);
       expect(result.isActive).toBe(false);
     });
   });
 
-  describe("Edge cases", () => {
-    test("should handle empty propDefs object", () => {
+  describe('Edge cases', () => {
+    test('should handle empty propDefs object', () => {
       const propDefs = {};
       const passedProps = {};
       const children: (ComponentNode | string)[] = [];
-      
+
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
-      
+
       expect(Object.keys(result).length).toBe(0);
     });
 
-    test("should handle propDefs with invalid structure", () => {
+    test('should handle propDefs with invalid structure', () => {
       const propDefs: Record<string, PropDefinition> = {
         invalid: null as any,
         valid: {
-          type: "string",
-          default: "value"
-        }
+          type: 'string',
+          default: 'value',
+        },
       };
       const passedProps = {};
       const children: (ComponentNode | string)[] = [];
@@ -488,20 +484,20 @@ describe("Prop Resolver - resolveComponentProps", () => {
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
       // Should skip invalid propDefs and only process valid ones
-      expect(result.valid).toBe("value");
+      expect(result.valid).toBe('value');
       expect(result.invalid).toBeUndefined();
     });
 
     test("should handle propDefs without 'default' key", () => {
       const propDefs: Record<string, PropDefinition> = {
         noDefault: {
-          type: "string"
+          type: 'string',
           // No 'default' key
-        }
+        },
       };
       const passedProps = {};
       const children: (ComponentNode | string)[] = [];
@@ -509,116 +505,116 @@ describe("Prop Resolver - resolveComponentProps", () => {
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
       expect(result.noDefault).toBeUndefined();
     });
 
-    test("should preserve passed props that are not in propDefs", () => {
+    test('should preserve passed props that are not in propDefs', () => {
       const propDefs: Record<string, PropDefinition> = {
         variant: {
-          type: "select",
-          default: "primary"
-        }
+          type: 'select',
+          default: 'primary',
+        },
       };
       const passedProps = {
-        variant: "secondary",
-        extraProp: "extra value"
+        variant: 'secondary',
+        extraProp: 'extra value',
       };
       const children: (ComponentNode | string)[] = [];
 
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
-      expect(result.variant).toBe("secondary");
+      expect(result.variant).toBe('secondary');
       // Extra props are now preserved for backward compatibility (with validation)
-      expect(result.extraProp).toBe("extra value");
+      expect(result.extraProp).toBe('extra value');
     });
   });
 });
 
-describe("Prop Resolver - resolvePropsFromDefinition", () => {
-  describe("Basic usage", () => {
-    test("should resolve props from structured component definition", () => {
+describe('Prop Resolver - resolvePropsFromDefinition', () => {
+  describe('Basic usage', () => {
+    test('should resolve props from structured component definition', () => {
       const componentDef: StructuredComponentDefinition = {
         interface: {
           variant: {
-            type: "select",
-            default: "primary"
-          }
-        }
+            type: 'select',
+            default: 'primary',
+          },
+        },
       };
       const passedProps = {};
       const children: (ComponentNode | string)[] = [];
 
       const result = resolvePropsFromDefinition(componentDef, passedProps, children);
 
-      expect(result.variant).toBe("primary");
+      expect(result.variant).toBe('primary');
     });
 
-    test("should handle missing interface", () => {
+    test('should handle missing interface', () => {
       const componentDef: StructuredComponentDefinition = {
         // No interface
       };
       const passedProps = {};
       const children: (ComponentNode | string)[] = [];
-      
+
       const result = resolvePropsFromDefinition(componentDef, passedProps, children);
-      
+
       expect(Object.keys(result).length).toBe(0);
     });
 
-    test("should handle empty interface", () => {
+    test('should handle empty interface', () => {
       const componentDef: StructuredComponentDefinition = {
-        interface: {}
+        interface: {},
       };
       const passedProps = {};
       const children: (ComponentNode | string)[] = [];
-      
+
       const result = resolvePropsFromDefinition(componentDef, passedProps, children);
-      
+
       expect(Object.keys(result).length).toBe(0);
     });
 
-    test("should use passed props and children", () => {
+    test('should use passed props and children', () => {
       const componentDef: StructuredComponentDefinition = {
         interface: {
           variant: {
-            type: "select",
-            default: "primary"
+            type: 'select',
+            default: 'primary',
           },
           children: {
-            type: "string",
-            default: "Default"
-          }
-        }
+            type: 'string',
+            default: 'Default',
+          },
+        },
       };
-      const passedProps = { variant: "secondary" };
-      const children: (ComponentNode | string)[] = ["Custom"];
+      const passedProps = { variant: 'secondary' };
+      const children: (ComponentNode | string)[] = ['Custom'];
 
       const result = resolvePropsFromDefinition(componentDef, passedProps, children);
 
-      expect(result.variant).toBe("secondary");
-      expect(result.children).toEqual(["Custom"]);
+      expect(result.variant).toBe('secondary');
+      expect(result.children).toEqual(['Custom']);
     });
   });
 
-  describe("i18n resolution", () => {
+  describe('i18n resolution', () => {
     const i18nConfig: I18nConfig = {
       defaultLocale: 'en',
       locales: [
         { code: 'en', name: 'English', nativeName: 'English', langTag: 'en-US' },
-        { code: 'es', name: 'Spanish', nativeName: 'Español', langTag: 'es-ES' }
-      ]
+        { code: 'es', name: 'Spanish', nativeName: 'Español', langTag: 'es-ES' },
+      ],
     };
 
-    test("should resolve I18nValue for string type", () => {
+    test('should resolve I18nValue for string type', () => {
       const propDefs: Record<string, PropDefinition> = {
-        title: { type: "string", default: "Default Title" }
+        title: { type: 'string', default: 'Default Title' },
       };
       const passedProps = { title: { _i18n: true, en: 'Hello', es: 'Hola' } };
       const children: (ComponentNode | string)[] = [];
@@ -628,15 +624,15 @@ describe("Prop Resolver - resolvePropsFromDefinition", () => {
         passedProps,
         children,
         locale: 'es',
-        i18nConfig
+        i18nConfig,
       });
 
       expect(result.title).toBe('Hola');
     });
 
-    test("should fall back to default locale when requested locale missing", () => {
+    test('should fall back to default locale when requested locale missing', () => {
       const propDefs: Record<string, PropDefinition> = {
-        title: { type: "string", default: "Default Title" }
+        title: { type: 'string', default: 'Default Title' },
       };
       const passedProps = { title: { _i18n: true, en: 'Hello' } }; // No 'es'
       const children: (ComponentNode | string)[] = [];
@@ -646,15 +642,15 @@ describe("Prop Resolver - resolvePropsFromDefinition", () => {
         passedProps,
         children,
         locale: 'es',
-        i18nConfig
+        i18nConfig,
       });
 
       expect(result.title).toBe('Hello'); // Falls back to 'en'
     });
 
-    test("should resolve I18nValue and wrap rich-text", () => {
+    test('should resolve I18nValue and wrap rich-text', () => {
       const propDefs: Record<string, PropDefinition> = {
-        text: { type: "rich-text", default: "Default Text" }
+        text: { type: 'rich-text', default: 'Default Text' },
       };
       const passedProps = { text: { _i18n: true, en: '<b>Bold</b>', es: 'Test' } };
       const children: (ComponentNode | string)[] = [];
@@ -664,7 +660,7 @@ describe("Prop Resolver - resolvePropsFromDefinition", () => {
         passedProps,
         children,
         locale: 'es',
-        i18nConfig
+        i18nConfig,
       });
 
       // Should be wrapped in RichTextMarker after i18n resolution
@@ -673,9 +669,9 @@ describe("Prop Resolver - resolvePropsFromDefinition", () => {
       expect((result.text as any).format).toBe('html');
     });
 
-    test("should wrap plain rich-text string in RichTextMarker", () => {
+    test('should wrap plain rich-text string in RichTextMarker', () => {
       const propDefs: Record<string, PropDefinition> = {
-        text: { type: "rich-text", default: "Default Text" }
+        text: { type: 'rich-text', default: 'Default Text' },
       };
       const passedProps = { text: '<b>Bold text</b>' };
       const children: (ComponentNode | string)[] = [];
@@ -683,7 +679,7 @@ describe("Prop Resolver - resolvePropsFromDefinition", () => {
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
       // Should be wrapped in RichTextMarker
@@ -692,9 +688,9 @@ describe("Prop Resolver - resolvePropsFromDefinition", () => {
       expect((result.text as any).format).toBe('html');
     });
 
-    test("should NOT wrap empty rich-text string", () => {
+    test('should NOT wrap empty rich-text string', () => {
       const propDefs: Record<string, PropDefinition> = {
-        text: { type: "rich-text", default: "" }
+        text: { type: 'rich-text', default: '' },
       };
       const passedProps = { text: '' };
       const children: (ComponentNode | string)[] = [];
@@ -702,7 +698,7 @@ describe("Prop Resolver - resolvePropsFromDefinition", () => {
       const result = resolveComponentProps({
         propDefs,
         passedProps,
-        children
+        children,
       });
 
       // Empty strings should not be wrapped
@@ -711,34 +707,34 @@ describe("Prop Resolver - resolvePropsFromDefinition", () => {
     });
   });
 
-  describe("Integration with Button.json structure", () => {
-    test("should resolve Button component props correctly", () => {
+  describe('Integration with Button.json structure', () => {
+    test('should resolve Button component props correctly', () => {
       const componentDef: StructuredComponentDefinition = {
         interface: {
           variant: {
-            type: "select",
-            options: ["primary", "secondary"],
-            default: "primary"
+            type: 'select',
+            options: ['primary', 'secondary'],
+            default: 'primary',
           },
           children: {
-            type: "string",
-            default: "Click me"
+            type: 'string',
+            default: 'Click me',
           },
           size: {
-            type: "select",
-            default: "medium",
-            options: ["medium", "large"]
-          }
-        }
+            type: 'select',
+            default: 'medium',
+            options: ['medium', 'large'],
+          },
+        },
       };
-      const passedProps = { variant: "secondary" };
+      const passedProps = { variant: 'secondary' };
       const children: (ComponentNode | string)[] = [];
 
       const result = resolvePropsFromDefinition(componentDef, passedProps, children);
 
-      expect(result.variant).toBe("secondary");
-      expect(result.children).toBe("Click me");
-      expect(result.size).toBe("medium");
+      expect(result.variant).toBe('secondary');
+      expect(result.children).toBe('Click me');
+      expect(result.size).toBe('medium');
     });
   });
 });