amis-core 2.8.0 → 2.9.0

package/esm/utils/resolveCondition.js

@@ -0,0 +1,306 @@
+/**
+ * amis-core v2.9.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;
+function resolveCondition(conditions, data, defaultResult) {
+    if (defaultResult === void 0) { defaultResult = true; }
+    return __awaiter(this, void 0, void 0, function () {
+        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];
+                    }
+                    return [4 /*yield*/, computeConditions(conditions.children, conditions.conjunction, data)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+}
+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)];
+                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;
+}
+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 };

package/esm/utils/resolveVariable.js

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

package/esm/utils/resolveVariableAndFilter.js

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

package/esm/utils/resolveVariableAndFilterForAsync.d.ts

@@ -0,0 +1 @@
+export declare const resolveVariableAndFilterForAsync: (path?: string, data?: object, defaultFilter?: string, fallbackValue?: (value: any) => any) => Promise<any>;

package/esm/utils/resolveVariableAndFilterForAsync.js

@@ -0,0 +1,46 @@
+/**
+ * amis-core v2.9.0
+ * Copyright 2018-2023 fex
+ */
+
+import { __awaiter, __generator } from 'tslib';
+import { parse, AsyncEvaluator } from 'amis-formula';
+
+var resolveVariableAndFilterForAsync = function (path, data, defaultFilter, fallbackValue) {
+    if (data === void 0) { data = {}; }
+    if (defaultFilter === void 0) { defaultFilter = '| html'; }
+    if (fallbackValue === void 0) { fallbackValue = function (value) { return value; }; }
+    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);
+                    return [2 /*return*/, undefined];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+};
+
+export { resolveVariableAndFilterForAsync };

package/esm/utils/scrollPosition.js

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

package/esm/utils/string2regExp.js

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

package/esm/utils/stripNumber.js

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

package/esm/utils/style-helper.js

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

package/esm/utils/style.js

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

package/esm/utils/toNumber.js

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

package/esm/utils/tokenize.js

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

package/esm/utils/tpl-builtin.js

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

package/esm/utils/tpl-lodash.js

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

package/esm/utils/tpl.d.ts

@@ -7,5 +7,12 @@ export declare function registerTplEnginer(name: string, enginer: Enginer): void
 export declare function filter(tpl?: any, data?: object, ...rest: Array<any>): string;
 export declare function setCustomEvalExpression(fn: (expression: string, data?: any) => boolean): void;
 export declare function evalExpression(expression: string, data?: object): boolean;
+/**
+ * 解析表达式（支持condition-builder）
+ * @param expression 表达式 or condition-builder对象
+ * @param data 上下文
+ * @returns
+ */
+export declare function evalExpressionWithConditionBuilder(expression: any, data?: object, defaultResult?: boolean): Promise<boolean>;
 export declare function setCustomEvalJs(fn: (expression: string, data?: any) => any): void;
 export declare function evalJS(js: string, data: object): any;

package/esm/utils/tpl.js

@@ -1,12 +1,13 @@
 /**
- * amis-core v2.8.0
+ * amis-core v2.9.0
  * Copyright 2018-2023 fex
  */
 
-import { __spreadArray, __read } from 'tslib';
+import { __spreadArray, __read, __awaiter, __generator } from 'tslib';
 import { register } from './tpl-builtin.js';
 import { register as register$1 } from './tpl-lodash.js';
 import { getFilters, parse, evaluate } from 'amis-formula';
+import { resolveCondition } from './resolveCondition.js';
 
 var enginers = {};
 function registerTplEnginer(name, enginer) {
@@ -79,6 +80,25 @@ function evalExpression(expression, data) {
         return false;
     }
 }
+/**
+ * 解析表达式（支持condition-builder）
+ * @param expression 表达式 or condition-builder对象
+ * @param data 上下文
+ * @returns
+ */
+function evalExpressionWithConditionBuilder(expression, data, defaultResult) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(Object.prototype.toString.call(expression) === '[object Object]')) return [3 /*break*/, 2];
+                    return [4 /*yield*/, resolveCondition(expression, data, defaultResult)];
+                case 1: return [2 /*return*/, _a.sent()];
+                case 2: return [2 /*return*/, evalExpression(String(expression), data)];
+            }
+        });
+    });
+}
 var AST_CACHE = {};
 function evalFormula(expression, data) {
     var ast = AST_CACHE[expression] ||
@@ -128,4 +148,4 @@ function evalJS(js, data) {
     });
 });
 
-export { evalExpression, evalJS, filter, registerTplEnginer, setCustomEvalExpression, setCustomEvalJs };
+export { evalExpression, evalExpressionWithConditionBuilder, evalJS, filter, registerTplEnginer, setCustomEvalExpression, setCustomEvalJs };

package/esm/utils/uncontrollable.js

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

package/esm/utils/validations.js

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

package/lib/Root.d.ts

