@cloudbase/framework-plugin-low-code 1.7.2 → 1.7.3

package/lib/weapps-core/utils/formily.js

@@ -0,0 +1,416 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCmpInstances = exports.deserialize = exports.serialize = void 0;
+const types_1 = require("../types");
+const common_1 = require("./common");
+const style_1 = require("./style");
+const types_2 = require("../../types");
+function serialize(webRuntimeAppData) {
+    const weAppData = {
+        selectedPageId: webRuntimeAppData.selectedPageId,
+        pageInstanceList: [],
+        lowCodes: webRuntimeAppData.codeModules,
+        npmDependencies: webRuntimeAppData.npmDependencies,
+        plugins: webRuntimeAppData.plugins,
+        rootPath: webRuntimeAppData.rootPath,
+        datasources: webRuntimeAppData.datasources || [],
+        vars: webRuntimeAppData.vars || { data: [] },
+        dataset: webRuntimeAppData.dataset,
+    };
+    (0, common_1.setValidValue)(weAppData, 'appConfig', webRuntimeAppData.appConfig);
+    (0, common_1.setValidValue)(weAppData, 'themeVars', webRuntimeAppData.themeVars);
+    (0, common_1.setValidValue)(weAppData, 'presetColors', webRuntimeAppData.presetColors);
+    handlePageInstanceList(webRuntimeAppData.pageInstanceList, weAppData.pageInstanceList);
+    function handlePageInstanceList(pageInstanceList, collection) {
+        pageInstanceList.map((pageData) => {
+            var _a;
+            const newPage = {
+                id: pageData.id,
+            };
+            (0, common_1.setValidValue)(newPage, 'isHome', pageData.isHome);
+            (0, common_1.setValidValue)(newPage, 'data', readDynamicData(pageData));
+            (0, common_1.setValidValue)(newPage, 'commonStyle', (0, style_1.removeInvalidStyleFormValue)(pageData.style));
+            (0, common_1.setValidValue)(newPage, 'styleBindPath', pageData.styleBindPath);
+            if ((0, common_1.isValidStyleBind)(pageData.styleBind)) {
+                (0, common_1.setValidValue)(newPage, 'styleBind', pageData.styleBind);
+            }
+            if ((0, common_1.isValidClassNameListBind)(pageData.classNameListBind)) {
+                (0, common_1.setValidValue)(newPage, 'classNameListBind', pageData.classNameListBind);
+            }
+            (0, common_1.setValidValue)(newPage, 'componentInstances', readComponents(pageData.componentSchemaJson.properties));
+            (0, common_1.setValidValue)(newPage, 'listeners', readListeners(pageData.listenerInstances));
+            (0, common_1.setValidValue)(newPage, 'pluginInstances', pageData.pluginInstances);
+            (0, common_1.setValidValue)(newPage, 'lowCodes', pageData.codeModules);
+            if ((_a = pageData.children) === null || _a === void 0 ? void 0 : _a.length) {
+                newPage.children = newPage.children || [];
+                handlePageInstanceList(pageData.children, newPage.children);
+            }
+            collection.push(newPage);
+        });
+    }
+    function readComponents(properties = {}, excludeKeys = []) {
+        var _a;
+        const cmps = {};
+        for (const key in properties) {
+            if (excludeKeys.indexOf(key) > -1) {
+                continue;
+            }
+            const srcCmp = properties[key];
+            const srcProps = srcCmp['x-props'];
+            if (srcProps) {
+                const cmpParts = srcProps.sourceKey.split(':');
+                cmps[key] = { genericComp: srcCmp['genericComp'] };
+                (0, common_1.setValidValue)(cmps[key], 'xComponent', {
+                    moduleName: cmpParts[0],
+                    name: cmpParts[1],
+                });
+                const componentXProps = {};
+                (0, common_1.setValidValue)(componentXProps, 'data', readDynamicData(srcProps));
+                (0, common_1.setValidValue)(componentXProps, 'listeners', readListeners(srcProps.listenerInstances));
+                (0, common_1.setValidValue)(componentXProps, 'staticResourceAttribute', srcProps.staticResourceAttribute);
+                (0, common_1.setValidValue)(componentXProps, 'directives', readDirectives(srcProps));
+                (0, common_1.setValidValue)(componentXProps, 'customDataForm', srcProps.customDataForm);
+                (0, common_1.setValidValue)(componentXProps, 'style', srcProps.style);
+                (0, common_1.setValidValue)(componentXProps, 'commonStyle', (0, style_1.removeInvalidStyleFormValue)(srcProps.commonStyle));
+                (0, common_1.setValidValue)(componentXProps, 'styleBindPath', srcProps.styleBindPath);
+                if ((_a = srcProps.styleBind) === null || _a === void 0 ? void 0 : _a.bindDataPath) {
+                    componentXProps.styleBind = {
+                        type: srcProps.styleBind.type,
+                        value: srcProps.styleBind.bindDataPath,
+                    };
+                }
+                if ((0, common_1.isValidClassNameListBind)(srcProps.classNameListBind)) {
+                    const classList = srcProps.classNameListBind;
+                    (0, common_1.setValidValue)(componentXProps, 'classListBind', {
+                        type: classList.type,
+                        value: classList.bindDataPath,
+                    });
+                }
+                if (srcProps.classNameList) {
+                    (0, common_1.setValidValue)(componentXProps, 'classList', srcProps.classNameList);
+                }
+                (0, common_1.setValidValue)(cmps[key], 'xProps', componentXProps);
+                (0, common_1.setValidValue)(cmps[key], 'xIndex', srcCmp['x-index']);
+                const excludeKeys = (srcProps.dataTypes || [])
+                    .filter((dataType) => dataType.type !== 'slot')
+                    .map((dataType) => dataType.propertyPath);
+                (0, common_1.setValidValue)(cmps[key], 'properties', readComponents(srcCmp.properties, excludeKeys));
+            }
+            else {
+                cmps[key] = { properties: readComponents(srcCmp.properties) };
+            }
+        }
+        return cmps;
+    }
+    function readDirectives(cmp) {
+        var _a, _b, _c;
+        const directives = {};
+        if (cmp.data && cmp.data._visible !== true) {
+            directives.waIf = {
+                value: cmp.data._visible,
+            };
+        }
+        if ((_a = cmp.dataBinds) === null || _a === void 0 ? void 0 : _a.length) {
+            const bind = cmp.dataBinds.find((bind) => bind.propertyPath === '_visible');
+            if (bind) {
+                const foundDataType = (cmp.dataTypes || []).find((dataType) => dataType.propertyPath === bind.propertyPath);
+                if (foundDataType && foundDataType.type === 'bind') {
+                    directives.waIf = {
+                        type: bind.type || types_1.PropBindType.state,
+                        value: bind.bindDataPath,
+                    };
+                }
+            }
+            const forBind = cmp.dataBinds.find((bind) => bind.propertyPath === '_waFor');
+            if (forBind) {
+                directives.waFor = {
+                    type: forBind.type || types_1.PropBindType.state,
+                    value: forBind.bindDataPath,
+                };
+            }
+        }
+        if (directives.waFor && ((_b = cmp.data) === null || _b === void 0 ? void 0 : _b._waForKey)) {
+            directives.waForKey = {
+                value: (_c = cmp.data) === null || _c === void 0 ? void 0 : _c._waForKey,
+            };
+        }
+        return directives;
+    }
+    function readDynamicData(cmp) {
+        var _a;
+        const data = {};
+        const ignoredProps = ['_visible', '_waFor', '_waForKey'];
+        for (const prop in cmp.data) {
+            if (ignoredProps.indexOf(prop) > -1) {
+                continue;
+            }
+            data[prop] = { value: cmp.data[prop] };
+        }
+        (_a = cmp.dataBinds) === null || _a === void 0 ? void 0 : _a.forEach((bind) => {
+            if (ignoredProps.indexOf(bind.propertyPath) > -1) {
+                return;
+            }
+            const foundDataType = (cmp.dataTypes || []).find((dataType) => dataType.propertyPath === bind.propertyPath);
+            if (foundDataType && foundDataType.type === 'bind') {
+                data[bind.propertyPath] = {
+                    type: bind.type || types_1.PropBindType.state,
+                    value: bind.bindDataPath,
+                };
+            }
+        });
+        return data;
+    }
+    function readListeners(listenerInstances = []) {
+        const listeners = listenerInstances.map((act) => {
+            const fromParts = act.sourceKey.split(':');
+            let handler;
+            if (act.type !== types_1.ActionType.Inline) {
+                const fromParts = act.sourceKey.split(':');
+                handler = {
+                    handler: {
+                        moduleName: fromParts[0],
+                        name: fromParts[1],
+                    },
+                };
+            }
+            else {
+                handler = { jsCode: act.jsCode };
+            }
+            return Object.assign(Object.assign({ key: act.key || '', trigger: act.trigger, type: act.type }, handler), { data: readDynamicData(act), isCapturePhase: act.isCapturePhase, noPropagation: act.noPropagation });
+        });
+        return listeners;
+    }
+    return weAppData;
+}
+exports.serialize = serialize;
+function deserialize(weAppData) {
+    const webRuntimeAppData = {
+        appTitle: weAppData.label,
+        label: weAppData.label,
+        selectedPageId: weAppData.selectedPageId,
+        historyType: weAppData.historyType || types_2.HISTORY_TYPE.BROWSER,
+        pageInstanceList: [],
+        codeModules: weAppData.lowCodes || [],
+        npmDependencies: weAppData.npmDependencies || {},
+        plugins: weAppData.plugins || [],
+        rootPath: weAppData.rootPath || '',
+        themeVars: weAppData.themeVars || {},
+        presetColors: weAppData.presetColors || [],
+        appConfig: weAppData.appConfig || {},
+        datasources: weAppData.datasources || [],
+        vars: weAppData.vars || { data: [] },
+        dataset: weAppData.dataset,
+        envId: weAppData.envId || '',
+        extra: weAppData.extra || {},
+    };
+    handlePageInstanceList(weAppData.pageInstanceList, webRuntimeAppData.pageInstanceList);
+    function handlePageInstanceList(pageInstanceList, collection) {
+        pageInstanceList.map((srcPage) => {
+            var _a;
+            const page = {
+                id: srcPage.id,
+                data: {},
+                dataBinds: [],
+                vars: { data: [] },
+                dataset: srcPage.dataset,
+            };
+            page.vars = srcPage.vars ? srcPage.vars : page.vars;
+            page.isHome = srcPage.isHome || false;
+            page.style = srcPage.commonStyle || {};
+            (0, common_1.setValidValue)(page, 'styleBindPath', srcPage.styleBindPath);
+            page.codeModules = srcPage.lowCodes || [];
+            page.pluginInstances = srcPage.pluginInstances || [];
+            page.componentSchemaJson = {
+                type: 'object',
+                properties: readCmpInstances(srcPage.componentInstances),
+                'x-index': 0,
+            };
+            page.listenerInstances = readListeners(srcPage.listeners) || [];
+            if (srcPage['code']) {
+                const target = srcPage['codeType'] === 'page' ? page : webRuntimeAppData;
+                target.codeModules.push({
+                    type: 'rematch',
+                    code: srcPage['code'],
+                    name: srcPage.id,
+                    path: '',
+                });
+            }
+            readDynamicData(srcPage.data, page);
+            if ((_a = srcPage.children) === null || _a === void 0 ? void 0 : _a.length) {
+                page.children = page.children || [];
+                handlePageInstanceList(srcPage.children, page.children);
+            }
+            collection.push(page);
+        });
+    }
+    return webRuntimeAppData;
+}
+exports.deserialize = deserialize;
+function readCmpInstances(cmps) {
+    const properties = {};
+    for (const key in cmps) {
+        const cmp = cmps[key];
+        const target = (properties[key] = {
+            key,
+            type: 'object',
+            properties: readCmpInstances(cmp.properties || {}),
+            genericComp: cmp.genericComp,
+        });
+        if (cmp.xComponent) {
+            cmp.xProps = (cmp.xProps || {});
+            const xCmp = cmp.xComponent.moduleName + ':' + cmp.xComponent.name;
+            const xProps = {
+                sourceKey: xCmp,
+                data: {},
+            };
+            xProps.dataBinds = xProps.dataBinds || [];
+            xProps.dataTypes = xProps.dataTypes || [];
+            xProps.customDataForm = xProps.customDataForm || {};
+            xProps.style = cmp.xProps.style || {};
+            xProps.commonStyle = cmp.xProps.commonStyle || {};
+            xProps.staticResourceAttribute = cmp.xProps.staticResourceAttribute || [];
+            (0, common_1.setValidValue)(xProps, 'styleBindPath', cmp.xProps.styleBindPath);
+            let { classList, classListBind } = cmp.xProps;
+            const { styleBind } = cmp.xProps;
+            const legacyClassList = classList;
+            if (legacyClassList === null || legacyClassList === void 0 ? void 0 : legacyClassList.value) {
+                if (!legacyClassList.type || legacyClassList.type === 'static') {
+                    classList = legacyClassList.value;
+                }
+                else {
+                    classList = [];
+                    classListBind = classListBind;
+                }
+            }
+            classList && (0, common_1.setValidValue)(xProps, 'classNameList', classList);
+            classListBind &&
+                (0, common_1.setValidValue)(xProps, 'classNameListBind', {
+                    type: classListBind.type,
+                    propertyPath: 'classNameList',
+                    bindDataPath: classListBind.value,
+                });
+            if (styleBind && styleBind.type !== 'static') {
+                xProps.styleBind = {
+                    type: styleBind.type,
+                    propertyPath: 'style',
+                    bindDataPath: styleBind.value,
+                };
+            }
+            xProps.listenerInstances = readListeners(cmp.xProps.listeners) || [];
+            readDynamicData(cmp.xProps.data, xProps, cmp.properties);
+            if (cmp.xProps.directives) {
+                const { waIf, waFor, waForKey } = cmp.xProps.directives;
+                if (waIf) {
+                    if (waIf.type === 'static' || waIf.type === undefined) {
+                        xProps.data = xProps.data || {};
+                        xProps.data._visible = waIf.value;
+                    }
+                    else {
+                        xProps.dataBinds = xProps.dataBinds || [];
+                        xProps.dataBinds.push({
+                            type: waIf.type || types_1.PropBindType.state,
+                            propertyPath: '_visible',
+                            bindDataPath: waIf.value,
+                        });
+                        xProps.dataTypes.push({
+                            propertyPath: '_visible',
+                            type: 'bind',
+                        });
+                    }
+                }
+                if (waFor && waFor.type !== 'static') {
+                    xProps.dataBinds = xProps.dataBinds || [];
+                    xProps.dataBinds.push({
+                        type: waFor.type || types_1.PropBindType.state,
+                        propertyPath: '_waFor',
+                        bindDataPath: waFor.value,
+                    });
+                    xProps.dataTypes.push({
+                        propertyPath: '_waFor',
+                        type: 'bind',
+                    });
+                    if (waForKey && (waForKey.type === 'static' || waForKey.type === undefined)) {
+                        xProps.data = xProps.data || {};
+                        xProps.data._waForKey = waForKey.value;
+                    }
+                }
+            }
+            else {
+                xProps.data = xProps.data || {};
+                xProps.data._visible = true;
+            }
+            (0, common_1.setValidValue)(target, 'x-component', xCmp.toLocaleLowerCase());
+            (0, common_1.setValidValue)(xProps, 'customDataForm', cmp.xProps.customDataForm);
+            target['x-props'] = xProps;
+            (0, common_1.setValidValue)(target, 'x-index', cmp.xIndex);
+        }
+    }
+    return properties;
+}
+exports.readCmpInstances = readCmpInstances;
+function readListeners(listeners = []) {
+    return listeners.map((l) => {
+        const { handler } = l;
+        const act = {
+            key: l.key || '',
+            sourceKey: handler ? handler.moduleName + ':' + handler.name : '',
+            trigger: l.trigger,
+            type: l.type,
+            data: {},
+            dataBinds: [],
+            handler: l.handler,
+            jsCode: l.jsCode,
+            isCapturePhase: l.isCapturePhase,
+            noPropagation: l.noPropagation,
+        };
+        readDynamicData(l.data, act);
+        return act;
+    });
+}
+function readDynamicData(from = {}, to, properties) {
+    to.dataTypes = to.dataTypes || [];
+    for (const prop in from) {
+        const dv = from[prop];
+        if (dv.type === 'static' || dv.type === undefined) {
+            to.data = to.data || {};
+            to.data[prop] = dv.value;
+            to.dataTypes.push({
+                propertyPath: prop,
+                type: 'static',
+            });
+        }
+        else if (dv.type === 'slot') {
+            to.dataTypes.push({
+                propertyPath: prop,
+                type: 'slot',
+            });
+        }
+        else {
+            to.dataBinds = to.dataBinds || [];
+            to.dataBinds.push({
+                propertyPath: prop,
+                bindDataPath: dv.value,
+                type: dv.type,
+            });
+            to.dataTypes.push({
+                propertyPath: prop,
+                type: 'bind',
+            });
+        }
+    }
+    if (properties) {
+        Object.keys(properties).forEach((key) => {
+            const foundOne = to.dataTypes.find((dataType) => dataType.propertyPath === key);
+            if (foundOne) {
+                foundOne.type = 'slot';
+            }
+            else {
+                if (!properties[key].xComponent)
+                    to.dataTypes.push({
+                        propertyPath: key,
+                        type: 'slot',
+                    });
+            }
+        });
+    }
+}

