amis-core 2.8.0 → 3.0.0

package/esm/utils/renderer-event.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v2.8.0
+ * amis-core v3.0.0
  * Copyright 2018-2023 fex
  */
 
@@ -34,7 +34,7 @@ function createRendererEvent(type, context) {
 // 绑定事件
 var bindEvent = function (renderer) {
     var e_1, _a;
-    var _b, _c;
+    var _b, _c, _d;
     if (!renderer) {
         return undefined;
     }
@@ -49,15 +49,16 @@ var bindEvent = function (renderer) {
                 rendererEventListeners = rendererEventListeners.filter(function (item) {
                     return !(item.renderer === listener.renderer && item.type === listener.type);
                 });
-                rendererEventListeners.push({
-                    renderer: renderer,
-                    type: key,
-                    debounce: listener.debounce || null,
-                    weight: listener.weight || 0,
-                    actions: listener.actions
-                });
+                listener.actions.length &&
+                    rendererEventListeners.push({
+                        renderer: renderer,
+                        type: key,
+                        debounce: listener.debounce || null,
+                        weight: listener.weight || 0,
+                        actions: listener.actions
+                    });
             }
-            if (!listener) {
+            if (!listener && ((_d = listeners[key].actions) === null || _d === void 0 ? void 0 : _d.length)) {
                 rendererEventListeners.push({
                     renderer: renderer,
                     type: key,
@@ -69,15 +70,15 @@ var bindEvent = function (renderer) {
         };
         try {
             // 暂存
-            for (var _d = __values(Object.keys(listeners)), _e = _d.next(); !_e.done; _e = _d.next()) {
-                var key = _e.value;
+            for (var _e = __values(Object.keys(listeners)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var key = _f.value;
                 _loop_1(key);
             }
         }
         catch (e_1_1) { e_1 = { error: e_1_1 }; }
         finally {
             try {
-                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
             }
             finally { if (e_1) throw e_1.error; }
         }
@@ -89,19 +90,20 @@ var bindEvent = function (renderer) {
 };
 // 触发事件
 function dispatchEvent(e, renderer, scoped, data, broadcast) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     return __awaiter(this, void 0, void 0, function () {
         var unbindEvent, eventName, eventConfig, rendererEvent, listeners, executedCount, checkExecuted, _loop_2, listeners_1, listeners_1_1, listener, state_1, e_2_1;
-        var e_2, _g;
+        var e_2, _j;
         var _this = this;
-        return __generator(this, function (_h) {
-            switch (_h.label) {
+        return __generator(this, function (_k) {
+            switch (_k.label) {
                 case 0:
                     unbindEvent = null;
                     eventName = typeof e === 'string' ? e : e.type;
                     (_c = (_b = (_a = renderer === null || renderer === void 0 ? void 0 : renderer.props) === null || _a === void 0 ? void 0 : _a.env) === null || _b === void 0 ? void 0 : _b.beforeDispatchEvent) === null || _c === void 0 ? void 0 : _c.call(_b, e, renderer, scoped, data, broadcast);
+                    broadcast && ((_e = (_d = renderer.props).onBroadcast) === null || _e === void 0 ? void 0 : _e.call(_d, e, broadcast, data));
                     if (!broadcast) {
-                        eventConfig = (_e = (_d = renderer === null || renderer === void 0 ? void 0 : renderer.props) === null || _d === void 0 ? void 0 : _d.onEvent) === null || _e === void 0 ? void 0 : _e[eventName];
+                        eventConfig = (_g = (_f = renderer === null || renderer === void 0 ? void 0 : renderer.props) === null || _f === void 0 ? void 0 : _f.onEvent) === null || _g === void 0 ? void 0 : _g[eventName];
                         if (!eventConfig) {
                             // 没命中也没关系
                             return [2 /*return*/, Promise.resolve()];
@@ -114,7 +116,7 @@ function dispatchEvent(e, renderer, scoped, data, broadcast) {
                     }
                     rendererEvent = broadcast ||
                         createRendererEvent(eventName, {
-                            env: (_f = renderer === null || renderer === void 0 ? void 0 : renderer.props) === null || _f === void 0 ? void 0 : _f.env,
+                            env: (_h = renderer === null || renderer === void 0 ? void 0 : renderer.props) === null || _h === void 0 ? void 0 : _h.env,
                             nativeEvent: e,
                             data: data,
                             scoped: scoped
@@ -135,11 +137,11 @@ function dispatchEvent(e, renderer, scoped, data, broadcast) {
                         }
                     };
                     _loop_2 = function (listener) {
-                        var _j, _k, wait, _l, trailing, _m, leading, _o, maxWait, debounced_1;
-                        return __generator(this, function (_p) {
-                            switch (_p.label) {
+                        var _l, _m, wait, _o, trailing, _p, leading, _q, maxWait, debounced_1;
+                        return __generator(this, function (_r) {
+                            switch (_r.label) {
                                 case 0:
-                                    _j = (listener === null || listener === void 0 ? void 0 : listener.debounce) || {}, _k = _j.wait, wait = _k === void 0 ? 100 : _k, _l = _j.trailing, trailing = _l === void 0 ? true : _l, _m = _j.leading, leading = _m === void 0 ? false : _m, _o = _j.maxWait, maxWait = _o === void 0 ? 10000 : _o;
+                                    _l = (listener === null || listener === void 0 ? void 0 : listener.debounce) || {}, _m = _l.wait, wait = _m === void 0 ? 100 : _m, _o = _l.trailing, trailing = _o === void 0 ? true : _o, _p = _l.leading, leading = _p === void 0 ? false : _p, _q = _l.maxWait, maxWait = _q === void 0 ? 10000 : _q;
                                     if (!(listener === null || listener === void 0 ? void 0 : listener.debounce)) return [3 /*break*/, 1];
                                     debounced_1 = debounce(function () { return __awaiter(_this, void 0, void 0, function () {
                                         return __generator(this, function (_a) {
@@ -168,9 +170,9 @@ function dispatchEvent(e, renderer, scoped, data, broadcast) {
                                     return [3 /*break*/, 3];
                                 case 1: return [4 /*yield*/, runActions(listener.actions, listener.renderer, rendererEvent)];
                                 case 2:
-                                    _p.sent();
+                                    _r.sent();
                                     checkExecuted();
-                                    _p.label = 3;
+                                    _r.label = 3;
                                 case 3:
                                     // 停止后续监听器执行
                                     if (rendererEvent.stoped) {
@@ -180,31 +182,31 @@ function dispatchEvent(e, renderer, scoped, data, broadcast) {
                             }
                         });
                     };
-                    _h.label = 1;
+                    _k.label = 1;
                 case 1:
-                    _h.trys.push([1, 6, 7, 8]);
+                    _k.trys.push([1, 6, 7, 8]);
                     listeners_1 = __values(listeners), listeners_1_1 = listeners_1.next();
-                    _h.label = 2;
+                    _k.label = 2;
                 case 2:
                     if (!!listeners_1_1.done) return [3 /*break*/, 5];
                     listener = listeners_1_1.value;
                     return [5 /*yield**/, _loop_2(listener)];
                 case 3:
-                    state_1 = _h.sent();
+                    state_1 = _k.sent();
                     if (state_1 === "break")
                         return [3 /*break*/, 5];
-                    _h.label = 4;
+                    _k.label = 4;
                 case 4:
                     listeners_1_1 = listeners_1.next();
                     return [3 /*break*/, 2];
                 case 5: return [3 /*break*/, 8];
                 case 6:
-                    e_2_1 = _h.sent();
+                    e_2_1 = _k.sent();
                     e_2 = { error: e_2_1 };
                     return [3 /*break*/, 8];
                 case 7:
                     try {
-                        if (listeners_1_1 && !listeners_1_1.done && (_g = listeners_1.return)) _g.call(listeners_1);
+                        if (listeners_1_1 && !listeners_1_1.done && (_j = listeners_1.return)) _j.call(listeners_1);
                     }
                     finally { if (e_2) throw e_2.error; }
                     return [7 /*endfinally*/];
@@ -224,6 +226,7 @@ var getRendererEventListeners = function () {
  */
 var resolveEventData = function (props, data, valueKey) {
     var _a, _b;
+    if (valueKey === void 0) { valueKey = 'value'; }
     return createObject(props.data, props.name && valueKey
         ? __assign(__assign({}, data), (_a = {}, _a[props.name] = data[valueKey], _a.__rendererData = __assign(__assign({}, props.data), (_b = {}, _b[props.name] = data[valueKey], _b)), _a)) : data);
 };

package/esm/utils/replaceText.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v2.8.0
+ * amis-core v3.0.0
  * Copyright 2018-2023 fex
  */
 

package/esm/utils/resize-sensor.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v2.8.0
+ * amis-core v3.0.0
  * Copyright 2018-2023 fex
  */
 

package/esm/utils/resolveCondition.d.ts

@@ -0,0 +1,6 @@
+export declare function resolveCondition(conditions: any, data: any, defaultResult?: boolean): Promise<boolean>;
+export declare function registerConditionComputer(op: string, func: (left: any, right: any, fieldType?: string) => boolean, fieldType?: string): void;
+export declare function getConditionComputers(): {
+    [op: string]: (left: any, right: any, fieldType?: string | undefined) => boolean;
+};
+export declare function setConditionComputeErrorHandler(fn: (conditions: any, data: any, defaultResult: boolean) => boolean | Promise<boolean>): void;

package/esm/utils/resolveCondition.js

@@ -0,0 +1,321 @@
+/**
+ * amis-core v3.0.0
+ * Copyright 2018-2023 fex
+ */
+
+import { __awaiter, __generator, __read } from 'tslib';
+import get from 'lodash/get';
+import endsWith from 'lodash/endsWith';
+import isEmpty from 'lodash/isEmpty';
+import isEqual from 'lodash/isEqual';
+import startsWith from 'lodash/startsWith';
+import { resolveVariableAndFilterForAsync } from './resolveVariableAndFilterForAsync.js';
+import moment from 'moment';
+import capitalize from 'lodash/capitalize';
+
+var conditionResolverMap = {};
+var DEFAULT_RESULT = true;
+var conditionComputeErrorHandler;
+function resolveCondition(conditions, data, defaultResult) {
+    if (defaultResult === void 0) { defaultResult = true; }
+    return __awaiter(this, void 0, void 0, function () {
+        var e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!conditions ||
+                        !conditions.conjunction ||
+                        !Array.isArray(conditions.children) ||
+                        !conditions.children.length) {
+                        return [2 /*return*/, defaultResult];
+                    }
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 6]);
+                    return [4 /*yield*/, computeConditions(conditions.children, conditions.conjunction, data)];
+                case 2: return [2 /*return*/, _a.sent()];
+                case 3:
+                    e_1 = _a.sent();
+                    if (!(e_1.name === 'FormulaEvalError')) return [3 /*break*/, 5];
+                    return [4 /*yield*/, (conditionComputeErrorHandler === null || conditionComputeErrorHandler === void 0 ? void 0 : conditionComputeErrorHandler(conditions.children, conditions.conjunction, data))];
+                case 4: return [2 /*return*/, _a.sent()];
+                case 5: return [2 /*return*/, defaultResult];
+                case 6: return [2 /*return*/];
+            }
+        });
+    });
+}
+function computeConditions(conditions, conjunction, data) {
+    if (conjunction === void 0) { conjunction = 'and'; }
+    return __awaiter(this, void 0, void 0, function () {
+        var computeResult, index, len, item, result, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    computeResult = true;
+                    index = 0, len = conditions.length;
+                    _b.label = 1;
+                case 1:
+                    if (!(index < len)) return [3 /*break*/, 7];
+                    item = conditions[index];
+                    if (!(item.conjunction && Array.isArray(item.children) && item.children.length)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, computeConditions(item.children, item.conjunction, data)];
+                case 2:
+                    _a = _b.sent();
+                    return [3 /*break*/, 5];
+                case 3: return [4 /*yield*/, computeCondition(item, index, data)];
+                case 4:
+                    _a = _b.sent();
+                    _b.label = 5;
+                case 5:
+                    result = _a;
+                    computeResult = !!result;
+                    if ((result && conjunction === 'or') ||
+                        (!result && conjunction === 'and')) {
+                        return [3 /*break*/, 7];
+                    }
+                    _b.label = 6;
+                case 6:
+                    index++;
+                    return [3 /*break*/, 1];
+                case 7: return [2 /*return*/, computeResult];
+            }
+        });
+    });
+}
+function computeCondition(rule, index, data) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function () {
+        var leftValue, rightValue, func;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    leftValue = get(data, rule.left.field);
+                    return [4 /*yield*/, resolveVariableAndFilterForAsync(rule.right, data, undefined, undefined, true)];
+                case 1:
+                    rightValue = _b.sent();
+                    func = (_a = conditionResolverMap["".concat(rule.op, "For").concat(capitalize(rule.left.type))]) !== null && _a !== void 0 ? _a : conditionResolverMap[rule.op];
+                    return [2 /*return*/, func ? func(leftValue, rightValue, rule.left.type) : DEFAULT_RESULT];
+            }
+        });
+    });
+}
+function startsWithFunc(left, right) {
+    if (left === undefined || right === undefined) {
+        return DEFAULT_RESULT;
+    }
+    return startsWith(left, right);
+}
+function endsWithFunc(left, right) {
+    if (left === undefined || right === undefined) {
+        return DEFAULT_RESULT;
+    }
+    return endsWith(left, right);
+}
+function equalFunc(left, right) {
+    return isEqual(left, right);
+}
+function notEqualFunc(left, right) {
+    return !isEqual(left, right);
+}
+function isEmptyFunc(left) {
+    if (typeof left === 'string') {
+        return !left;
+    }
+    else if (typeof left === 'number') {
+        return left === undefined;
+    }
+    else if (Array.isArray(left)) {
+        return !left.length;
+    }
+    else if (typeof left === 'object') {
+        return isEmpty(left);
+    }
+    return DEFAULT_RESULT;
+}
+function isNotEmptyFunc(left) {
+    if (typeof left === 'string') {
+        return !left;
+    }
+    else if (typeof left === 'number') {
+        return left !== undefined;
+    }
+    else if (Array.isArray(left)) {
+        return !!left.length;
+    }
+    else if (typeof left === 'object') {
+        return !isEmpty(left);
+    }
+    return DEFAULT_RESULT;
+}
+function greaterFunc(left, right) {
+    if (left === undefined || right === undefined) {
+        return DEFAULT_RESULT;
+    }
+    return parseFloat(left) > parseFloat(right);
+}
+function normalizeDate(raw) {
+    if (typeof raw === 'string' || typeof raw === 'number') {
+        var formats = ['', 'YYYY-MM-DD HH:mm:ss', 'X'];
+        if (/^\d{10}((\.\d+)*)$/.test(raw.toString())) {
+            formats = ['X', 'x', 'YYYY-MM-DD HH:mm:ss', ''];
+        }
+        else if (/^\d{13}((\.\d+)*)$/.test(raw.toString())) {
+            formats = ['x', 'X', 'YYYY-MM-DD HH:mm:ss', ''];
+        }
+        while (formats.length) {
+            var format = formats.shift();
+            var date = moment(raw, format);
+            if (date.isValid()) {
+                return date.toDate();
+            }
+        }
+    }
+    return raw;
+}
+function normalizeDateRange(raw) {
+    return (Array.isArray(raw) ? raw : raw.split(',')).map(function (item) {
+        return normalizeDate(String(item).trim());
+    });
+}
+function greaterForDateFunc(left, right) {
+    left = normalizeDate(left);
+    right = normalizeDate(right);
+    return moment(left).isAfter(moment(right), 's');
+}
+function greaterOrEqualForDateFunc(left, right) {
+    left = normalizeDate(left);
+    right = normalizeDate(right);
+    return moment(left).isSameOrAfter(moment(right), 's');
+}
+function greaterOrEqualFunc(left, right) {
+    if (left === undefined || right === undefined) {
+        return DEFAULT_RESULT;
+    }
+    return parseFloat(left) >= parseFloat(right);
+}
+function lessFunc(left, right) {
+    if (left === undefined || right === undefined) {
+        return DEFAULT_RESULT;
+    }
+    return parseFloat(left) < parseFloat(right);
+}
+function lessForDateFunc(left, right) {
+    left = normalizeDate(left);
+    right = normalizeDate(right);
+    return moment(left).isBefore(moment(right), 's');
+}
+function lessOrEqualForDateFunc(left, right) {
+    left = normalizeDate(left);
+    right = normalizeDate(right);
+    return moment(left).isSameOrBefore(moment(right), 's');
+}
+function lessOrEqualFunc(left, right) {
+    if (left === undefined || right === undefined) {
+        return DEFAULT_RESULT;
+    }
+    return parseFloat(left) <= parseFloat(right);
+}
+function likeFunc(left, right) {
+    if (left === undefined || right === undefined) {
+        return DEFAULT_RESULT;
+    }
+    return !!~left.indexOf(right);
+}
+function notLikeFunc(left, right) {
+    if (left === undefined || right === undefined) {
+        return DEFAULT_RESULT;
+    }
+    return !~left.indexOf(right);
+}
+function betweenFunc(left, right) {
+    if (typeof left === 'number' && right !== undefined) {
+        var _a = __read(right.sort(), 2), min = _a[0], max = _a[1];
+        return left >= parseFloat(min) && left <= parseFloat(max);
+    }
+    return DEFAULT_RESULT;
+}
+function betweenForDateFunc(left, right) {
+    if (right !== undefined) {
+        var _a = __read(normalizeDateRange(right), 2), min = _a[0], max = _a[1];
+        return moment(normalizeDate(left)).isBetween(min, max, 's', '[]');
+    }
+    return DEFAULT_RESULT;
+}
+function notBetweenFunc(left, right) {
+    if (typeof left === 'number' && right !== undefined) {
+        var _a = __read(right.sort(), 2), min = _a[0], max = _a[1];
+        return left < parseFloat(min) && left > parseFloat(max);
+    }
+    return DEFAULT_RESULT;
+}
+function notBetweenForDateFunc(left, right) {
+    if (right !== undefined) {
+        var _a = __read(normalizeDateRange(right), 2), min = _a[0], max = _a[1];
+        return !moment(normalizeDate(left)).isBetween(min, max, 's', '[]');
+    }
+    return DEFAULT_RESULT;
+}
+function selectAnyInFunc(left, right) {
+    if (!Array.isArray(right)) {
+        return DEFAULT_RESULT;
+    }
+    if (Array.isArray(left)) {
+        return right.every(function (item) { return left.includes(item); });
+    }
+    return right.includes(left);
+}
+function selectNotAnyInFunc(left, right) {
+    if (!Array.isArray(right)) {
+        return DEFAULT_RESULT;
+    }
+    if (Array.isArray(left)) {
+        return !right.every(function (item) { return left.includes(item); });
+    }
+    return !right.includes(left);
+}
+function registerConditionComputer(op, func, fieldType) {
+    conditionResolverMap["".concat(op).concat(fieldType ? 'For' + capitalize(fieldType) : '')] = func;
+}
+function getConditionComputers() {
+    return conditionResolverMap;
+}
+function setConditionComputeErrorHandler(fn) {
+    conditionComputeErrorHandler = fn;
+}
+registerConditionComputer('greater', greaterFunc);
+registerConditionComputer('greater', greaterForDateFunc, 'date');
+registerConditionComputer('greater', greaterForDateFunc, 'time');
+registerConditionComputer('greater', greaterForDateFunc, 'datetime');
+registerConditionComputer('greater_or_equal', greaterOrEqualFunc);
+registerConditionComputer('greater_or_equal', greaterOrEqualForDateFunc, 'date');
+registerConditionComputer('greater_or_equal', greaterOrEqualForDateFunc, 'time');
+registerConditionComputer('greater_or_equal', greaterOrEqualForDateFunc, 'datetime');
+registerConditionComputer('less', lessFunc);
+registerConditionComputer('less', lessForDateFunc, 'date');
+registerConditionComputer('less', lessForDateFunc, 'time');
+registerConditionComputer('less', lessForDateFunc, 'datetime');
+registerConditionComputer('less_or_equal', lessOrEqualFunc);
+registerConditionComputer('less_or_equal', lessOrEqualForDateFunc, 'date');
+registerConditionComputer('less_or_equal', lessOrEqualForDateFunc, 'time');
+registerConditionComputer('less_or_equal', lessOrEqualForDateFunc, 'datetime');
+registerConditionComputer('is_empty', isEmptyFunc);
+registerConditionComputer('is_not_empty', isNotEmptyFunc);
+registerConditionComputer('between', betweenFunc);
+registerConditionComputer('between', betweenForDateFunc, 'date');
+registerConditionComputer('between', betweenForDateFunc, 'time');
+registerConditionComputer('between', betweenForDateFunc, 'datetime');
+registerConditionComputer('not_between', notBetweenFunc);
+registerConditionComputer('not_between', notBetweenForDateFunc, 'date');
+registerConditionComputer('not_between', notBetweenForDateFunc, 'time');
+registerConditionComputer('not_between', notBetweenForDateFunc, 'datetime');
+registerConditionComputer('equal', equalFunc);
+registerConditionComputer('not_equal', notEqualFunc);
+registerConditionComputer('like', likeFunc);
+registerConditionComputer('not_like', notLikeFunc);
+registerConditionComputer('select_any_in', selectAnyInFunc);
+registerConditionComputer('select_not_any_in', selectNotAnyInFunc);
+registerConditionComputer('starts_with', startsWithFunc);
+registerConditionComputer('ends_with', endsWithFunc);
+
+export { getConditionComputers, registerConditionComputer, resolveCondition, setConditionComputeErrorHandler };

package/esm/utils/resolveVariable.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v2.8.0
+ * amis-core v3.0.0
  * Copyright 2018-2023 fex
  */
 

package/esm/utils/resolveVariableAndFilter.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v2.8.0
+ * amis-core v3.0.0
  * Copyright 2018-2023 fex
  */
 

package/esm/utils/resolveVariableAndFilterForAsync.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 设置自定义函数，functions中找不到处理的函数时执行
+ * @param fn
+ */
+export declare function setFormulaEvalErrorHandler(fn: (path: string, data?: object, ...args: any[]) => any): void;
+export declare const resolveVariableAndFilterForAsync: (path?: string, data?: object, defaultFilter?: string, fallbackValue?: (value: any) => any, skipFormulaEvalErrorHandler?: boolean) => Promise<any>;

package/esm/utils/resolveVariableAndFilterForAsync.js

@@ -0,0 +1,63 @@
+/**
+ * amis-core v3.0.0
+ * Copyright 2018-2023 fex
+ */
+
+import { __awaiter, __generator } from 'tslib';
+import { parse, AsyncEvaluator } from 'amis-formula';
+
+var formulaEvalErrorHandler;
+/**
+ * 设置自定义函数，functions中找不到处理的函数时执行
+ * @param fn
+ */
+function setFormulaEvalErrorHandler(fn) {
+    formulaEvalErrorHandler = fn;
+}
+var resolveVariableAndFilterForAsync = function (path, data, defaultFilter, fallbackValue, skipFormulaEvalErrorHandler) {
+    if (data === void 0) { data = {}; }
+    if (defaultFilter === void 0) { defaultFilter = '| html'; }
+    if (fallbackValue === void 0) { fallbackValue = function (value) { return value; }; }
+    if (skipFormulaEvalErrorHandler === void 0) { skipFormulaEvalErrorHandler = false; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var ast, ret, e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!path || typeof path !== 'string') {
+                        return [2 /*return*/, undefined];
+                    }
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    ast = parse(path, {
+                        evalMode: false,
+                        allowFilter: true
+                    });
+                    return [4 /*yield*/, new AsyncEvaluator(data, {
+                            defaultFilter: defaultFilter
+                        }).evalute(ast)];
+                case 2:
+                    ret = _a.sent();
+                    return [2 /*return*/, ret == null && !~path.indexOf('default') && !~path.indexOf('now')
+                            ? fallbackValue(ret)
+                            : ret];
+                case 3:
+                    e_1 = _a.sent();
+                    console.warn(e_1);
+                    if (e_1.name === 'FormulaEvalError') {
+                        if (!skipFormulaEvalErrorHandler) {
+                            // 无法解析时，执行handler自定义解析逻辑
+                            return [2 /*return*/, formulaEvalErrorHandler === null || formulaEvalErrorHandler === void 0 ? void 0 : formulaEvalErrorHandler(path, data, defaultFilter, fallbackValue)];
+                        }
+                        // 跳过自定义解析逻辑，则直接抛异常
+                        throw e_1;
+                    }
+                    return [2 /*return*/, undefined];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+};
+
+export { resolveVariableAndFilterForAsync, setFormulaEvalErrorHandler };

package/esm/utils/scrollPosition.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v2.8.0
+ * amis-core v3.0.0
  * Copyright 2018-2023 fex
  */
 

package/esm/utils/string2regExp.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v2.8.0
+ * amis-core v3.0.0
  * Copyright 2018-2023 fex
  */
 

package/esm/utils/stripNumber.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v2.8.0
+ * amis-core v3.0.0
  * Copyright 2018-2023 fex
  */
 

package/esm/utils/style-helper.d.ts

@@ -1,5 +1,6 @@
 import { PlainObject } from '../types';
 export declare const valueMap: PlainObject;
+export declare const inheritValueMap: PlainObject;
 interface extra {
     pre?: string;
     suf?: string;
@@ -7,7 +8,7 @@ interface extra {
 export declare function findOrCreactStyle(id: string): HTMLElement;
 export declare function insertStyle(style: string, id: string): void;
 export declare function addStyle(style: string, id: string): void;
-export declare function formatStyle(css: any, classNames: {
+export declare function formatStyle(themeCss: any, classNames: {
     key: string;
     value?: string;
     weights?: {
@@ -16,14 +17,14 @@ export declare function formatStyle(css: any, classNames: {
         active?: extra;
         disabled?: extra;
     };
-}[], id?: string): {
+}[], id?: string, defaultData?: any): {
     value: string;
     origin: {
         className: string;
         content: string;
     }[];
 };
-export declare function insertCustomStyle(css: any, classNames: {
+export declare function insertCustomStyle(themeCss: any, classNames: {
     key: string;
     value?: string;
     weights?: {
@@ -32,5 +33,9 @@ export declare function insertCustomStyle(css: any, classNames: {
         active?: extra;
         disabled?: extra;
     };
-}[], id?: string): void;
+}[], id?: string, defaultData?: any): void;
+/**
+ * 根据路径获取默认值
+ */
+export declare function getValueByPath(path: string, data: any): any;
 export {};