@builder.io/mitosis 0.0.0-dev-20260605060721

package/dist/src/helpers/get-function-string.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFunctionString = void 0;
+const getFunctionString = (code) => code.startsWith('function') ? code : `function ${code}`;
+exports.getFunctionString = getFunctionString;

package/dist/src/helpers/get-prop-functions.d.ts

@@ -0,0 +1,5 @@
+import { MitosisComponent } from '../types/mitosis-component';
+/**
+ * Get props used in the components by reference
+ */
+export declare const getPropFunctions: (json: MitosisComponent) => string[];

package/dist/src/helpers/get-prop-functions.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPropFunctions = void 0;
+const legacy_1 = __importDefault(require("neotraverse/legacy"));
+const propsRegex = /props\s*\.\s*([a-zA-Z0-9_\x04]+)\(/;
+const allPropsMatchesRegex = new RegExp(propsRegex, 'g');
+/**
+ * Get props used in the components by reference
+ */
+const getPropFunctions = (json) => {
+    const props = [];
+    (0, legacy_1.default)(json).forEach(function (item) {
+        if (typeof item === 'string') {
+            // TODO: proper babel ref matching
+            const matches = item.match(allPropsMatchesRegex);
+            if (matches) {
+                for (const match of matches) {
+                    props.push(match.match(propsRegex)[1]);
+                }
+            }
+        }
+    });
+    return props;
+};
+exports.getPropFunctions = getPropFunctions;

package/dist/src/helpers/get-props-ref.d.ts

@@ -0,0 +1,2 @@
+import { MitosisComponent } from '../types/mitosis-component';
+export declare function getPropsRef(json: MitosisComponent, shouldRemove?: boolean): [string, boolean];

package/dist/src/helpers/get-props-ref.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPropsRef = void 0;
+const legacy_1 = __importDefault(require("neotraverse/legacy"));
+const is_mitosis_node_1 = require("./is-mitosis-node");
+function getPropsRef(json, shouldRemove) {
+    let has = false;
+    let prop = '';
+    (0, legacy_1.default)(json).forEach(function (item) {
+        if ((0, is_mitosis_node_1.isMitosisNode)(item)) {
+            const binding = item.bindings.ref;
+            const regexp = /(.+)?props\.(.+)( |\)|;|\()?$/;
+            if (binding && regexp.test(binding.code)) {
+                const match = regexp.exec(binding.code);
+                const _prop = match === null || match === void 0 ? void 0 : match[2];
+                if (_prop) {
+                    prop = _prop;
+                }
+                if (shouldRemove) {
+                    delete item.bindings.ref;
+                }
+                has = true;
+                this.stop();
+            }
+        }
+    });
+    return [prop, has];
+}
+exports.getPropsRef = getPropsRef;

package/dist/src/helpers/get-props.d.ts

@@ -0,0 +1,5 @@
+import { MitosisComponent } from '../types/mitosis-component';
+/**
+ * Get props used in the components by reference
+ */
+export declare const getProps: (json: MitosisComponent) => Set<string>;

package/dist/src/helpers/get-props.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProps = void 0;
+const process_code_1 = require("./plugins/process-code");
+const propsRegex = /props\s*\.\s*([a-zA-Z0-9_\$]+)/;
+const allPropsMatchesRegex = new RegExp(propsRegex, 'g');
+// copied from https://github.com/vuejs/core/blob/fa6556a0d56eeff1fec4f948460351ccf8f99f35/packages/compiler-core/src/validateExpression.ts
+// typeof, instanceof and in are allowed
+const prohibitedKeywordRE = new RegExp('\\b' +
+    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+        'extends,finally,continue,debugger,function,arguments,typeof,void,' +
+        // both below conditions added based on https://github.com/vuejs/vue/blob/e80cd09fff570df57d608f8f5aaccee6d7f31917/src/core/instance/state.ts#L89-L96
+        // below line added from https://github.com/vuejs/vue/blob/8880b55d52f8d873f79ef67436217c8752cddef5/src/shared/util.ts#L130
+        'key,ref,slot,slot-scope,is,' +
+        // below line added from https://github.com/vuejs/vue/blob/72aed6a149b94b5b929fb47370a7a6d4cb7491c5/src/platforms/web/util/attrs.ts#L5
+        'style')
+        .split(',')
+        .join('\\b|\\b') +
+    '\\b');
+/**
+ * Get props used in the components by reference
+ */
+const getProps = (json) => {
+    const props = new Set();
+    (0, process_code_1.createCodeProcessorPlugin)(() => (code) => {
+        const matches = code.match(allPropsMatchesRegex);
+        if (matches) {
+            for (const match of matches) {
+                const prop = match.match(propsRegex)[1];
+                if (prop.match(prohibitedKeywordRE)) {
+                    throw new Error(`avoid using JavaScript keyword as property name: "${prop}"`);
+                }
+                props.add(prop);
+            }
+        }
+        return code;
+    })(json);
+    return props;
+};
+exports.getProps = getProps;

