@mpxjs/webpack-plugin 2.9.62 → 2.9.65

package/lib/runtime/components/react/dist/mpx-web-view.jsx

@@ -1,14 +1,15 @@
-import { forwardRef, useEffect } from 'react';
-// @ts-ignore
-import { noop } from '@mpxjs/utils';
+import { forwardRef, useEffect, useRef } from 'react';
+import { noop, warn } from '@mpxjs/utils';
 import { Portal } from '@ant-design/react-native';
 import { getCustomEvent } from './getInnerListeners';
 import { promisify, redirectTo, navigateTo, navigateBack, reLaunch, switchTab } from '@mpxjs/api-proxy';
-// @ts-ignore
 import { WebView } from 'react-native-webview';
 import useNodesRef from './useNodesRef';
 const _WebView = forwardRef((props, ref) => {
     const { src, bindmessage = noop, bindload = noop, binderror = noop } = props;
+    if (props.style) {
+        warn('The web-view component does not support the style prop.');
+    }
     const defaultWebViewStyle = {
         position: 'absolute',
         left: 0,
@@ -16,7 +17,8 @@ const _WebView = forwardRef((props, ref) => {
         top: 0,
         bottom: 0
     };
-    const { nodeRef: webViewRef } = useNodesRef(props, ref, {
+    const webViewRef = useRef(null);
+    useNodesRef(props, ref, webViewRef, {
         defaultStyle: defaultWebViewStyle
     });
     const _messageList = [];
@@ -56,12 +58,14 @@ const _WebView = forwardRef((props, ref) => {
         binderror(result);
     };
     const _message = function (res) {
-        let data;
+        let data = {};
         let asyncCallback;
         const navObj = promisify({ redirectTo, navigateTo, navigateBack, reLaunch, switchTab });
         try {
             const nativeEventData = res.nativeEvent?.data;
-            data = JSON.parse(nativeEventData);
+            if (typeof nativeEventData === 'string') {
+                data = JSON.parse(nativeEventData);
+            }
         }
         catch (e) {
             data = {};

package/lib/runtime/components/react/dist/parser.js

@@ -0,0 +1,218 @@
+export class ExpressionParser {
+    tokens;
+    formatter;
+    functions;
+    current;
+    constructor(input, formatter = val => parseFloat(val), functions = {}) {
+        this.tokens = this.tokenize(input);
+        this.formatter = formatter;
+        this.functions = functions;
+        this.current = 0;
+    }
+    tokenize(input) {
+        const tokens = [];
+        const regex = /(\d+\.?\d*(?:px|rpx|%|vw|vh)?|[+\-*/(),]|\b[a-zA-Z_][a-zA-Z0-9_]*\b)/g;
+        let match;
+        while ((match = regex.exec(input))) {
+            if (/^\d+\.?\d*(?:px|rpx|%|vw|vh)?$/.test(match[0])) {
+                const lastToken = tokens[tokens.length - 1];
+                const last2Token = tokens[tokens.length - 2];
+                if (lastToken?.type === '-' && (!last2Token || /^[+\-*/(,]$/.test(last2Token?.type))) {
+                    tokens.pop();
+                    tokens.push({
+                        type: 'NUMBER',
+                        value: '-' + match[0]
+                    });
+                }
+                else {
+                    tokens.push({
+                        type: 'NUMBER',
+                        value: match[0]
+                    });
+                }
+            }
+            else {
+                tokens.push({
+                    type: match[0],
+                    value: match[0]
+                });
+            }
+        }
+        return tokens;
+    }
+    parse() {
+        return this.expression();
+    }
+    expression() {
+        let node = this.term();
+        while (this.current < this.tokens.length &&
+            (this.tokens[this.current].type === '+' || this.tokens[this.current].type === '-')) {
+            const operator = this.tokens[this.current].type;
+            this.current++;
+            const right = this.term();
+            node = this.applyOperator(operator, node, right);
+        }
+        return node;
+    }
+    term() {
+        let node = this.factor();
+        while (this.current < this.tokens.length &&
+            (this.tokens[this.current].type === '*' || this.tokens[this.current].type === '/')) {
+            const operator = this.tokens[this.current].type;
+            this.current++;
+            const right = this.factor();
+            node = this.applyOperator(operator, node, right);
+        }
+        return node;
+    }
+    factor() {
+        const token = this.tokens[this.current];
+        if (token.type === 'NUMBER') {
+            this.current++;
+            const numericValue = this.formatter(token.value);
+            return { type: 'NUMBER', value: numericValue };
+        }
+        else if (token.type === '(') {
+            this.current++;
+            const node = this.expression();
+            if (this.tokens[this.current].type !== ')') {
+                throw new Error('Expected closing parenthesis');
+            }
+            this.current++;
+            return node;
+        }
+        else if (this.functions[token.type]) {
+            this.current++;
+            if (this.tokens[this.current].type !== '(') {
+                throw new Error('Expected opening parenthesis after function');
+            }
+            this.current++;
+            const args = this.parseArguments();
+            if (this.tokens[this.current].type !== ')') {
+                throw new Error('Expected closing parenthesis');
+            }
+            this.current++;
+            return this.applyFunction(token.type, args);
+        }
+        throw new Error(`Unexpected token: ${token.type}`);
+    }
+    parseArguments() {
+        const args = [];
+        while (this.current < this.tokens.length && this.tokens[this.current].type !== ')') {
+            args.push(this.expression());
+            if (this.tokens[this.current].type === ',') {
+                this.current++;
+            }
+        }
+        return args;
+    }
+    applyOperator(operator, left, right) {
+        const leftVal = left.value;
+        const rightVal = right.value;
+        let result;
+        switch (operator) {
+            case '+':
+                result = leftVal + rightVal;
+                break;
+            case '-':
+                result = leftVal - rightVal;
+                break;
+            case '*':
+                result = leftVal * rightVal;
+                break;
+            case '/':
+                result = leftVal / rightVal;
+                break;
+            default: throw new Error(`Unknown operator: ${operator}`);
+        }
+        return { type: 'NUMBER', value: result };
+    }
+    applyFunction(func, args) {
+        if (args.some(arg => arg.type !== 'NUMBER')) {
+            throw new Error('Function arguments must be numbers');
+        }
+        const numericArgs = args.map(arg => arg.value);
+        if (this.functions[func]) {
+            return { type: 'NUMBER', value: this.functions[func].apply(null, numericArgs) };
+        }
+        else {
+            throw new Error(`Unknown function: ${func}`);
+        }
+    }
+}
+export function parseFunc(str, funcName) {
+    const regex = new RegExp(`${funcName}\\(`, 'g');
+    const result = [];
+    let match;
+    while ((match = regex.exec(str)) !== null) {
+        const start = match.index;
+        let i = start + funcName.length + 1;
+        let depth = 1;
+        const args = [];
+        let arg = '';
+        while (depth && i < str.length) {
+            if (depth === 1 && (str[i] === ',' || str[i] === ')')) {
+                args.push(arg.trim());
+                arg = '';
+            }
+            else {
+                arg += str[i];
+            }
+            switch (str[i]) {
+                case '(':
+                    depth++;
+                    break;
+                case ')':
+                    depth--;
+                    break;
+                default:
+                // Do nothing
+            }
+            i++;
+        }
+        const end = regex.lastIndex = i;
+        result.push({
+            start,
+            end,
+            args
+        });
+    }
+    return result;
+}
+export class ReplaceSource {
+    _source;
+    _replacements;
+    constructor(source) {
+        this._source = source;
+        this._replacements = [];
+    }
+    replace(start, end, content) {
+        this._replacements.push({ start, end, content });
+    }
+    source() {
+        if (this._replacements.length === 0) {
+            return this._source;
+        }
+        let current = this._source;
+        let pos = 0;
+        const result = [];
+        for (const replacement of this._replacements) {
+            const start = Math.floor(replacement.start);
+            const end = Math.floor(replacement.end) + 1;
+            if (pos < start) {
+                const offset = start - pos;
+                result.push(current.slice(0, offset));
+                current = current.slice(offset);
+                pos = start;
+            }
+            result.push(replacement.content);
+            if (pos < end) {
+                const offset = end - pos;
+                current = current.slice(offset);
+                pos = end;
+            }
+        }
+        result.push(current);
+        return result.join('');
+    }
+}

package/lib/runtime/components/react/dist/useNodesRef.js

@@ -1,6 +1,5 @@
 import { useRef, useImperativeHandle } from 'react';
-export default function useNodesRef(props, ref, instance = {}) {
-    const nodeRef = useRef(null);
+export default function useNodesRef(props, ref, nodeRef, instance = {}) {
     const _props = useRef(null);
     _props.current = props;
     useImperativeHandle(ref, () => {
@@ -14,7 +13,4 @@ export default function useNodesRef(props, ref, instance = {}) {
             }
         };
     });
-    return {
-        nodeRef
-    };
 }