@builder.io/mitosis 0.0.0-dev-20260605060721

package/dist/src/generators/swift/blocks.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blockToSwift = void 0;
+const helpers_1 = require("./helpers");
+// Helper function to sanitize text content for SwiftUI
+const sanitizeTextForSwift = (text) => {
+    if (!text)
+        return '""';
+    // Check if text contains newlines
+    if (text.includes('\n')) {
+        // Use triple quotes for multiline strings
+        return `"""${text}"""`;
+    }
+    // Escape double quotes in the text
+    return `"${text.replace(/"/g, '\\"')}"`;
+};
+const blockToSwift = ({ json, options, parentComponent, }) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    if (json.properties._text) {
+        return `Text(${sanitizeTextForSwift(json.properties._text)})`;
+    }
+    const tag = json.name;
+    // For fragments, render children without a wrapper
+    if (tag === 'Fragment') {
+        return json.children
+            .map((child) => (0, exports.blockToSwift)({ json: child, options, parentComponent }))
+            .join('\n');
+    }
+    // Process bindings and properties - use parentComponent here instead of json
+    const processCode = (0, helpers_1.stripStateAndProps)({ json: parentComponent, options });
+    // Handle ForEach blocks - use bindings.each pattern like other generators
+    if ((_a = json.bindings.each) === null || _a === void 0 ? void 0 : _a.code) {
+        const { collection, itemName, indexName } = (0, helpers_1.getForEachParams)(json, processCode);
+        const forEachContent = json.children
+            .map((child) => (0, exports.blockToSwift)({ json: child, options, parentComponent }))
+            .join('\n');
+        // Check if the collection is using Array.from({length: X}) pattern
+        const arrayFromMatch = collection.match(/Array\.from\(\s*\{\s*length:\s*(\d+)\s*\}\s*\)/);
+        if (arrayFromMatch) {
+            // Convert to SwiftUI's ForEach with a range
+            const length = arrayFromMatch[1];
+            if (indexName) {
+                // With index
+                return `ForEach(0..<${length}, id: \\.self) { ${indexName} in
+  let ${itemName} = ${indexName}
+  ${forEachContent}
+}`;
+            }
+            else {
+                // Without index
+                return `ForEach(0..<${length}, id: \\.self) { ${itemName} in
+  ${forEachContent}
+}`;
+            }
+        }
+        else {
+            // Standard collection-based ForEach
+            if (indexName) {
+                return `ForEach(Array(zip(${collection}.indices, ${collection})), id: \\.0) { ${indexName}, ${itemName} in
+  ${forEachContent}
+}`;
+            }
+            else {
+                return `ForEach(${collection}, id: \\.self) { ${itemName} in
+  ${forEachContent}
+}`;
+            }
+        }
+    }
+    // Determine the SwiftUI component name
+    const component = (0, helpers_1.jsxElementToSwiftUIView)(tag);
+    // Handle children
+    const hasChildren = json.children && json.children.length > 0;
+    // Handle event handlers
+    const eventHandlers = Object.entries(json.bindings)
+        .filter(([key]) => { var _a; return key.startsWith('on') && ((_a = json.bindings[key]) === null || _a === void 0 ? void 0 : _a.code); })
+        .map(([key, binding]) => {
+        const swiftEventName = (0, helpers_1.getEventHandlerName)(key);
+        return `.${swiftEventName}(${processCode((binding === null || binding === void 0 ? void 0 : binding.code) || '')})`;
+    });
+    // Handle data bindings (like bind:value)
+    const dataBindings = Object.entries(json.bindings)
+        .filter(([key]) => { var _a; return key.startsWith('bind:') && ((_a = json.bindings[key]) === null || _a === void 0 ? void 0 : _a.code); })
+        .map(([key, binding]) => {
+        const bindingType = (0, helpers_1.getBindingType)(key);
+        const bindingValue = processCode((binding === null || binding === void 0 ? void 0 : binding.code) || '');
+        return { type: bindingType, value: bindingValue };
+    });
+    // Handle style properties
+    const styleModifiers = [];
+    if (json.bindings.style) {
+        // Dynamic styles
+        styleModifiers.push(`// Dynamic styles not fully implemented`);
+        styleModifiers.push(`.modifier(/* Dynamic style handling needed here */)"`);
+    }
+    else if (json.properties.style) {
+        // Static styles
+        try {
+            const styleObj = JSON.parse(json.properties.style);
+            styleModifiers.push(...(0, helpers_1.cssToSwiftUIModifiers)(styleObj));
+        }
+        catch (e) {
+            styleModifiers.push(`// Could not parse style: ${json.properties.style}`);
+        }
+    }
+    // Check if we need a ScrollView
+    const needsScroll = (0, helpers_1.needsScrollView)(json);
+    // Conditional rendering
+    let result = '';
+    if ((_b = json.bindings.if) === null || _b === void 0 ? void 0 : _b.code) {
+        result += `if ${processCode(json.bindings.if.code)} {\n`;
+    }
+    else if ((_c = json.bindings.show) === null || _c === void 0 ? void 0 : _c.code) {
+        // In SwiftUI we can use opacity for show/hide
+        styleModifiers.push(`.opacity(${processCode(json.bindings.show.code)} ? 1 : 0)`);
+    }
+    // Start building the component
+    let componentCode = '';
+    switch (component) {
+        case 'Text':
+            // Text components in SwiftUI need their content as a parameter
+            let textContent = '';
+            if (json.properties._text) {
+                textContent = sanitizeTextForSwift(json.properties._text);
+            }
+            else if ((_d = json.bindings.innerHTML) === null || _d === void 0 ? void 0 : _d.code) {
+                // For dynamic content, we'll need to handle it as an expression
+                textContent = processCode(json.bindings.innerHTML.code);
+            }
+            else {
+                textContent = '""';
+            }
+            componentCode = `Text(${textContent})`;
+            break;
+        case 'Button':
+            // Find the action from eventHandlers or create an empty one
+            let buttonAction = '{}';
+            const onClickHandler = eventHandlers.find((h) => h.includes('onTapGesture'));
+            if (onClickHandler) {
+                buttonAction = onClickHandler.replace('.onTapGesture(', '').replace(')', '');
+                // Remove this handler from the list since we're using it directly
+                eventHandlers.splice(eventHandlers.indexOf(onClickHandler), 1);
+            }
+            const buttonLabel = hasChildren
+                ? json.children
+                    .map((child) => (0, exports.blockToSwift)({ json: child, options, parentComponent }))
+                    .join('\n')
+                : `Text("${json.properties._text || 'Button'}")`;
+            componentCode = `Button(action: { ${buttonAction} }) {\n${buttonLabel}\n}`;
+            break;
+        case 'TextField':
+            // TextField can have either bind:value or direct value binding
+            let bindingExpression = '';
+            // First check for explicit bind:value
+            const textBinding = dataBindings.find((b) => b.type === 'value');
+            // If not found, check for direct value binding
+            const directValueBinding = ((_e = json.bindings.value) === null || _e === void 0 ? void 0 : _e.code)
+                ? processCode(json.bindings.value.code)
+                : null;
+            if (textBinding) {
+                // Use the explicit binding from dataBindings
+                bindingExpression = textBinding.value;
+            }
+            else if (directValueBinding) {
+                // Use direct value binding
+                bindingExpression = directValueBinding;
+            }
+            if (bindingExpression) {
+                // Convert to SwiftUI binding syntax
+                bindingExpression = bindingExpression.replace(/self\.(\w+)/g, '$$$1');
+                // If it still doesn't start with $, add it
+                if (!bindingExpression.startsWith('$')) {
+                    bindingExpression = `$${bindingExpression}`;
+                }
+                componentCode = `TextField("${json.properties.placeholder || ''}", text: ${bindingExpression})`;
+            }
+            else {
+                // No binding found, use constant value
+                componentCode = `TextField("${json.properties.placeholder || ''}", text: .constant("${json.properties.value || ''}"))`;
+            }
+            break;
+        case 'Image':
+            // Determine if using system image, URL, or asset
+            if ((_f = json.properties.src) === null || _f === void 0 ? void 0 : _f.startsWith('system-')) {
+                // System image
+                const systemName = json.properties.src.replace('system-', '');
+                componentCode = `Image(systemName: "${systemName}")`;
+            }
+            else if ((_g = json.properties.src) === null || _g === void 0 ? void 0 : _g.startsWith('http')) {
+                // URL image (requires AsyncImage)
+                componentCode = `AsyncImage(url: URL(string: "${json.properties.src}")!) { image in
+          image.resizable()
+        } placeholder: {
+          ProgressView()
+        }`;
+            }
+            else {
+                // Asset image
+                componentCode = `Image("${json.properties.src || 'placeholder'}")`;
+            }
+            if (json.properties.resizeMode) {
+                componentCode += `.resizable().aspectRatio(contentMode: .${json.properties.resizeMode})`;
+            }
+            else if (!((_h = json.properties.src) === null || _h === void 0 ? void 0 : _h.startsWith('http'))) {
+                // Add resizable for non-async images without specific mode
+                componentCode += `.resizable().aspectRatio(contentMode: .fit)`;
+            }
+            break;
+        case 'VStack':
+        case 'HStack':
+        case 'ZStack':
+            // Stacks with children
+            const alignment = json.properties.alignment || 'leading';
+            const spacing = json.properties.spacing || '8';
+            componentCode = `${component}(alignment: .${alignment}, spacing: ${spacing}) {\n`;
+            if (hasChildren) {
+                componentCode += json.children
+                    .map((child) => {
+                    return (0, exports.blockToSwift)({ json: child, options, parentComponent });
+                })
+                    .join('\n');
+            }
+            componentCode += '\n}';
+            break;
+        case 'List':
+            // Lists in SwiftUI
+            componentCode = `List {\n`;
+            if (hasChildren) {
+                componentCode += json.children
+                    .map((child) => {
+                    return (0, exports.blockToSwift)({ json: child, options, parentComponent });
+                })
+                    .join('\n');
+            }
+            componentCode += '\n}';
+            break;
+        case 'Picker':
+            // Handle select element
+            // Pickers in SwiftUI need a selection binding, a label, and content
+            const selectBinding = dataBindings.find((b) => b.type === 'value');
+            const selectionVar = selectBinding ? selectBinding.value : '.constant("")';
+            // Create label from the "label" property or a default
+            const pickerLabel = json.properties.label
+                ? `Text("${json.properties.label}")`
+                : 'Text("Select")';
+            // Start building the picker
+            componentCode = `Picker(selection: Binding(get: { ${selectionVar} }, set: { ${selectionVar} = $0 }), label: { ${pickerLabel} }) {`;
+            // Add options as children
+            if (hasChildren) {
+                json.children.forEach((child) => {
+                    var _a;
+                    // For option elements, extract the value and text
+                    if (((_a = child.name) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'option') {
+                        const optionValue = child.properties.value || '';
+                        const optionText = child.properties._text || optionValue;
+                        componentCode += `\nText("${optionText}").tag("${optionValue}")`;
+                    }
+                    else {
+                        // Handle non-option children (unusual but possible)
+                        componentCode += `\n${(0, exports.blockToSwift)({ json: child, options, parentComponent })}`;
+                    }
+                });
+            }
+            componentCode += '\n}';
+            break;
+        default:
+            // Custom components or other SwiftUI views
+            if (hasChildren) {
+                componentCode = `${component} {\n`;
+                componentCode += json.children
+                    .map((child) => {
+                    return (0, exports.blockToSwift)({ json: child, options, parentComponent });
+                })
+                    .join('\n');
+                componentCode += '\n}';
+            }
+            else {
+                componentCode = `${component}()`;
+            }
+    }
+    // Apply modifiers
+    styleModifiers.forEach((modifier) => {
+        componentCode += `\n${modifier}`;
+    });
+    // Add event handlers that weren't specifically handled above
+    eventHandlers
+        .filter((handler) => !componentCode.includes(handler))
+        .forEach((handler) => {
+        componentCode += `\n${handler}`;
+    });
+    // Wrap with ScrollView if needed
+    if (needsScroll) {
+        componentCode = `ScrollView {\n${componentCode}\n}`;
+    }
+    // Close conditional rendering block if needed
+    if ((_j = json.bindings.if) === null || _j === void 0 ? void 0 : _j.code) {
+        result += componentCode + '\n}';
+    }
+    else {
+        result += componentCode;
+    }
+    return result;
+};
+exports.blockToSwift = blockToSwift;