package/dist/src/helpers/get-refs.d.ts

@@ -0,0 +1,2 @@
+import { MitosisComponent } from '../types/mitosis-component';
+export declare const getRefs: (json: MitosisComponent, refKey?: string) => Set<string>;

package/dist/src/helpers/get-refs.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRefs = void 0;
+const legacy_1 = __importDefault(require("neotraverse/legacy"));
+const is_mitosis_node_1 = require("./is-mitosis-node");
+const getRefs = (json, refKey = 'ref') => {
+    const refs = new Set();
+    (0, legacy_1.default)(json).forEach(function (item) {
+        if ((0, is_mitosis_node_1.isMitosisNode)(item)) {
+            const binding = item.bindings[refKey];
+            if (binding && typeof binding.code === 'string') {
+                refs.add(binding.code);
+            }
+        }
+    });
+    return refs;
+};
+exports.getRefs = getRefs;

package/dist/src/helpers/get-state-object-string.d.ts

@@ -0,0 +1,20 @@
+import { MitosisComponent } from '../types/mitosis-component';
+import { MitosisContext } from '../types/mitosis-context';
+type ValueMapper = (code: string, type: 'data' | 'function' | 'getter', typeParameter: string | undefined, key: string | undefined) => string;
+interface GetStateObjectStringOptions {
+    data?: boolean;
+    functions?: boolean;
+    getters?: boolean;
+    valueMapper?: ValueMapper;
+    /**
+     * If you want the plain value mapper as output
+     */
+    onlyValueMapper?: boolean;
+    format?: 'object' | 'class' | 'variables';
+    keyPrefix?: string;
+    withType?: boolean;
+}
+export declare const getMemberObjectString: (object: MitosisComponent['state'], userOptions?: GetStateObjectStringOptions) => string;
+export declare const stringifyContextValue: (object: MitosisContext['value'], userOptions?: GetStateObjectStringOptions) => string;
+export declare const getStateObjectStringFromComponent: (component: MitosisComponent, options?: GetStateObjectStringOptions) => string;
+export {};

