@builder.io/mitosis 0.0.0-dev-20260605060721

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

@@ -0,0 +1,412 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertJsFunctionToSwift = exports.extractFunctionSignature = exports.getBindingType = exports.camelToSnakeCase = exports.getForEachParams = exports.isForEachBlock = exports.needsScrollView = exports.getEventHandlerName = exports.getStatePropertyTypeAnnotation = exports.cssToSwiftUIModifiers = exports.jsxElementToSwiftUIView = exports.getSwiftType = exports.stripStateAndProps = exports.ensureSwiftStringFormat = exports.convertConsoleLogToPrint = void 0;
+const capitalize_1 = require("../../helpers/capitalize");
+const strip_state_and_props_refs_1 = require("../../helpers/strip-state-and-props-refs");
+// TODO(kyle): use babel here to do ast
+const convertConsoleLogToPrint = (code) => {
+    if (!code)
+        return code;
+    // Match console.log statements with various argument patterns
+    return code.replace(/console\.log\s*\(\s*(.*?)\s*\)/g, (match, args) => {
+        // Handle empty console.log()
+        if (!args.trim()) {
+            return 'print()';
+        }
+        // Simple handling for basic console.log calls
+        // For complex cases, we'd need a more sophisticated parser
+        return `print(${(0, exports.ensureSwiftStringFormat)(args)})`;
+    });
+};
+exports.convertConsoleLogToPrint = convertConsoleLogToPrint;
+// Helper function to ensure Swift strings use double quotes
+const ensureSwiftStringFormat = (code) => {
+    if (!code)
+        return code;
+    // We need a more reliable approach to handle nested quotes
+    // This uses a state machine approach to track whether we're inside double quotes
+    let result = '';
+    let insideDoubleQuotes = false;
+    for (let i = 0; i < code.length; i++) {
+        const char = code[i];
+        const prevChar = i > 0 ? code[i - 1] : '';
+        // Handle quote state tracking
+        if (char === '"' && prevChar !== '\\') {
+            insideDoubleQuotes = !insideDoubleQuotes;
+            result += char;
+        }
+        // Only replace single quotes when not inside double quotes
+        else if (char === "'" && prevChar !== '\\' && !insideDoubleQuotes) {
+            // Start of a single-quoted string
+            result += '"';
+            // Find the end of the single-quoted string, accounting for escaped quotes
+            let j = i + 1;
+            while (j < code.length) {
+                if (code[j] === "'" && code[j - 1] !== '\\') {
+                    break;
+                }
+                j++;
+            }
+            // Add the string content
+            result += code.substring(i + 1, j);
+            // Add closing double quote if we found the end
+            if (j < code.length) {
+                result += '"';
+                i = j; // Skip to the end of the single-quoted string
+            }
+            else {
+                // If no closing quote was found, just add the single quote as is
+                result = result.substring(0, result.length - 1) + "'";
+            }
+        }
+        else {
+            result += char;
+        }
+    }
+    return result;
+};
+exports.ensureSwiftStringFormat = ensureSwiftStringFormat;
+const stripStateAndProps = ({ json, options, }) => {
+    return (code) => {
+        // Convert console.log statements to Swift print
+        code = (0, exports.convertConsoleLogToPrint)(code);
+        // Ensure Swift strings use double quotes
+        code = (0, exports.ensureSwiftStringFormat)(code);
+        // In Swift, we use self.propertyName for accessing properties
+        return (0, strip_state_and_props_refs_1.stripStateAndPropsRefs)(code, {
+            includeState: true,
+            includeProps: true,
+            replaceWith: (name) => {
+                // In Swift, we access properties with self.propertyName
+                return `self.${name}`;
+            },
+        });
+    };
+};
+exports.stripStateAndProps = stripStateAndProps;
+const getSwiftType = (type) => {
+    if (!type)
+        return 'Any';
+    // Handle array types with proper Swift syntax
+    if (type.includes('Array<') || type.includes('[]') || type.toLowerCase().startsWith('array')) {
+        // Extract the element type from Array<ElementType>
+        let elementType = 'Any';
+        // Match different array type patterns
+        const arrayMatch = type.match(/Array<([^>]+)>/i) ||
+            type.match(/([^[\]]+)\[\]/i) ||
+            type.match(/array\s*<([^>]+)>/i);
+        if (arrayMatch && arrayMatch[1]) {
+            elementType = (0, exports.getSwiftType)(arrayMatch[1].trim());
+        }
+        // Return Swift array type: [ElementType]
+        return `[${elementType}]`;
+    }
+    // Handle primitive types
+    switch (type.toLowerCase()) {
+        case 'string':
+            return 'String';
+        case 'number':
+            return 'Double';
+        case 'boolean':
+        case 'bool':
+            return 'Bool';
+        case 'any':
+            return 'Any';
+        case 'void':
+            return 'Void';
+        case 'object':
+            return '[String: Any]';
+        case 'null':
+        case 'undefined':
+            return 'Optional<Any>';
+        default:
+            // For complex types, return as is with first letter capitalized
+            return type.charAt(0).toUpperCase() + type.slice(1);
+    }
+};
+exports.getSwiftType = getSwiftType;
+const jsxElementToSwiftUIView = (tagName) => {
+    // Map JSX/HTML elements to SwiftUI components
+    switch (tagName.toLowerCase()) {
+        case 'div':
+            return 'VStack';
+        case 'span':
+        case 'p':
+        case 'h1':
+        case 'h2':
+        case 'h3':
+        case 'h4':
+        case 'h5':
+        case 'h6':
+            return 'Text';
+        case 'img':
+            return 'Image';
+        case 'input':
+            return 'TextField';
+        case 'button':
+            return 'Button';
+        case 'a':
+            return 'Link';
+        case 'ul':
+            return 'List';
+        case 'li':
+            return 'Text'; // Will be wrapped in List
+        case 'form':
+            return 'Form';
+        case 'select':
+            return 'Picker';
+        case 'option':
+            return 'Text'; // Options in SwiftUI are part of the Picker content
+        default:
+            // For custom components or unrecognized tags
+            return (0, capitalize_1.capitalize)(tagName);
+    }
+};
+exports.jsxElementToSwiftUIView = jsxElementToSwiftUIView;
+const cssToSwiftUIModifiers = (style) => {
+    const modifiers = [];
+    // Map CSS properties to SwiftUI modifiers
+    Object.entries(style).forEach(([key, value]) => {
+        switch (key) {
+            case 'backgroundColor':
+                modifiers.push(`.background(Color("${value}"))`);
+                break;
+            case 'color':
+                modifiers.push(`.foregroundColor(Color("${value}"))`);
+                break;
+            case 'fontSize':
+                const fontSize = parseInt(value);
+                if (!isNaN(fontSize)) {
+                    modifiers.push(`.font(.system(size: ${fontSize}))`);
+                }
+                break;
+            case 'fontWeight':
+                modifiers.push(`.fontWeight(.${value})`);
+                break;
+            case 'padding':
+                modifiers.push(`.padding(${value})`);
+                break;
+            case 'margin':
+                // Swift doesn't have direct margin equivalent, we'll use padding
+                modifiers.push(`// Note: 'margin' converted to padding: ${value}`);
+                modifiers.push(`.padding(${value})`);
+                break;
+            case 'width':
+                modifiers.push(`.frame(width: ${value})`);
+                break;
+            case 'height':
+                modifiers.push(`.frame(height: ${value})`);
+                break;
+            // Add more CSS to SwiftUI modifier mappings as needed
+            default:
+                modifiers.push(`// Unmapped style: ${key}: ${value}`);
+        }
+    });
+    return modifiers;
+};
+exports.cssToSwiftUIModifiers = cssToSwiftUIModifiers;
+const getStatePropertyTypeAnnotation = (propertyType, type) => {
+    // Use appropriate SwiftUI property wrappers
+    switch (propertyType) {
+        case 'reactive':
+            // For reactive state, use @State for simple values
+            // @Observable would be used for classes but requires Swift 5.9+/iOS 17+
+            return `@State private var`;
+        case 'normal':
+            // For normal state, use @State for simple values
+            return `@State private var`;
+        default:
+            // For non-reactive values, use a regular property
+            return `var`;
+    }
+};
+exports.getStatePropertyTypeAnnotation = getStatePropertyTypeAnnotation;
+const getEventHandlerName = (eventName) => {
+    switch (eventName) {
+        case 'onClick':
+            return 'onTapGesture';
+        case 'onChange':
+            return 'onChange';
+        case 'onInput':
+            return 'onEditingChanged';
+        case 'onBlur':
+            return 'onSubmit';
+        case 'onFocus':
+            return 'onEditingChanged';
+        default:
+            return eventName;
+    }
+};
+exports.getEventHandlerName = getEventHandlerName;
+const needsScrollView = (json) => {
+    // Check if overflow property indicates scrolling
+    if (json.properties.style) {
+        try {
+            const styleObj = JSON.parse(json.properties.style);
+            return (styleObj.overflow === 'auto' ||
+                styleObj.overflow === 'scroll' ||
+                styleObj.overflowY === 'auto' ||
+                styleObj.overflowY === 'scroll' ||
+                styleObj.overflowX === 'auto' ||
+                styleObj.overflowX === 'scroll');
+        }
+        catch (e) {
+            // If style can't be parsed, check for overflow directly in the style string
+            const styleStr = json.properties.style;
+            return (styleStr.includes('overflow:auto') ||
+                styleStr.includes('overflow:scroll') ||
+                styleStr.includes('overflow-y:auto') ||
+                styleStr.includes('overflow-y:scroll') ||
+                styleStr.includes('overflow-x:auto') ||
+                styleStr.includes('overflow-x:scroll'));
+        }
+    }
+    return false;
+};
+exports.needsScrollView = needsScrollView;
+const isForEachBlock = (json) => {
+    var _a;
+    // Check if this is a ForEach binding using the bindings.each pattern
+    return !!((_a = json.bindings.each) === null || _a === void 0 ? void 0 : _a.code);
+};
+exports.isForEachBlock = isForEachBlock;
+const getForEachParams = (json, processCode) => {
+    var _a, _b;
+    if (!((_a = json.bindings.each) === null || _a === void 0 ? void 0 : _a.code)) {
+        return { collection: '', itemName: 'item', indexName: null };
+    }
+    const eachCode = json.bindings.each.code;
+    let itemName = 'item';
+    let indexName = null;
+    // Extract collection, item name, and index name from each binding
+    try {
+        // Parse expressions like: items.map(item => ...)
+        // or items.map((item, index) => ...)
+        const match = eachCode.match(/(\w+)\.map\(\s*(?:\()?([^,)]+)(?:,\s*([^)]+))?\)?/);
+        if (match) {
+            const collection = processCode(match[1]);
+            itemName = match[2].trim();
+            indexName = ((_b = match[3]) === null || _b === void 0 ? void 0 : _b.trim()) || null;
+            return { collection, itemName, indexName };
+        }
+        // Fallback to the whole code as collection if pattern doesn't match
+        return {
+            collection: processCode(eachCode),
+            itemName,
+            indexName,
+        };
+    }
+    catch (e) {
+        console.warn('Failed to parse each binding:', eachCode);
+        return {
+            collection: processCode(eachCode),
+            itemName,
+            indexName,
+        };
+    }
+};
+exports.getForEachParams = getForEachParams;
+const camelToSnakeCase = (str) => {
+    return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+};
+exports.camelToSnakeCase = camelToSnakeCase;
+const getBindingType = (key) => {
+    if (key.startsWith('bind:')) {
+        return key.substring(5);
+    }
+    return key;
+};
+exports.getBindingType = getBindingType;
+/**
+ * Extract function signature information from JavaScript function code
+ */
+const extractFunctionSignature = (code) => {
+    // Default values
+    let name = '';
+    let params = [];
+    let returnType = 'Void';
+    let body = '';
+    // Extract function name, parameters, and body
+    const funcMatch = code.match(/(?:function\s+)?([a-zA-Z_$][a-zA-Z0-9_$]*)?\s*\(([^)]*)\)\s*(?:=>)?\s*(?:{([\s\S]*)}|(.*))/);
+    if (funcMatch) {
+        name = funcMatch[1] || '';
+        // Extract parameters
+        const paramsStr = funcMatch[2].trim();
+        if (paramsStr) {
+            params = paramsStr.split(',').map((param) => {
+                // Handle TypeScript-style parameter types if present
+                const paramParts = param.trim().split(':');
+                const paramName = paramParts[0].trim();
+                const paramType = paramParts.length > 1 ? (0, exports.getSwiftType)(paramParts[1].trim()) : 'Any';
+                return { name: paramName, type: paramType };
+            });
+        }
+        // Extract function body
+        body = funcMatch[3] || funcMatch[4] || '';
+        // Try to determine return type from TypeScript annotations or infer from return statements
+        const returnTypeMatch = code.match(/\)\s*:\s*([^{]+)/);
+        if (returnTypeMatch) {
+            returnType = (0, exports.getSwiftType)(returnTypeMatch[1].trim());
+        }
+        else if (body.includes('return')) {
+            // Try to infer from return statements
+            const returnValueMatch = body.match(/return\s+(["'].*["']|true|false|\d+|\d+\.\d+|\[.*\])/);
+            if (returnValueMatch) {
+                const returnValue = returnValueMatch[1];
+                if (returnValue.startsWith('"') || returnValue.startsWith("'")) {
+                    returnType = 'String';
+                }
+                else if (returnValue === 'true' || returnValue === 'false') {
+                    returnType = 'Bool';
+                }
+                else if (returnValue.match(/^\d+$/)) {
+                    returnType = 'Int';
+                }
+                else if (returnValue.match(/^\d+\.\d+$/)) {
+                    returnType = 'Double';
+                }
+                else if (returnValue.startsWith('[')) {
+                    returnType = '[Any]';
+                }
+            }
+        }
+    }
+    return { name, params, returnType, body };
+};
+exports.extractFunctionSignature = extractFunctionSignature;
+/**
+ * Convert JavaScript function code to Swift function syntax
+ */
+const convertJsFunctionToSwift = (code, functionName) => {
+    // Extract the function signature
+    const { name, params, returnType, body } = (0, exports.extractFunctionSignature)(code);
+    // Use provided name or extracted name
+    const finalName = functionName || name || 'function';
+    // Convert function body to Swift
+    let swiftBody = body
+        // Convert variable declarations
+        .replace(/\bvar\s+(\w+)/g, 'var $1')
+        .replace(/\blet\s+(\w+)/g, 'let $1')
+        .replace(/\bconst\s+(\w+)/g, 'let $1')
+        // Convert common array methods
+        .replace(/\.push\(/g, '.append(')
+        .replace(/\.map\(/g, '.map(')
+        .replace(/\.filter\(/g, '.filter(')
+        .replace(/\.includes\(/g, '.contains(')
+        .replace(/\.indexOf\(/g, '.firstIndex(of: ')
+        // Convert null/undefined checks
+        .replace(/=== null/g, '== nil')
+        .replace(/!== null/g, '!= nil')
+        .replace(/=== undefined/g, '== nil')
+        .replace(/!== undefined/g, '!= nil')
+        // Convert console.log
+        .replace(/console\.log\((.+?)\)/g, 'print($1)');
+    // Create parameter list with Swift types
+    const paramList = params.map((p) => `${p.name}: ${p.type}`).join(', ');
+    // Build the Swift function signature
+    const signature = `func ${finalName}(${paramList}) -> ${returnType}`;
+    // Build the complete Swift function
+    const swiftCode = `${signature} {\n  ${swiftBody}\n}`;
+    return { swiftCode, signature };
+};
+exports.convertJsFunctionToSwift = convertJsFunctionToSwift;

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

@@ -0,0 +1,2 @@
+export * from './generator';
+export * from './types';

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

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./generator"), exports);
+__exportStar(require("./types"), exports);

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

@@ -0,0 +1,29 @@
+import { BaseTranspilerOptions } from '../../types/transpiler';
+export interface ToSwiftOptions extends BaseTranspilerOptions {
+    /**
+     * Format generated Swift code
+     * @default true
+     */
+    formatCode?: boolean;
+    /**
+     * Include type annotations in Swift code
+     * @default true
+     */
+    includeTypes?: boolean;
+    /**
+     * Type of state management to use
+     * @default 'state'
+     */
+    stateType?: 'state' | 'stateObject' | 'observable';
+    /**
+     * Prefix for class names
+     * @default ''
+     */
+    classPrefix?: string;
+    /**
+     * Whether to include SwiftUI preview code
+     * @default true
+     */
+    includePreview?: boolean;
+}
+export type SwiftMetadata = {};

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,8 @@
+import { ToTaroOptions } from '../../generators/taro/types';
+import { ClassStyleMap } from '../../helpers/styles/helpers';
+import { MitosisComponent } from '../../types/mitosis-component';
+import { TranspilerGenerator } from '../../types/transpiler';
+export declare const DEFAULT_Component_SET: Set<string>;
+export declare const collectTaroStyles: (json: MitosisComponent) => ClassStyleMap;
+export declare const TagMap: Record<string, string>;
+export declare const componentToTaro: TranspilerGenerator<Partial<ToTaroOptions>>;

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

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.componentToTaro = exports.TagMap = exports.collectTaroStyles = exports.DEFAULT_Component_SET = void 0;
+const json5_1 = __importDefault(require("json5"));
+const lodash_1 = require("lodash");
+const legacy_1 = __importDefault(require("neotraverse/legacy"));
+const bindings_1 = require("../../helpers/bindings");
+const fast_clone_1 = require("../../helpers/fast-clone");
+const is_mitosis_node_1 = require("../../helpers/is-mitosis-node");
+const merge_options_1 = require("../../helpers/merge-options");
+const react_1 = require("../react");
+// @tarojs/components
+exports.DEFAULT_Component_SET = new Set([
+    'View',
+    'Icon',
+    'Progress',
+    'RichText',
+    'Text',
+    'Button',
+    'Checkbox',
+    'CheckboxGroup',
+    'Form',
+    'Input',
+    'Label',
+    'Picker',
+    'PickerView',
+    'PickerViewColumn',
+    'Radio',
+    'RadioGroup',
+    'Slider',
+    'Switch',
+    'CoverImage',
+    'Textarea',
+    'CoverView',
+    'MovableArea',
+    'MovableView',
+    'ScrollView',
+    'Swiper',
+    'SwiperItem',
+    'Navigator',
+    'Audio',
+    'Camera',
+    'Image',
+    'LivePlayer',
+    'Video',
+    'Canvas',
+    'Ad',
+    'WebView',
+    'Block',
+    'Map',
+    'Slot',
+    'SlotView',
+    'Editor',
+    'MatchMedia',
+    'FunctionalPageNavigator',
+    'LivePusher',
+    'OfficialAccount',
+    'OpenData',
+    'NavigationBar',
+    'PageMeta',
+    'VoipRoom',
+    'AdCustom',
+]);
+// TODO: px to 2 px
+const collectTaroStyles = (json) => {
+    const styleMap = {};
+    const componentIndexes = {};
+    (0, legacy_1.default)(json).forEach(function (item) {
+        var _a;
+        if (!(0, is_mitosis_node_1.isMitosisNode)(item) || typeof ((_a = item.bindings.css) === null || _a === void 0 ? void 0 : _a.code) !== 'string') {
+            return;
+        }
+        const value = json5_1.default.parse(item.bindings.css.code);
+        delete item.bindings.css;
+        if (!(0, lodash_1.size)(value)) {
+            return;
+        }
+        for (const key in value) {
+            const propertyValue = value[key];
+            // convert px to 2 * px, PX to PX
+            if (typeof propertyValue === 'string' && propertyValue.match(/^\d/)) {
+                let newValue = parseFloat(propertyValue);
+                if (!isNaN(newValue)) {
+                    if (propertyValue.endsWith('px')) {
+                        newValue = 2 * newValue;
+                        value[key] = `${newValue}px`;
+                    }
+                    else {
+                        value[key] = newValue;
+                    }
+                }
+            }
+        }
+        const componentName = (0, lodash_1.camelCase)(item.name || 'view');
+        const index = (componentIndexes[componentName] = (componentIndexes[componentName] || 0) + 1);
+        const className = `${componentName}${index}`;
+        item.bindings.style = (0, bindings_1.createSingleBinding)({ code: `styles.${className}` });
+        styleMap[className] = value;
+    });
+    return styleMap;
+};
+exports.collectTaroStyles = collectTaroStyles;
+exports.TagMap = {
+    span: 'Text',
+    button: 'Button',
+    input: 'Input',
+    img: 'Image',
+    form: 'Form',
+    textarea: 'Textarea',
+};
+/**
+ * Plugin that handles necessary transformations from React to React Native:
+ * - Converts DOM tags to @tarojs/components
+ * - Removes redundant `class`/`className` attributes
+ */
+const PROCESS_TARO_PLUGIN = () => ({
+    json: {
+        pre: (json) => {
+            const TaroComponentsImports = { path: '@tarojs/components', imports: {} };
+            json.imports.push(TaroComponentsImports);
+            (0, legacy_1.default)(json).forEach((node) => {
+                var _a, _b, _c, _d;
+                if ((0, is_mitosis_node_1.isMitosisNode)(node)) {
+                    // TODO: More dom tags convert to  @tarojs/components
+                    if (!!exports.TagMap[node.name]) {
+                        TaroComponentsImports.imports[exports.TagMap[node.name]] = exports.TagMap[node.name];
+                        node.name = exports.TagMap[node.name];
+                    }
+                    else if (node.name.toLowerCase() === node.name) {
+                        TaroComponentsImports.imports.View = 'View';
+                        node.name = 'View';
+                    }
+                    if (((_a = node.properties._text) === null || _a === void 0 ? void 0 : _a.trim().length) || ((_d = (_c = (_b = node.bindings._text) === null || _b === void 0 ? void 0 : _b.code) === null || _c === void 0 ? void 0 : _c.trim()) === null || _d === void 0 ? void 0 : _d.length)) {
+                        TaroComponentsImports.imports.Text = 'Text';
+                        node.name = 'Text';
+                    }
+                    if (node.properties.class) {
+                        delete node.properties.class;
+                    }
+                    if (node.properties.className) {
+                        delete node.properties.className;
+                    }
+                    if (node.bindings.class) {
+                        delete node.bindings.class;
+                    }
+                    if (node.bindings.className) {
+                        delete node.bindings.className;
+                    }
+                }
+            });
+        },
+    },
+});
+const DEFAULT_OPTIONS = {
+    stateType: 'useState',
+    plugins: [PROCESS_TARO_PLUGIN],
+};
+const componentToTaro = (_options = {}) => ({ component, path }) => {
+    const json = (0, fast_clone_1.fastClone)(component);
+    const options = (0, merge_options_1.mergeOptions)(DEFAULT_OPTIONS, _options, {
+        type: 'taro',
+    });
+    return (0, react_1.componentToReact)(options)({ component: json, path });
+};
+exports.componentToTaro = componentToTaro;

package/dist/src/generators/taro/index.d.ts

@@ -0,0 +1,2 @@
+export * from './generator';
+export * from './types';

package/dist/src/generators/taro/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./generator"), exports);
+__exportStar(require("./types"), exports);

package/dist/src/generators/taro/types.d.ts

@@ -0,0 +1,3 @@
+import { ToReactOptions } from '../../generators/react';
+export type ToTaroOptions = ToReactOptions;
+export type TaroMetadata = {};

package/dist/src/generators/taro/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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