amis-formula 2.9.0 → 3.1.0

package/esm/doc.js

@@ -1,5 +1,5 @@
 /**
- * amis-formula v2.9.0
+ * amis-formula v3.1.0
  * Copyright 2021-2023 fex
  */
 

package/esm/error.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 表达式解析错误
+ */
+export declare class FormulaEvalError extends Error {
+    constructor(message: string);
+}

package/esm/error.js

@@ -0,0 +1,21 @@
+/**
+ * amis-formula v3.1.0
+ * Copyright 2021-2023 fex
+ */
+
+import { __extends } from 'tslib';
+
+/**
+ * 表达式解析错误
+ */
+var FormulaEvalError = /** @class */ (function (_super) {
+    __extends(FormulaEvalError, _super);
+    function FormulaEvalError(message) {
+        var _this = _super.call(this, message) || this;
+        _this.name = 'FormulaEvalError';
+        return _this;
+    }
+    return FormulaEvalError;
+}(Error));
+
+export { FormulaEvalError };

package/esm/evalutor.js

@@ -1,5 +1,5 @@
 /**
- * amis-formula v2.9.0
+ * amis-formula v3.1.0
  * Copyright 2021-2023 fex
  */
 
@@ -15,6 +15,7 @@ import uniqBy from 'lodash/uniqBy';
 import isEqual from 'lodash/isEqual';
 import isPlainObject from 'lodash/isPlainObject';
 import get from 'lodash/get';