package/dist/src/helpers/get-state-object-string.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStateObjectStringFromComponent = exports.stringifyContextValue = exports.getMemberObjectString = void 0;
+const DEFAULT_OPTIONS = {
+    format: 'object',
+    keyPrefix: '',
+    valueMapper: (val) => val,
+    onlyValueMapper: false,
+    data: true,
+    functions: true,
+    getters: true,
+    withType: false,
+};
+const convertStateMemberToString = ({ data, format, functions, getters, keyPrefix, valueMapper, withType, onlyValueMapper, }) => ([key, state]) => {
+    const keyValueDelimiter = format === 'object' ? ':' : '=';
+    if (!state) {
+        return undefined;
+    }
+    const { code, typeParameter } = state;
+    const type = withType && typeParameter ? `:${typeParameter}` : '';
+    switch (state.type) {
+        case 'function': {
+            if (!functions) {
+                return undefined;
+            }
+            const mapper = valueMapper(code, 'function', typeParameter, key);
+            if (onlyValueMapper) {
+                return mapper;
+            }
+            return `${keyPrefix} ${key} ${keyValueDelimiter} ${mapper}`;
+        }
+        case 'method': {
+            if (!functions) {
+                return undefined;
+            }
+            const mapper = valueMapper(code, 'function', typeParameter, key);
+            if (onlyValueMapper) {
+                return mapper;
+            }
+            return `${keyPrefix} ${mapper}`;
+        }
+        case 'getter': {
+            if (!getters) {
+                return undefined;
+            }
+            const mapper = valueMapper(code, 'getter', typeParameter, key);
+            if (onlyValueMapper) {
+                return mapper;
+            }
+            return `${keyPrefix} ${mapper}`;
+        }
+        case 'property': {
+            if (!data) {
+                return undefined;
+            }
+            const mapper = valueMapper(code, 'data', typeParameter, key);
+            if (onlyValueMapper) {
+                return mapper;
+            }
+            return `${keyPrefix} ${key}${type}${keyValueDelimiter} ${mapper}`;
+        }
+        default:
+            break;
+    }
+};
+const getMemberObjectString = (object, userOptions = {}) => {
+    const options = { ...DEFAULT_OPTIONS, ...userOptions };
+    const lineItemDelimiter = options.format === 'object' ? ',' : '\n';
+    const stringifiedProperties = Object.entries(object)
+        .map(convertStateMemberToString(options))
+        .filter((x) => x !== undefined)
+        .join(lineItemDelimiter);
+    const prefix = options.format === 'object' ? '{' : '';
+    const suffix = options.format === 'object' ? '}' : '';
+    // NOTE: we add a `lineItemDelimiter` at the very end because other functions will sometimes append more properties.
+    // If the delimiter is a comma and the format is `object`, then we need to make sure we have an extra comma at the end,
+    // or the object will become invalid JS.
+    // We also have to make sure that `stringifiedProperties` isn't empty, or we will get `{,}` which is invalid
+    const extraDelimiter = stringifiedProperties.length > 0 ? lineItemDelimiter : '';
+    return `${prefix}${stringifiedProperties}${extraDelimiter}${suffix}`;
+};
+exports.getMemberObjectString = getMemberObjectString;
+const stringifyContextValue = (object, userOptions = {}) => (0, exports.getMemberObjectString)(object, userOptions);
+exports.stringifyContextValue = stringifyContextValue;
+const getStateObjectStringFromComponent = (component, options) => (0, exports.getMemberObjectString)(component.state, options);
+exports.getStateObjectStringFromComponent = getStateObjectStringFromComponent;

package/dist/src/helpers/get-state-used.d.ts

@@ -0,0 +1,5 @@
+import { MitosisComponent } from '../types/mitosis-component';
+/**
+ * Get state used in the components by reference
+ */
+export declare const getStateUsed: (json: MitosisComponent) => Set<string>;

package/dist/src/helpers/get-state-used.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStateUsed = void 0;
+const legacy_1 = __importDefault(require("neotraverse/legacy"));
+const stateAccessRegex = /state\s*\.\s*([a-zA-Z0-9_\$]+)/;
+const allStateMatchesRegex = new RegExp(stateAccessRegex, 'g');
+/**
+ * Get state used in the components by reference
+ */
+const getStateUsed = (json) => {
+    const stateProperties = new Set();
+    (0, legacy_1.default)(json).forEach(function (item) {
+        if (typeof item === 'string') {
+            // TODO: proper babel ref matching
+            const matches = item.match(allStateMatchesRegex);
+            if (matches) {
+                for (const match of matches) {
+                    stateProperties.add(match.match(stateAccessRegex)[1]);
+                }
+            }
+        }
+    });
+    return stateProperties;
+};
+exports.getStateUsed = getStateUsed;