package/dist/src/generators/swift/generator.d.ts

@@ -0,0 +1,3 @@
+import { TranspilerGenerator } from '../../types/transpiler';
+import { ToSwiftOptions } from './types';
+export declare const componentToSwift: TranspilerGenerator<ToSwiftOptions>;

package/dist/src/generators/swift/generator.js

@@ -0,0 +1,287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.componentToSwift = void 0;
+const dedent_1 = require("../../helpers/dedent");
+const fast_clone_1 = require("../../helpers/fast-clone");
+const generic_format_1 = require("../../helpers/generic-format");
+const get_props_1 = require("../../helpers/get-props");
+const get_refs_1 = require("../../helpers/get-refs");
+const getters_to_functions_1 = require("../../helpers/getters-to-functions");
+const merge_options_1 = require("../../helpers/merge-options");
+const on_event_1 = require("../../helpers/on-event");
+const patterns_1 = require("../../helpers/patterns");
+const process_code_1 = require("../../helpers/plugins/process-code");
+const slots_1 = require("../../helpers/slots");
+const strip_meta_properties_1 = require("../../helpers/strip-meta-properties");
+const plugins_1 = require("../../modules/plugins");
+const blocks_1 = require("./blocks");
+const helpers_1 = require("./helpers");
+const DEFAULT_OPTIONS = {
+    stateType: 'state',
+    formatCode: true,
+    includeTypes: true,
+    includePreview: true,
+    classPrefix: '',
+};
+const componentToSwift = (userProvidedOptions) => ({ component }) => {
+    var _a, _b;
+    const options = (0, merge_options_1.initializeOptions)({
+        target: 'swift',
+        component,
+        defaults: DEFAULT_OPTIONS,
+        userOptions: userProvidedOptions,
+    });
+    options.plugins = [
+        ...(options.plugins || []),
+        (0, on_event_1.processOnEventHooksPlugin)(),
+        (0, process_code_1.CODE_PROCESSOR_PLUGIN)((codeType) => {
+            switch (codeType) {
+                case 'bindings':
+                case 'properties':
+                case 'hooks':
+                case 'hooks-deps':
+                case 'hooks-deps-array':
+                case 'state':
+                case 'context-set':
+                case 'dynamic-jsx-elements':
+                case 'types':
+                    return (x) => (0, helpers_1.convertConsoleLogToPrint)(x);
+            }
+        }),
+        (0, process_code_1.CODE_PROCESSOR_PLUGIN)((codeType) => {
+            switch (codeType) {
+                case 'hooks':
+                    return (code) => (0, helpers_1.stripStateAndProps)({ json, options })(code);
+                case 'bindings':
+                case 'hooks-deps':
+                case 'state':
+                    return (code) => (0, patterns_1.stripGetter)((0, helpers_1.stripStateAndProps)({ json, options })(code));
+                case 'properties':
+                case 'context-set':
+                    return (code) => (0, helpers_1.stripStateAndProps)({ json, options })(code);
+                case 'dynamic-jsx-elements':
+                case 'hooks-deps-array':
+                case 'types':
+                    return (x) => (0, helpers_1.convertConsoleLogToPrint)(x);
+            }
+        }),
+    ];
+    // Make a copy we can safely mutate
+    let json = (0, fast_clone_1.fastClone)(component);
+    json = (0, plugins_1.runPreJsonPlugins)({ json, plugins: options.plugins });
+    (0, getters_to_functions_1.gettersToFunctions)(json);
+    const componentName = options.classPrefix + (json.name || ((_a = json.meta.useMetadata) === null || _a === void 0 ? void 0 : _a.name) || 'MitosisComponent');
+    // Process props
+    const filteredProps = Array.from((0, get_props_1.getProps)(json)).filter((prop) => !(0, slots_1.isSlotProperty)(prop));
+    const props = Array.from(new Set(filteredProps));
+    // Process refs (not directly applicable in SwiftUI, will be converted to @State)
+    const refs = Array.from((0, get_refs_1.getRefs)(json))
+        .map((0, helpers_1.stripStateAndProps)({ json, options }))
+        .filter((x) => !props.includes(x));
+    json = (0, plugins_1.runPostJsonPlugins)({ json, plugins: options.plugins });
+    (0, strip_meta_properties_1.stripMetaProperties)(json);
+    // Generate state variables
+    const stateProperties = Object.entries(json.state)
+        .filter(([_, value]) => {
+        // Skip methods - they'll be handled separately
+        return !((value === null || value === void 0 ? void 0 : value.type) === 'method' ||
+            ((value === null || value === void 0 ? void 0 : value.code) && (value.code.includes('function') || value.code.includes('=>'))));
+    })
+        .map(([key, value]) => {
+        var _a, _b, _c, _d, _e;
+        // Check for value properties safely
+        const propertyType = value === null || value === void 0 ? void 0 : value.propertyType;
+        // Determine Swift type - handle missing type property
+        let valueType = 'Any';
+        if (value === null || value === void 0 ? void 0 : value.typeParameter) {
+            valueType = value.typeParameter;
+        }
+        else {
+            // Try to infer type from code if possible
+            if (((_a = value === null || value === void 0 ? void 0 : value.code) === null || _a === void 0 ? void 0 : _a.includes('"')) || ((_b = value === null || value === void 0 ? void 0 : value.code) === null || _b === void 0 ? void 0 : _b.includes("'"))) {
+                valueType = 'string';
+            }
+            else if ((_c = value === null || value === void 0 ? void 0 : value.code) === null || _c === void 0 ? void 0 : _c.match(/^[0-9]+(\.[0-9]+)?$/)) {
+                valueType = 'number';
+            }
+            else if ((value === null || value === void 0 ? void 0 : value.code) === 'true' || (value === null || value === void 0 ? void 0 : value.code) === 'false') {
+                valueType = 'boolean';
+            }
+            else if (((_d = value === null || value === void 0 ? void 0 : value.code) === null || _d === void 0 ? void 0 : _d.startsWith('[')) || ((_e = value === null || value === void 0 ? void 0 : value.code) === null || _e === void 0 ? void 0 : _e.startsWith('Array'))) {
+                valueType = 'Array<Any>';
+            }
+        }
+        const typeAnnotation = (0, helpers_1.getStatePropertyTypeAnnotation)(propertyType, valueType);
+        const swiftType = (0, helpers_1.getSwiftType)(valueType);
+        let stateDeclaration = `${typeAnnotation} ${key}: ${swiftType}`;
+        // Add default value if present
+        if (value === null || value === void 0 ? void 0 : value.code) {
+            stateDeclaration += ` = ${value.code}`;
+        }
+        else {
+            // Add default initialization based on type
+            switch (swiftType) {
+                case 'String':
+                    stateDeclaration += ' = ""';
+                    break;
+                case 'Bool':
+                    stateDeclaration += ' = false';
+                    break;
+                case 'Double':
+                case 'Int':
+                    stateDeclaration += ' = 0';
+                    break;
+                case 'Array<String>':
+                case '[String]':
+                    stateDeclaration += ' = []';
+                    break;
+                default:
+                    if (swiftType.includes('Array') || swiftType.includes('[')) {
+                        stateDeclaration += ' = []';
+                    }
+                    else if (swiftType !== 'Any' && swiftType !== 'Void') {
+                        stateDeclaration += '/* initialize with appropriate default */';
+                    }
+            }
+        }
+        return stateDeclaration;
+    })
+        .join('\n  ');
+    // Generate state function variables with inline closure assignment
+    const functionStateProperties = [];
+    Object.entries(json.state)
+        .filter(([_, value]) => {
+        return ((value === null || value === void 0 ? void 0 : value.type) === 'method' ||
+            ((value === null || value === void 0 ? void 0 : value.code) && (value.code.includes('function') || value.code.includes('=>'))));
+    })
+        .forEach(([key, value]) => {
+        if (!(value === null || value === void 0 ? void 0 : value.code)) {
+            // Handle empty function with inline closure
+            functionStateProperties.push(`private var ${key}: () -> Void = { () in /* Empty function */ }`);
+            return;
+        }
+        // Convert the JS function to Swift
+        const processedCode = (0, helpers_1.stripStateAndProps)({ json, options })(value.code);
+        const { swiftCode, signature } = (0, helpers_1.convertJsFunctionToSwift)(processedCode, `_${key}`);
+        // Parse signature to get parameter list and return type
+        const signatureMatch = signature.match(/func _([^(]+)\(([^)]*)\) -> ([^{]+)/);
+        if (signatureMatch) {
+            const [, funcName, params, returnType] = signatureMatch;
+            // Create the function type for the state variable
+            const paramTypes = params
+                ? params
+                    .split(',')
+                    .map((p) => { var _a; return ((_a = p.trim().split(':')[1]) === null || _a === void 0 ? void 0 : _a.trim()) || 'Any'; })
+                    .join(', ')
+                : '';
+            const functionType = params
+                ? `(${paramTypes}) -> ${returnType.trim()}`
+                : `() -> ${returnType.trim()}`;
+            // Extract function body from swiftCode
+            const bodyMatch = swiftCode.match(/{\s*([\s\S]*?)\s*}/);
+            const functionBody = bodyMatch ? bodyMatch[1].trim() : '/* Empty function body */';
+            // Build closure syntax for inline assignment
+            const closureSyntax = params
+                ? `{ (${params}) -> ${returnType.trim()} in\n    ${functionBody}\n  }`
+                : `{ () -> ${returnType.trim()} in\n    ${functionBody}\n  }`;
+            // Add the state variable declaration with inline closure assignment
+            functionStateProperties.push(`var ${key}: ${functionType} = ${closureSyntax}`);
+        }
+        else {
+            // Fallback if signature parsing fails
+            functionStateProperties.push(`var ${key}: () -> Void = { () in /* Could not parse function */ }`);
+        }
+    });
+    // Process lifecycle methods
+    const lifecycleMethods = [];
+    // Only add onInit if needed and if there are no function state properties
+    // (to avoid duplicate initializers)
+    if ((_b = json.hooks.onInit) === null || _b === void 0 ? void 0 : _b.code) {
+        lifecycleMethods.push((0, dedent_1.dedent) `
+        init() {
+          ${json.hooks.onInit.code}
+        }
+      `);
+    }
+    // Generate SwiftUI component
+    let str = (0, dedent_1.dedent) `
+      import SwiftUI
+
+      struct ${componentName}: View {
+        ${props
+        .map((prop) => {
+        var _a, _b, _c, _d;
+        const propType = ((_b = (_a = json.props) === null || _a === void 0 ? void 0 : _a[prop]) === null || _b === void 0 ? void 0 : _b.propertyType) || 'Any';
+        const swiftType = (0, helpers_1.getSwiftType)(propType);
+        return `let ${prop}: ${swiftType}${((_d = (_c = json.props) === null || _c === void 0 ? void 0 : _c[prop]) === null || _d === void 0 ? void 0 : _d.optional) ? '?' : ''}`;
+    })
+        .join('\n  ')}
+        
+        ${stateProperties}
+        ${functionStateProperties.length > 0
+        ? '\n  // Function state variables\n  ' + functionStateProperties.join('\n  ')
+        : ''}
+        
+        var body: some View {
+          ${json.children
+        .map((item) => (0, blocks_1.blockToSwift)({
+        json: item,
+        options: options,
+        parentComponent: json,
+    }))
+        .join('\n')}
+          ${lifecycleMethods.filter((method) => method.startsWith('.')).join('\n  ')}
+        }
+        
+        ${lifecycleMethods.filter((method) => !method.startsWith('.')).join('\n  ')}
+      }
+    `;
+    // Add preview if enabled
+    if (options.includePreview) {
+        str += (0, dedent_1.dedent) `
+        \n
+        #if DEBUG
+        struct ${componentName}_Previews: PreviewProvider {
+          static var previews: some View {
+            ${componentName}(
+              ${props
+            .map((prop) => {
+            var _a, _b, _c, _d;
+            const propType = ((_b = (_a = json.props) === null || _a === void 0 ? void 0 : _a[prop]) === null || _b === void 0 ? void 0 : _b.propertyType) || 'Any';
+            const swiftType = (0, helpers_1.getSwiftType)(propType);
+            // Generate appropriate preview values based on type
+            let previewValue = '';
+            switch (swiftType) {
+                case 'String':
+                    previewValue = '"Preview"';
+                    break;
+                case 'Bool':
+                    previewValue = 'false';
+                    break;
+                case 'Double':
+                case 'Int':
+                    previewValue = '0';
+                    break;
+                default:
+                    if ((_d = (_c = json.props) === null || _c === void 0 ? void 0 : _c[prop]) === null || _d === void 0 ? void 0 : _d.optional) {
+                        previewValue = 'nil';
+                    }
+                    else {
+                        previewValue = '/* provide preview value */';
+                    }
+            }
+            return `${prop}: ${previewValue}`;
+        })
+            .join(',\n              ')}
+            )
+          }
+        }
+        #endif
+      `;
+    }
+    str = (0, plugins_1.runPreCodePlugins)({ json, code: str, plugins: options.plugins });
+    str = (0, generic_format_1.format)(str);
+    str = (0, plugins_1.runPostCodePlugins)({ json, code: str, plugins: options.plugins });
+    return str;
+};
+exports.componentToSwift = componentToSwift;

package/dist/src/generators/swift/helpers.d.ts

@@ -0,0 +1,42 @@
+import { MitosisComponent } from '../../types/mitosis-component';
+import { MitosisNode } from '../../types/mitosis-node';
+import { ToSwiftOptions } from './types';
+export declare const convertConsoleLogToPrint: (code: string) => string;
+export declare const ensureSwiftStringFormat: (code: string) => string;
+export declare const stripStateAndProps: ({ json, options, }: {
+    json: MitosisComponent;
+    options: ToSwiftOptions;
+}) => (code: string) => string;
+export declare const getSwiftType: (type: string | undefined) => string;
+export declare const jsxElementToSwiftUIView: (tagName: string) => string;
+export declare const cssToSwiftUIModifiers: (style: Record<string, string>) => string[];
+export declare const getStatePropertyTypeAnnotation: (propertyType: string | undefined, type: string | undefined) => string;
+export declare const getEventHandlerName: (eventName: string) => string;
+export declare const needsScrollView: (json: MitosisNode) => boolean;
+export declare const isForEachBlock: (json: MitosisNode) => boolean;
+export declare const getForEachParams: (json: MitosisNode, processCode: (code: string) => string) => {
+    collection: string;
+    itemName: string;
+    indexName: string | null;
+};
+export declare const camelToSnakeCase: (str: string) => string;
+export declare const getBindingType: (key: string) => string;
+/**
+ * Extract function signature information from JavaScript function code
+ */
+export declare const extractFunctionSignature: (code: string) => {
+    name: string;
+    params: {
+        name: string;
+        type: string;
+    }[];
+    returnType: string;
+    body: string;
+};
+/**
+ * Convert JavaScript function code to Swift function syntax
+ */
+export declare const convertJsFunctionToSwift: (code: string, functionName?: string) => {
+    swiftCode: string;
+    signature: string;
+};