package/lib/weapps-core/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from './formily';
+export * from './style';
+export * from './common';
+export * from './lowcdoe';
+export * from './file';
+export * from './appbuild';
+//# sourceMappingURL=index.d.ts.map

package/lib/weapps-core/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/weapps-core/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC"}

package/lib/weapps-core/utils/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;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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("./formily"), exports);
+__exportStar(require("./style"), exports);
+__exportStar(require("./common"), exports);
+__exportStar(require("./lowcdoe"), exports);
+__exportStar(require("./file"), exports);
+__exportStar(require("./appbuild"), exports);

package/lib/weapps-core/utils/lowcdoe.d.ts

@@ -0,0 +1,4 @@
+import { ILowCodesModifyStatus, IWeAppData, ILockedPage } from '../types';
+export declare function evalExpression(code: string, runtime: any): any;
+export declare function receiveDataByLowcodeDiff(lastestAppData: IWeAppData, appSaveData: IWeAppData, allLowCodes: ILowCodesModifyStatus[], redisLockedPages: ILockedPage[], username: string): void;
+//# sourceMappingURL=lowcdoe.d.ts.map

package/lib/weapps-core/utils/lowcdoe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lowcdoe.d.ts","sourceRoot":"","sources":["../../../src/weapps-core/utils/lowcdoe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AACzE,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAMxD;AAiBD,wBAAgB,wBAAwB,CACtC,cAAc,EAAE,UAAU,EAC1B,WAAW,EAAE,UAAU,EACvB,WAAW,EAAE,qBAAqB,EAAE,EACpC,gBAAgB,EAAE,WAAW,EAAE,EAC/B,QAAQ,EAAE,MAAM,QAwDjB"}