package/dist/src/helpers/get-styles.d.ts

@@ -0,0 +1,4 @@
+import { MitosisNode } from '../types/mitosis-node';
+import { MitosisStyles } from '../types/mitosis-styles';
+export declare const getStyles: (json: MitosisNode) => MitosisStyles | null;
+export declare const setStyles: (json: MitosisNode, styles: MitosisStyles | null) => void;

package/dist/src/helpers/get-styles.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setStyles = exports.getStyles = void 0;
+const json5_1 = __importDefault(require("json5"));
+const lodash_1 = require("lodash");
+const bindings_1 = require("./bindings");
+const getStyles = (json) => {
+    var _a;
+    if (!json.bindings.css) {
+        return null;
+    }
+    let css;
+    try {
+        css = json5_1.default.parse((_a = json.bindings.css) === null || _a === void 0 ? void 0 : _a.code);
+    }
+    catch (err) {
+        console.warn('Could not json 5 parse css', err, json.bindings.css.code);
+        return null;
+    }
+    return css;
+};
+exports.getStyles = getStyles;
+const setStyles = (json, styles) => {
+    if (!(0, lodash_1.size)(styles)) {
+        delete json.bindings.css;
+    }
+    else {
+        json.bindings.css = (0, bindings_1.createSingleBinding)({ code: json5_1.default.stringify(styles) });
+    }
+};
+exports.setStyles = setStyles;

package/dist/src/helpers/get-tag-name.d.ts

@@ -0,0 +1,2 @@
+import { MitosisNode } from '../types/mitosis-node';
+export declare const getBuilderTagName: (node: MitosisNode) => string | undefined;

package/dist/src/helpers/get-tag-name.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBuilderTagName = void 0;
+const getBuilderTagName = (node) => {
+    return node.properties.$tagName;
+};
+exports.getBuilderTagName = getBuilderTagName;

package/dist/src/helpers/get-typed-function.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Get functions with typescript typing
+ */
+export declare const getTypedFunction: (code: string, typescript?: boolean, typeParameter?: string) => string;

package/dist/src/helpers/get-typed-function.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypedFunction = void 0;
+/**
+ * Get functions with typescript typing
+ */
+const getTypedFunction = (code, typescript, typeParameter) => {
+    if (!typeParameter || !typescript) {
+        return code;
+    }
+    const firstParenthesisIndex = code.indexOf('{');
+    // The function should have at least one {
+    if (firstParenthesisIndex < 0) {
+        return code;
+    }
+    const preType = code.slice(0, firstParenthesisIndex - 1);
+    const postType = code.slice(firstParenthesisIndex, code.length);
+    return [preType, ': ', `ReturnType<${typeParameter}>`, postType].join('');
+};
+exports.getTypedFunction = getTypedFunction;

package/dist/src/helpers/getters-to-functions.d.ts

@@ -0,0 +1,5 @@
+import { MitosisComponent } from '../types/mitosis-component';
+/**
+ * Map getters like `useStore({ get foo() { ... }})` from `state.foo` to `foo()`
+ */
+export declare const gettersToFunctions: (json: MitosisComponent) => void;

package/dist/src/helpers/getters-to-functions.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gettersToFunctions = void 0;
+const legacy_1 = __importDefault(require("neotraverse/legacy"));
+/**
+ * Map getters like `useStore({ get foo() { ... }})` from `state.foo` to `foo()`
+ */
+const gettersToFunctions = (json) => {
+    const getterKeys = Object.keys(json.state).filter((item) => { var _a; return ((_a = json.state[item]) === null || _a === void 0 ? void 0 : _a.type) === 'getter'; });
+    (0, legacy_1.default)(json).forEach(function (item) {
+        // TODO: not all strings are expressions!
+        if (typeof item === 'string') {
+            let value = item;
+            for (const key of getterKeys) {
+                try {
+                    value = value.replace(new RegExp(`state\\s*\\.\\s*${key}([^a-z0-9]|$)`, 'gi'), (match, group1) => {
+                        if (match.endsWith('?')) {
+                            return `${key}?.()${group1}`;
+                        }
+                        return `${key}()${group1}`;
+                    });
+                }
+                catch (err) {
+                    console.error('Could not update getter ref', err);
+                }
+            }
+            if (value !== item) {
+                this.update(value);
+            }
+        }
+    });
+};
+exports.gettersToFunctions = gettersToFunctions;

