@builder.io/mitosis 0.0.78 → 0.0.79

package/dist/src/parsers/svelte/typescript/index.js

@@ -0,0 +1,130 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectTypes = exports.parseAttributes = exports.createTagRegex = exports.isTypeScriptComponent = void 0;
+var babel = __importStar(require("@babel/core"));
+var generator_1 = __importDefault(require("@babel/generator"));
+var parser = __importStar(require("@babel/parser"));
+var types = __importStar(require("@babel/types"));
+var lodash_1 = require("lodash");
+function isTypeScriptComponent(string_) {
+    var regex = createTagRegex('script', 'gi');
+    var match = regex.exec(string_);
+    var lang = parseAttributes(((match === null || match === void 0 ? void 0 : match.length) && match[1]) || '').lang;
+    return lang === 'ts';
+}
+exports.isTypeScriptComponent = isTypeScriptComponent;
+/** Create a tag matching regexp. */
+function createTagRegex(tagName, flags) {
+    return new RegExp("/<!--[^]*?-->|<".concat(tagName, "(\\s[^]*?)?(?:>([^]*?)<\\/").concat(tagName, ">|\\/>)"), flags);
+}
+exports.createTagRegex = createTagRegex;
+/** Transform an attribute string into a key-value object */
+function parseAttributes(attributesString) {
+    return attributesString
+        .split(/\s+/)
+        .filter(Boolean)
+        .reduce(function (accumulator, attribute) {
+        var _a = attribute.split('='), name = _a[0], value = _a[1];
+        // istanbul ignore next
+        accumulator[name] = value ? value.replace(/["']/g, '') : true;
+        return accumulator;
+    }, {});
+}
+exports.parseAttributes = parseAttributes;
+function getScriptContent(markup, module) {
+    var regex = createTagRegex('script', 'gi');
+    var match;
+    while ((match = regex.exec(markup)) !== null) {
+        var context = parseAttributes(match[1] || '').context;
+        if ((context !== 'module' && !module) || (context === 'module' && module)) {
+            return match[2];
+        }
+    }
+    return '';
+}
+function collectTypes(string_, json) {
+    var _a;
+    var module = getScriptContent(string_, true); // module
+    var instance = getScriptContent(string_, false); // instance
+    function traverse(script_) {
+        var ast = parser.parse(script_, {
+            sourceType: 'module',
+            plugins: ['typescript'],
+        });
+        babel.traverse(ast, {
+            enter: function (path) {
+                var _a;
+                // alias or interface (e.g. type Props = { } or interface Props {} )
+                if (types.isTSTypeAliasDeclaration(path.node) ||
+                    types.isTSInterfaceDeclaration(path.node)) {
+                    json.types = __spreadArray(__spreadArray([], ((_a = json.types) !== null && _a !== void 0 ? _a : []), true), [(0, generator_1.default)(path.node).code], false);
+                    path.skip();
+                }
+                else if (types.isTSTypeAnnotation(path.node)) {
+                    // add to actual ref
+                    var reference = (0, generator_1.default)(path.parent).code;
+                    var type = (0, generator_1.default)(path.node.typeAnnotation).code;
+                    // add to ref
+                    if (Object.prototype.hasOwnProperty.call(json.refs, reference)) {
+                        json.refs[reference].typeParameter = type;
+                    }
+                    // temp add to prop object.
+                    // after having finished traversing, we'll create the prop type declaration
+                    if (Object.prototype.hasOwnProperty.call(json.props, reference)) {
+                        json.props[reference].type = type;
+                    }
+                }
+            },
+        });
+    }
+    traverse(module);
+    traverse(instance);
+    // add prop type declaration to json.types and set the propsTypeRef
+    if ((0, lodash_1.some)(json.props, function (property) { return !!property.type; })) {
+        var propertyTypeDeclaration = "type Props = {";
+        propertyTypeDeclaration += Object.keys((0, lodash_1.pickBy)(json.props, function (property) { return !!property.type; }))
+            .map(function (key) {
+            return "".concat(key, ": ").concat(json.props[key].type, ";");
+        })
+            .join('\n');
+        propertyTypeDeclaration += '}';
+        json.types = __spreadArray(__spreadArray([], ((_a = json.types) !== null && _a !== void 0 ? _a : []), true), [propertyTypeDeclaration], false);
+        json.propsTypeRef = 'Props';
+    }
+}
+exports.collectTypes = collectTypes;

package/dist/src/plugins/compile-away-builder-components.d.ts

@@ -1,6 +1,7 @@
 import { TraverseContext } from 'traverse';
 import { MitosisComponent } from '../types/mitosis-component';
 import { MitosisNode } from '../types/mitosis-node';
+import { Plugin } from '..';
 declare type CompileAwayComponentsMap = {
     [key: string]: (node: MitosisNode, context: TraverseContext, components: CompileAwayComponentsMap) => MitosisNode | void;
 };
@@ -10,9 +11,5 @@ declare type CompileAwayBuilderComponentsOptions = {
     omit?: string[];
 };
 export declare const compileAwayBuilderComponentsFromTree: (tree: MitosisNode | MitosisComponent, components: CompileAwayComponentsMap) => void;
-export declare const compileAwayBuilderComponents: (pluginOptions?: CompileAwayBuilderComponentsOptions) => (options?: any) => {
-    json: {
-        pre: (json: MitosisComponent) => void;
-    };
-};
+export declare const compileAwayBuilderComponents: (pluginOptions?: CompileAwayBuilderComponentsOptions) => Plugin;
 export {};

package/dist/src/types/config.d.ts

@@ -50,11 +50,6 @@ export declare type MitosisConfig = {
      * ```
      */
     options: Partial<GeneratorOptions>;
-    /**
-     * Configure the extension of the files you want to compile
-     * Default value: 'lite.tsx'
-     */
-    extension: string;
     /**
      * Configure a custom parser function which takes a string and returns MitosisJSON
      * Defaults to the JSXParser of this project (src/parsers/jsx)

package/dist/src/types/mitosis-component.d.ts

@@ -1,5 +1,5 @@
 import { Dictionary } from '../helpers/typescript';
-import { _JSON, JSONObject } from './json';
+import { JSONObject } from './json';
 import { MitosisNode } from './mitosis-node';
 /**
  * @example
@@ -54,16 +54,9 @@ export interface MitosisExport {
     isFunction?: boolean;
 }
 export declare type StateValueType = 'function' | 'getter' | 'method' | 'property';
-export declare type StateCode = _JSON;
-declare type CodeValue = {
+export declare type StateValue = {
     code: string;
-    type: Exclude<StateValueType, 'property'>;
-    typeParameter?: string;
-};
-export declare const checkIsCodeValue: (value: unknown) => value is CodeValue;
-export declare type StateValue = CodeValue | {
-    code: StateCode;
-    type: Extract<StateValueType, 'property'>;
+    type: StateValueType;
     typeParameter?: string;
 };
 export declare type MitosisState = Dictionary<StateValue | undefined>;
@@ -103,4 +96,3 @@ export declare type MitosisComponent = {
     defaultProps?: JSONObject;
     style?: string;
 };
-export {};

package/dist/src/types/mitosis-component.js

@@ -1,13 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkIsCodeValue = void 0;
-var checkIsCodeValue = function (value) {
-    return typeof value === 'object' &&
-        value &&
-        Object.keys(value).length === 2 &&
-        'type' in value &&
-        'code' in value
-        ? ['function', 'getter', 'method'].includes(value.type)
-        : false;
-};
-exports.checkIsCodeValue = checkIsCodeValue;