package/lib/weapps-core/utils/lowcdoe.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.receiveDataByLowcodeDiff = exports.evalExpression = void 0;
+function evalExpression(code, runtime) {
+    try {
+        return runtime.eval(`(function(forItems, $context){const $for = forItems; return ${code};})`);
+    }
+    catch (e) {
+        runtime.console.error(`Error in expression:\t${code}\n\n`, e);
+    }
+}
+exports.evalExpression = evalExpression;
+function findLowcodeItem(appData, lowcodeDiff) {
+    const pathKeys = lowcodeDiff.path.split('/');
+    if (pathKeys[0] === 'global') {
+        return appData.lowCodes.find((item) => item.path === lowcodeDiff.path);
+    }
+    else {
+        const pageInstance = appData.pageInstanceList.find((item) => item.id === pathKeys[0]);
+        return pageInstance.lowCodes.find((item) => item.path === lowcodeDiff.path);
+    }
+}
+function receiveDataByLowcodeDiff(lastestAppData, appSaveData, allLowCodes, redisLockedPages, username) {
+    allLowCodes.forEach((lowcodeDiff) => {
+        const cannotDel = redisLockedPages.find((lockedPage) => lockedPage.id === lowcodeDiff.path && username !== lockedPage.username);
+        if (cannotDel)
+            return;
+        const pathKeys = lowcodeDiff.path.split('/');
+        let index = -1;
+        switch (lowcodeDiff.type) {
+            case 'add':
+            case 'mod':
+                if (pathKeys[0] === 'global') {
+                    const lowcode = findLowcodeItem(appSaveData, lowcodeDiff);
+                    index = lastestAppData.lowCodes.findIndex((item) => item.path === lowcodeDiff.path);
+                    if (index === -1) {
+                        lastestAppData.lowCodes.push(lowcode);
+                    }
+                    else {
+                        lastestAppData.lowCodes[index] = lowcode;
+                    }
+                }
+                else {
+                    const lowcode = findLowcodeItem(appSaveData, lowcodeDiff);
+                    const pageInstance = lastestAppData.pageInstanceList.find((item) => item.id === pathKeys[0]);
+                    index = pageInstance.lowCodes.findIndex((item) => item.path === lowcodeDiff.path);
+                    if (index === -1) {
+                        pageInstance.lowCodes.push(lowcode);
+                    }
+                    else {
+                        pageInstance.lowCodes[index] = lowcode;
+                    }
+                }
+                break;
+            case 'del':
+                if (pathKeys[0] === 'global') {
+                    index = lastestAppData.lowCodes.findIndex((item) => item.path === lowcodeDiff.path);
+                    index > -1 && lastestAppData.lowCodes.splice(index, 1);
+                }
+                else {
+                    const pageInstance = lastestAppData.pageInstanceList.find((item) => item.id === pathKeys[0]);
+                    index = pageInstance.lowCodes.findIndex((item) => item.path === lowcodeDiff.path);
+                    index > -1 && pageInstance.lowCodes.splice(index, 1);
+                }
+                break;
+        }
+    });
+}
+exports.receiveDataByLowcodeDiff = receiveDataByLowcodeDiff;