package/dist/src/helpers/handle-missing-state.d.ts

@@ -0,0 +1,2 @@
+import { MitosisComponent } from '..';
+export declare function handleMissingState(json: MitosisComponent): void;

package/dist/src/helpers/handle-missing-state.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMissingState = void 0;
+const get_state_used_1 = require("./get-state-used");
+function handleMissingState(json) {
+    const stateUsed = (0, get_state_used_1.getStateUsed)(json);
+    Array.from(stateUsed).forEach((property) => {
+        if (!(property in json.state)) {
+            json.state[property] = { code: 'null', type: 'property', propertyType: 'normal' };
+        }
+    });
+}
+exports.handleMissingState = handleMissingState;

package/dist/src/helpers/has-bindings-text.d.ts

@@ -0,0 +1,2 @@
+import { MitosisComponent } from '../types/mitosis-component';
+export declare const hasBindingsText: (json: MitosisComponent) => boolean;

package/dist/src/helpers/has-bindings-text.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasBindingsText = void 0;
+const legacy_1 = __importDefault(require("neotraverse/legacy"));
+const is_children_1 = __importDefault(require("./is-children"));
+const is_mitosis_node_1 = require("./is-mitosis-node");
+const hasBindingsText = (json) => {
+    let has = false;
+    (0, legacy_1.default)(json).forEach(function (node) {
+        var _a;
+        if ((0, is_mitosis_node_1.isMitosisNode)(node) && !(0, is_children_1.default)({ node }) && ((_a = node.bindings._text) === null || _a === void 0 ? void 0 : _a.code)) {
+            has = true;
+            this.stop();
+        }
+    });
+    return has;
+};
+exports.hasBindingsText = hasBindingsText;

package/dist/src/helpers/has-component.d.ts

@@ -0,0 +1,2 @@
+import { MitosisComponent } from '../types/mitosis-component';
+export declare const hasComponent: (name: string, json: MitosisComponent) => boolean;

package/dist/src/helpers/has-component.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasComponent = void 0;
+const legacy_1 = __importDefault(require("neotraverse/legacy"));
+const is_mitosis_node_1 = require("./is-mitosis-node");
+const hasComponent = (name, json) => {
+    let has = false;
+    (0, legacy_1.default)(json).forEach(function (item) {
+        if ((0, is_mitosis_node_1.isMitosisNode)(item)) {
+            if (item.name === name) {
+                has = true;
+                this.stop();
+            }
+        }
+    });
+    return has;
+};
+exports.hasComponent = hasComponent;

package/dist/src/helpers/has-props.d.ts

@@ -0,0 +1,2 @@
+import { MitosisComponent } from '../types/mitosis-component';
+export declare const hasProps: (json: MitosisComponent) => boolean;

package/dist/src/helpers/has-props.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasProps = void 0;
+const legacy_1 = __importDefault(require("neotraverse/legacy"));
+const hasProps = (json) => {
+    let has = false;
+    (0, legacy_1.default)(json).forEach(function (item) {
+        // TODO: use proper reference tracking
+        if (typeof item === 'string' && item.match(/(^|\W)props\s*\./)) {
+            has = true;
+            this.stop();
+        }
+    });
+    return has;
+};
+exports.hasProps = hasProps;

package/dist/src/helpers/has-stateful-dom.d.ts

@@ -0,0 +1,2 @@
+import { MitosisComponent } from '../types/mitosis-component';
+export declare const hasStatefulDom: (json: MitosisComponent) => boolean;