+import { FormulaEvalError } from './error.js';
 
 /**
  * @file 公式内置函数
@@ -366,7 +367,7 @@ var Evaluator = /** @class */ (function () {
             (this.filters.hasOwnProperty(ast.identifier) &&
                 this.filters[ast.identifier]);
         if (!fn) {
-            throw new Error("".concat(ast.identifier, "\u51FD\u6570\u6CA1\u6709\u5B9A\u4E49"));
+            throw new FormulaEvalError("".concat(ast.identifier, "\u51FD\u6570\u6CA1\u6709\u5B9A\u4E49"));
         }
         var args = ast.args;
         // 逻辑函数特殊处理，因为有时候有些运算是可以跳过的。

package/esm/evalutorForAsync.js

@@ -1,10 +1,11 @@
 /**
- * amis-formula v2.9.0
+ * amis-formula v3.1.0
  * Copyright 2021-2023 fex
  */
 
 import { __extends, __awaiter, __generator } from 'tslib';
 import { stripNumber, createObject, Evaluator } from './evalutor.js';
+import { FormulaEvalError } from './error.js';
 
 function runSequence(arr, fn) {
     return __awaiter(this, void 0, void 0, function () {
@@ -72,7 +73,7 @@ var AsyncEvaluator = /** @class */ (function (_super) {
     };
     AsyncEvaluator.prototype.filter = function (ast) {
         return __awaiter(this, void 0, void 0, function () {
-            var input, filters, context, result;
+            var input, filters, context, filter, fn, argsRes;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -85,47 +86,42 @@ var AsyncEvaluator = /** @class */ (function (_super) {
                             data: this.context,
                             restFilters: filters
                         };
-                        return [4 /*yield*/, filters.reduce(function (ps, filter, index) { return __awaiter(_this, void 0, void 0, function () {
-                                var input, fn, argsRes;
+                        _a.label = 2;
+                    case 2:
+                        if (!filters.length) return [3 /*break*/, 4];
+                        filter = filters.shift();
+                        fn = this.filters[filter.name];
+                        if (!fn) {
+                            throw new Error("filter `".concat(filter.name, "` not exists."));
+                        }
+                        context.filter = filter;
+                        return [4 /*yield*/, runSequence(filter.args, function (item) { return __awaiter(_this, void 0, void 0, function () {
+                                var res;
                                 var _this = this;
                                 return __generator(this, function (_a) {
                                     switch (_a.label) {
-                                        case 0: return [4 /*yield*/, ps];
+                                        case 0:
+                                            if (!((item === null || item === void 0 ? void 0 : item.type) === 'mixed')) return [3 /*break*/, 2];
+                                            return [4 /*yield*/, runSequence(item.body, function (item) {
+                                                    return typeof item === 'string' ? item : _this.evalute(item);
+                                                })];
                                         case 1:
-                                            input = _a.sent();
-                                            fn = this.filters[filter.name];
-                                            if (!fn) {
-                                                throw new Error("filter `".concat(filter.name, "` not exists."));
-                                            }
-                                            context.filter = filter;
-                                            return [4 /*yield*/, filter.args.reduce(function (promise, item) { return __awaiter(_this, void 0, void 0, function () {
-                                                    var _this = this;
-                                                    return __generator(this, function (_a) {
-                                                        switch (_a.label) {
-                                                            case 0: return [4 /*yield*/, promise];
-                                                            case 1:
-                                                                _a.sent();
-                                                                if ((item === null || item === void 0 ? void 0 : item.type) === 'mixed') {
-                                                                    return [2 /*return*/, runSequence(item.body, function (item) {
-                                                                            return typeof item === 'string' ? item : _this.evalute(item);
-                                                                        })];
-                                                                }
-                                                                else if (item.type) {
-                                                                    return [2 /*return*/, this.evalute(item)];
-                                                                }
-                                                                return [2 /*return*/, item];
-                                                        }
-                                                    });
-                                                }); }, Promise.resolve([]))];
+                                            res = _a.sent();
+                                            return [2 /*return*/, res.join('')];
                                         case 2:
-                                            argsRes = _a.sent();
-                                            return [2 /*return*/, fn.apply(context, [input].concat(argsRes))];
+                                            if (item.type) {
+                                                return [2 /*return*/, this.evalute(item)];
+                                            }
+                                            _a.label = 3;
+                                        case 3: return [2 /*return*/, item];
                                     }
                                 });
-                            }); }, Promise.resolve(input))];
-                    case 2:
-                        result = _a.sent();
-                        return [2 /*return*/, result];
+                            }); })];
+                    case 3:
+                        argsRes = _a.sent();
+                        input = fn.apply(context, [input].concat(argsRes));
+                        return [3 /*break*/, 2];
+                    case 4: return [2 /*return*/, input];
                 }
             });
         });
@@ -573,7 +569,7 @@ var AsyncEvaluator = /** @class */ (function (_super) {
                             (this.filters.hasOwnProperty(ast.identifier) &&
                                 this.filters[ast.identifier]);
                         if (!fn) {
-                            throw new Error("".concat(ast.identifier, "\u51FD\u6570\u6CA1\u6709\u5B9A\u4E49"));
+                            throw new FormulaEvalError("".concat(ast.identifier, "\u51FD\u6570\u6CA1\u6709\u5B9A\u4E49"));
                         }
                         args = ast.args;
                         if (!~['IF', 'AND', 'OR', 'XOR', 'IFS'].indexOf(ast.identifier)) return [3 /*break*/, 1];

package/esm/filter.js

@@ -1,5 +1,5 @@
 /**
- * amis-formula v2.9.0
+ * amis-formula v3.1.0
  * Copyright 2021-2023 fex
  */
 

package/esm/function.d.ts

@@ -1,3 +1,5 @@
-import { FunctionMap } from './types';
+import { FunctionMap, FunctionDocMap, FunctionDocItem } from './types';
 export declare const functions: FunctionMap;
 export declare function registerFunction(name: string, fn: (input: any, ...args: any[]) => any): void;
+export declare let functionDocs: FunctionDocMap;
+export declare function registerFunctionDoc(groupName: string, item: FunctionDocItem): void;

package/esm/function.js

@@ -1,5 +1,5 @@
 /**
- * amis-formula v2.9.0
+ * amis-formula v3.1.0
  * Copyright 2021-2023 fex
  */
 
@@ -10,5 +10,14 @@ function registerFunction(name, fn) {
     functions["fn".concat(name)] = fn;
     Evaluator.setDefaultFunctions(functions);
 }
+var functionDocs = {};
+function registerFunctionDoc(groupName, item) {
+    if (functionDocs[groupName]) {
+        functionDocs[groupName].push(item);
+    }
+    else {
+        functionDocs[groupName] = [item];
+    }
+}
 
-export { functions, registerFunction };
+export { functionDocs, functions, registerFunction, registerFunctionDoc };

package/esm/index.d.ts

@@ -3,8 +3,8 @@ import { AsyncEvaluator } from './evalutorForAsync';
 import { parse } from './parser';
 import { lexer } from './lexer';
 import { registerFilter, filters, getFilters, extendsFilters } from './filter';
-import { registerFunction } from './function';
+import { registerFunction, registerFunctionDoc, functionDocs } from './function';
 import type { FilterContext, ASTNode, ParserOptions, EvaluatorOptions } from './types';
-export { parse, lexer, Evaluator, AsyncEvaluator, FilterContext, filters, getFilters, registerFilter, registerFunction, extendsFilters };
+export { parse, lexer, Evaluator, AsyncEvaluator, FilterContext, filters, getFilters, registerFilter, registerFunction, registerFunctionDoc, functionDocs, extendsFilters };
 export declare function evaluate(astOrString: string | ASTNode, data: any, options?: ParserOptions & EvaluatorOptions): any;
 export declare function evaluateForAsync(astOrString: string | ASTNode, data: any, options?: ParserOptions & EvaluatorOptions): Promise<any>;

package/esm/index.js

@@ -1,5 +1,5 @@
 /**
- * amis-formula v2.9.0
+ * amis-formula v3.1.0
  * Copyright 2021-2023 fex
  */
 
@@ -13,7 +13,7 @@ export { parse } from './parser.js';
 export { lexer } from './lexer.js';
 import { getFilters } from './filter.js';
 export { extendsFilters, filters, getFilters, registerFilter } from './filter.js';
-export { registerFunction } from './function.js';
+export { functionDocs, registerFunction, registerFunctionDoc } from './function.js';
 
 function evaluate(astOrString, data, options) {
     var ast = astOrString;

package/esm/lexer.js

@@ -1,5 +1,5 @@
 /**
- * amis-formula v2.9.0
+ * amis-formula v3.1.0
  * Copyright 2021-2023 fex
  */
 

package/esm/parser.js

@@ -1,5 +1,5 @@
 /**
- * amis-formula v2.9.0
+ * amis-formula v3.1.0
  * Copyright 2021-2023 fex
  */
 

package/esm/types.d.ts

@@ -5,6 +5,15 @@ export interface FilterMap {
 export interface FunctionMap {
     [propName: string]: (this: Evaluator, ast: Object, data: any) => any;
 }
+export interface FunctionDocItem {
+    name: string;
+    example?: string;
+    description?: string;
+    [propName: string]: any;
+}
+export interface FunctionDocMap {
+    [propName: string]: FunctionDocItem[];
+}
 export interface FilterContext {
     data: Object;
     filter?: {

package/lib/doc.js

@@ -1,5 +1,5 @@
 /**
- * amis-formula v2.9.0
+ * amis-formula v3.1.0
  * Copyright 2021-2023 fex
  */
 

package/lib/error.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 表达式解析错误
+ */
+export declare class FormulaEvalError extends Error {
+    constructor(message: string);
+}

package/lib/error.js

@@ -0,0 +1,25 @@
+/**
+ * amis-formula v3.1.0
+ * Copyright 2021-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+
+/**
+ * 表达式解析错误
+ */
+var FormulaEvalError = /** @class */ (function (_super) {
+    tslib.__extends(FormulaEvalError, _super);
+    function FormulaEvalError(message) {
+        var _this = _super.call(this, message) || this;
+        _this.name = 'FormulaEvalError';
+        return _this;
+    }
+    return FormulaEvalError;
+}(Error));
+
+exports.FormulaEvalError = FormulaEvalError;

package/lib/evalutor.js

@@ -1,5 +1,5 @@
 /**
- * amis-formula v2.9.0
+ * amis-formula v3.1.0
  * Copyright 2021-2023 fex
  */
 
@@ -19,6 +19,7 @@ var uniqBy = require('lodash/uniqBy');
 var isEqual = require('lodash/isEqual');
 var isPlainObject = require('lodash/isPlainObject');
 var get = require('lodash/get');
+var error = require('./error.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -384,7 +385,7 @@ var Evaluator = /** @class */ (function () {
             (this.filters.hasOwnProperty(ast.identifier) &&
                 this.filters[ast.identifier]);
         if (!fn) {
-            throw new Error("".concat(ast.identifier, "\u51FD\u6570\u6CA1\u6709\u5B9A\u4E49"));
+            throw new error.FormulaEvalError("".concat(ast.identifier, "\u51FD\u6570\u6CA1\u6709\u5B9A\u4E49"));
         }
         var args = ast.args;
         // 逻辑函数特殊处理，因为有时候有些运算是可以跳过的。

package/lib/evalutorForAsync.js

@@ -1,5 +1,5 @@
 /**
- * amis-formula v2.9.0
+ * amis-formula v3.1.0
  * Copyright 2021-2023 fex
  */
 
@@ -9,6 +9,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib = require('tslib');
 var evalutor = require('./evalutor.js');
+var error = require('./error.js');
 
 function runSequence(arr, fn) {
     return tslib.__awaiter(this, void 0, void 0, function () {
@@ -76,7 +77,7 @@ var AsyncEvaluator = /** @class */ (function (_super) {
     };
     AsyncEvaluator.prototype.filter = function (ast) {
         return tslib.__awaiter(this, void 0, void 0, function () {
-            var input, filters, context, result;
+            var input, filters, context, filter, fn, argsRes;
             var _this = this;
             return tslib.__generator(this, function (_a) {
                 switch (_a.label) {
@@ -89,47 +90,42 @@ var AsyncEvaluator = /** @class */ (function (_super) {
                             data: this.context,
                             restFilters: filters
                         };
-                        return [4 /*yield*/, filters.reduce(function (ps, filter, index) { return tslib.__awaiter(_this, void 0, void 0, function () {
-                                var input, fn, argsRes;
+                        _a.label = 2;
+                    case 2:
+                        if (!filters.length) return [3 /*break*/, 4];
+                        filter = filters.shift();
+                        fn = this.filters[filter.name];
+                        if (!fn) {
+                            throw new Error("filter `".concat(filter.name, "` not exists."));
+                        }
+                        context.filter = filter;
+                        return [4 /*yield*/, runSequence(filter.args, function (item) { return tslib.__awaiter(_this, void 0, void 0, function () {
+                                var res;
                                 var _this = this;
                                 return tslib.__generator(this, function (_a) {
                                     switch (_a.label) {
-                                        case 0: return [4 /*yield*/, ps];
+                                        case 0:
+                                            if (!((item === null || item === void 0 ? void 0 : item.type) === 'mixed')) return [3 /*break*/, 2];
+                                            return [4 /*yield*/, runSequence(item.body, function (item) {
+                                                    return typeof item === 'string' ? item : _this.evalute(item);
+                                                })];
                                         case 1:
-                                            input = _a.sent();
-                                            fn = this.filters[filter.name];
-                                            if (!fn) {
-                                                throw new Error("filter `".concat(filter.name, "` not exists."));
-                                            }
-                                            context.filter = filter;
-                                            return [4 /*yield*/, filter.args.reduce(function (promise, item) { return tslib.__awaiter(_this, void 0, void 0, function () {
-                                                    var _this = this;
-                                                    return tslib.__generator(this, function (_a) {
-                                                        switch (_a.label) {
-                                                            case 0: return [4 /*yield*/, promise];
-                                                            case 1:
-                                                                _a.sent();
-                                                                if ((item === null || item === void 0 ? void 0 : item.type) === 'mixed') {
-                                                                    return [2 /*return*/, runSequence(item.body, function (item) {
-                                                                            return typeof item === 'string' ? item : _this.evalute(item);
-                                                                        })];
-                                                                }
-                                                                else if (item.type) {
-                                                                    return [2 /*return*/, this.evalute(item)];
-                                                                }
-                                                                return [2 /*return*/, item];
-                                                        }
-                                                    });
-                                                }); }, Promise.resolve([]))];
+                                            res = _a.sent();
+                                            return [2 /*return*/, res.join('')];
                                         case 2:
-                                            argsRes = _a.sent();
-                                            return [2 /*return*/, fn.apply(context, [input].concat(argsRes))];
+                                            if (item.type) {
+                                                return [2 /*return*/, this.evalute(item)];
+                                            }
+                                            _a.label = 3;
+                                        case 3: return [2 /*return*/, item];
                                     }
                                 });
-                            }); }, Promise.resolve(input))];
-                    case 2:
-                        result = _a.sent();
-                        return [2 /*return*/, result];
+                            }); })];
+                    case 3:
+                        argsRes = _a.sent();
+                        input = fn.apply(context, [input].concat(argsRes));
+                        return [3 /*break*/, 2];
+                    case 4: return [2 /*return*/, input];
                 }
             });
         });
@@ -577,7 +573,7 @@ var AsyncEvaluator = /** @class */ (function (_super) {
                             (this.filters.hasOwnProperty(ast.identifier) &&
                                 this.filters[ast.identifier]);
                         if (!fn) {
-                            throw new Error("".concat(ast.identifier, "\u51FD\u6570\u6CA1\u6709\u5B9A\u4E49"));
+                            throw new error.FormulaEvalError("".concat(ast.identifier, "\u51FD\u6570\u6CA1\u6709\u5B9A\u4E49"));
                         }
                         args = ast.args;
                         if (!~['IF', 'AND', 'OR', 'XOR', 'IFS'].indexOf(ast.identifier)) return [3 /*break*/, 1];

package/lib/filter.js

@@ -1,5 +1,5 @@
 /**
- * amis-formula v2.9.0
+ * amis-formula v3.1.0
  * Copyright 2021-2023 fex
  */
 

package/lib/function.d.ts

@@ -1,3 +1,5 @@
-import { FunctionMap } from './types';
+import { FunctionMap, FunctionDocMap, FunctionDocItem } from './types';
 export declare const functions: FunctionMap;
 export declare function registerFunction(name: string, fn: (input: any, ...args: any[]) => any): void;
+export declare let functionDocs: FunctionDocMap;
+export declare function registerFunctionDoc(groupName: string, item: FunctionDocItem): void;

package/lib/function.js

@@ -1,5 +1,5 @@
 /**
- * amis-formula v2.9.0
+ * amis-formula v3.1.0
  * Copyright 2021-2023 fex
  */
 
@@ -14,6 +14,17 @@ function registerFunction(name, fn) {
     functions["fn".concat(name)] = fn;
     evalutor.Evaluator.setDefaultFunctions(functions);
 }
+var functionDocs = {};
+function registerFunctionDoc(groupName, item) {
+    if (functionDocs[groupName]) {
+        functionDocs[groupName].push(item);
+    }
+    else {
+        functionDocs[groupName] = [item];
+    }
+}
 
+exports.functionDocs = functionDocs;
 exports.functions = functions;
 exports.registerFunction = registerFunction;
+exports.registerFunctionDoc = registerFunctionDoc;

package/lib/index.d.ts

@@ -3,8 +3,8 @@ import { AsyncEvaluator } from './evalutorForAsync';
 import { parse } from './parser';
 import { lexer } from './lexer';
 import { registerFilter, filters, getFilters, extendsFilters } from './filter';
-import { registerFunction } from './function';
+import { registerFunction, registerFunctionDoc, functionDocs } from './function';
 import type { FilterContext, ASTNode, ParserOptions, EvaluatorOptions } from './types';
-export { parse, lexer, Evaluator, AsyncEvaluator, FilterContext, filters, getFilters, registerFilter, registerFunction, extendsFilters };
+export { parse, lexer, Evaluator, AsyncEvaluator, FilterContext, filters, getFilters, registerFilter, registerFunction, registerFunctionDoc, functionDocs, extendsFilters };
 export declare function evaluate(astOrString: string | ASTNode, data: any, options?: ParserOptions & EvaluatorOptions): any;
 export declare function evaluateForAsync(astOrString: string | ASTNode, data: any, options?: ParserOptions & EvaluatorOptions): Promise<any>;

package/lib/index.js

@@ -1,5 +1,5 @@
 /**
- * amis-formula v2.9.0
+ * amis-formula v3.1.0
  * Copyright 2021-2023 fex
  */
 
@@ -45,6 +45,8 @@ exports.extendsFilters = filter.extendsFilters;
 exports.filters = filter.filters;
 exports.getFilters = filter.getFilters;
 exports.registerFilter = filter.registerFilter;
+exports.functionDocs = _function.functionDocs;
 exports.registerFunction = _function.registerFunction;
+exports.registerFunctionDoc = _function.registerFunctionDoc;
 exports.evaluate = evaluate;
 exports.evaluateForAsync = evaluateForAsync;

package/lib/lexer.js

@@ -1,5 +1,5 @@
 /**
- * amis-formula v2.9.0
+ * amis-formula v3.1.0
  * Copyright 2021-2023 fex
  */
 

package/lib/parser.js

@@ -1,5 +1,5 @@
 /**
- * amis-formula v2.9.0
+ * amis-formula v3.1.0
  * Copyright 2021-2023 fex
  */
 

package/lib/types.d.ts

@@ -5,6 +5,15 @@ export interface FilterMap {
 export interface FunctionMap {
     [propName: string]: (this: Evaluator, ast: Object, data: any) => any;
 }
+export interface FunctionDocItem {
+    name: string;
+    example?: string;
+    description?: string;
+    [propName: string]: any;
+}
+export interface FunctionDocMap {
+    [propName: string]: FunctionDocItem[];
+}
 export interface FilterContext {
     data: Object;
     filter?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amis-formula",
-  "version": "2.9.0",
+  "version": "3.1.0",
   "description": "负责 amis 里面的表达式实现，内置公式，编辑器等",
   "main": "lib/index.js",
   "module": "esm/index.js",
@@ -113,5 +113,5 @@
       "printBasicPrototype": false
     }
   },
-  "gitHead": "cc289e56da53504995df57c84b517f5801d9fd0f"
+  "gitHead": "020b12d0be43215664e0c0e53cd33486c43fde86"
 }