package/lib/weapps-core/utils/style.d.ts

@@ -0,0 +1,17 @@
+import { CSSProperties, ICommonStyle } from '../types';
+export declare function toCssStyle(commonStyle?: ICommonStyle, options?: {
+    toRem: boolean;
+    ignoreSelf?: boolean;
+    addPXUnit?: boolean;
+    toRpx?: boolean;
+}): CSSProperties;
+export declare function removeInvalidStyleFormValue(styleForm?: ICommonStyle): ICommonStyle;
+export declare function translateStyleToRpx(style?: CSSProperties): CSSProperties;
+export declare function translateStyleToRem(style?: CSSProperties): CSSProperties;
+export declare function translateStyleByHandler(style: any, handler: (p: string) => string): {};
+export declare function toREM(cssLen: number | string): string;
+export declare function toRPX(cssLen: number | string): string;
+export declare function removeWrapperBadEffectStyle(commonStyle?: CSSProperties): CSSProperties;
+export declare function removeEffectTwiceStyle(commonStyle?: CSSProperties): CSSProperties;
+export declare function toCssText(style: CSSProperties, className?: string): string;
+//# sourceMappingURL=style.d.ts.map

package/lib/weapps-core/utils/style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"style.d.ts","sourceRoot":"","sources":["../../../src/weapps-core/utils/style.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAqBvD,wBAAgB,UAAU,CACxB,WAAW,GAAE,YAAiB,EAC9B,OAAO,GAAE;IACP,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;CACoD,GACrE,aAAa,CAgNf;AAED,wBAAgB,2BAA2B,CAAC,SAAS,GAAE,YAAiB,GAAG,YAAY,CAUtF;AAyCD,wBAAgB,mBAAmB,CAAC,KAAK,GAAE,aAAkB,GAAG,aAAa,CAE5E;AAED,wBAAgB,mBAAmB,CAAC,KAAK,GAAE,aAAkB,GAAG,aAAa,CAE5E;AAED,wBAAgB,uBAAuB,CAAC,KAAK,KAAoB,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,MAUhG;AA0BD,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAiBrD;AAED,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAcrD;AAED,wBAAgB,2BAA2B,CAAC,WAAW,GAAE,aAAkB,GAAG,aAAa,CAgB1F;AAED,wBAAgB,sBAAsB,CAAC,WAAW,GAAE,aAAkB,GAAG,aAAa,CAoBrF;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,aAAa,EAAE,SAAS,SAAqB,UAQ7E"}