package/dist/src/helpers/has-stateful-dom.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasStatefulDom = void 0;
+const legacy_1 = __importDefault(require("neotraverse/legacy"));
+const is_mitosis_node_1 = require("./is-mitosis-node");
+const hasStatefulDom = (json) => {
+    let has = false;
+    (0, legacy_1.default)(json).forEach(function (item) {
+        if ((0, is_mitosis_node_1.isMitosisNode)(item)) {
+            if (/input|textarea|select/.test(item.name)) {
+                has = true;
+                this.stop();
+            }
+        }
+    });
+    return has;
+};
+exports.hasStatefulDom = hasStatefulDom;

package/dist/src/helpers/has.d.ts

@@ -0,0 +1,9 @@
+import { MitosisComponent } from '../types/mitosis-component';
+import { MitosisNode } from '../types/mitosis-node';
+/**
+ * Test if the component has something
+ *
+ * e.g.
+ *    const hasSpread = has(component, node => some(node.bindings, { type: 'spread' }));
+ */
+export declare function has(json: MitosisComponent, test: (node: MitosisNode) => boolean): boolean;

package/dist/src/helpers/has.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.has = void 0;
+const legacy_1 = __importDefault(require("neotraverse/legacy"));
+const is_mitosis_node_1 = require("./is-mitosis-node");
+/**
+ * Test if the component has something
+ *
+ * e.g.
+ *    const hasSpread = has(component, node => some(node.bindings, { type: 'spread' }));
+ */
+function has(json, test) {
+    let found = false;
+    (0, legacy_1.default)(json).forEach(function (thing) {
+        if ((0, is_mitosis_node_1.isMitosisNode)(thing)) {
+            if (test(thing)) {
+                found = true;
+                this.stop();
+            }
+        }
+    });
+    return found;
+}
+exports.has = has;

package/dist/src/helpers/html-escape.d.ts

@@ -0,0 +1 @@
+export declare function htmlAttributeEscape(value: string): string;

package/dist/src/helpers/html-escape.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.htmlAttributeEscape = void 0;
+function htmlAttributeEscape(value) {
+    return value.replace(/"/g, '"').replace(/\n/g, '\\n');
+}
+exports.htmlAttributeEscape = htmlAttributeEscape;

package/dist/src/helpers/indent.d.ts

@@ -0,0 +1 @@
+export declare function indent(str: string, spaces?: number): string;

package/dist/src/helpers/indent.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indent = void 0;
+function indent(str, spaces = 4) {
+    return str.replace(/\n([^\n])/g, `\n${' '.repeat(spaces)}$1`);
+}
+exports.indent = indent;

package/dist/src/helpers/is-children.d.ts

@@ -0,0 +1,6 @@
+import { MitosisNode } from '../types/mitosis-node';
+export declare const getTextValue: (node: MitosisNode) => string;
+export default function isChildren({ node, extraMatches, }: {
+    node: MitosisNode;
+    extraMatches?: string[];
+}): boolean;

package/dist/src/helpers/is-children.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTextValue = void 0;
+const getTextValue = (node) => {
+    var _a;
+    const textValue = ((_a = node.bindings._text) === null || _a === void 0 ? void 0 : _a.code) || node.properties.__text || '';
+    return textValue.replace(/\s+/g, '');
+};
+exports.getTextValue = getTextValue;
+function isChildren({ node, extraMatches = [], }) {
+    const textValue = (0, exports.getTextValue)(node);
+    return ['props.children', 'children', 'children()'].concat(extraMatches).includes(textValue);
+}
+exports.default = isChildren;

package/dist/src/helpers/is-component.d.ts

@@ -0,0 +1,5 @@
+import { MitosisNode } from '../types/mitosis-node';
+/**
+ * This node is a component, vs a plain html tag (<Foo> vs <div>)
+ */
+export declare const isComponent: (json: MitosisNode) => boolean;