@@ -21,7 +21,7 @@ export interface RootProps {
 }
 export interface RootWrapperProps {
     env: RendererEnv;
-    children: React.ReactNode;
+    children: React.ReactNode | Array<React.ReactNode>;
     schema: SchemaNode;
     rootStore: IRendererStore;
     theme: string;

package/lib/Root.js

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

package/lib/RootRenderer.d.ts

@@ -23,5 +23,5 @@ export declare class RootRenderer extends React.Component<RootRendererProps> {
     handleDrawerClose(): void;
     openFeedback(dialog: any, ctx: any): Promise<unknown>;
     reloadTarget(scoped: IScopedContext, target: string, data?: any): void;
-    render(): React.ReactNode;
+    render(): string | number | boolean | JSX.Element | React.ReactFragment | null | undefined;
 }

package/lib/RootRenderer.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v2.8.0
+ * amis-core v2.9.0
  * Copyright 2018-2023 fex
  */
 
@@ -122,11 +122,11 @@ var RootRenderer = /** @class */ (function (_super) {
         }
         else if (action.actionType === 'dialog') {
             store.setCurrentAction(action);
-            store.openDialog(ctx);
+            store.openDialog(ctx, undefined, undefined, delegate);
         }
         else if (action.actionType === 'drawer') {
             store.setCurrentAction(action);
-            store.openDrawer(ctx);
+            store.openDrawer(ctx, undefined, undefined, delegate);
         }
         else if (action.actionType === 'toast') {
             (_b = (_a = action.toast) === null || _a === void 0 ? void 0 : _a.items) === null || _b === void 0 ? void 0 : _b.forEach(function (item) {
@@ -160,7 +160,7 @@ var RootRenderer = /** @class */ (function (_super) {
                             redirect = action.redirect && tpl.filter(action.redirect, store.data);
                             redirect && env.jumpTo(redirect, action);
                             action.reload &&
-                                this.reloadTarget(delegate || this.context, action.reload, store.data);
+                                this.reloadTarget(delegate || this.context, tpl.filter(action.reload, ctx), store.data);
                             return [2 /*return*/];
                     }
                 });
@@ -192,6 +192,7 @@ var RootRenderer = /** @class */ (function (_super) {
         }
     };
     RootRenderer.prototype.handleDialogConfirm = function (values, action) {
+        var _a;
         var args = [];
         for (var _i = 2; _i < arguments.length; _i++) {
             args[_i - 2] = arguments[_i];
@@ -206,7 +207,13 @@ var RootRenderer = /** @class */ (function (_super) {
             dialog.onConfirm.apply(dialog, tslib.__spreadArray([values, action], tslib.__read(args), false)) === false) {
             return;
         }
+        var dialogAction = store.action;
+        var reload = (_a = action.reload) !== null && _a !== void 0 ? _a : dialogAction.reload;
+        var scoped = store.getDialogScoped() || this.context;
         store.closeDialog(true);
+        if (reload) {
+            scoped.reload(reload, store.data);
+        }
     };
     RootRenderer.prototype.handleDialogClose = function (confirmed) {
         if (confirmed === void 0) { confirmed = false; }
@@ -214,6 +221,7 @@ var RootRenderer = /** @class */ (function (_super) {
         store.closeDialog(confirmed);
     };
     RootRenderer.prototype.handleDrawerConfirm = function (values, action) {
+        var _a;
         var args = [];
         for (var _i = 2; _i < arguments.length; _i++) {
             args[_i - 2] = arguments[_i];
@@ -228,7 +236,16 @@ var RootRenderer = /** @class */ (function (_super) {
             drawer.onConfirm.apply(drawer, tslib.__spreadArray([values, action], tslib.__read(args), false)) === false) {
             return;
         }
+        var drawerAction = store.action;
+        var reload = (_a = action.reload) !== null && _a !== void 0 ? _a : drawerAction.reload;
+        var scoped = store.getDrawerScoped() || this.context;
         store.closeDrawer();
+        // 稍等会，等动画结束。
+        setTimeout(function () {
+            if (reload) {
+                scoped.reload(reload, store.data);
+            }
+        }, 300);
     };
     RootRenderer.prototype.handleDrawerClose = function () {
         var store = this.store;

package/lib/SchemaRenderer.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import { RendererConfig, RendererEnv, RendererProps } from './factory';
+import { IScopedContext } from './Scoped';
 import { Schema, SchemaNode } from './types';
 import { RendererEvent } from './utils/renderer-event';
 interface SchemaRendererProps extends Partial<RendererProps> {
@@ -9,7 +10,7 @@ interface SchemaRendererProps extends Partial<RendererProps> {
 }
 export declare class SchemaRenderer extends React.Component<SchemaRendererProps, any> {
     static displayName: string;
-    static contextType: React.Context<import("./Scoped").IScopedContext>;
+    static contextType: React.Context<IScopedContext>;
     rendererKey: string;
     renderer: RendererConfig | null;
     ref: any;

package/lib/SchemaRenderer.js

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