amis-core 2.6.0 → 2.7.0

package/esm/utils/formula.js

@@ -1,219 +0,0 @@
-/**
- * amis-core v2.6.0
- * Copyright 2018-2022 fex
- */
-
-import isObjectByLodash from 'lodash/isObject';
-import isString from 'lodash/isString';
-import isBoolean from 'lodash/isBoolean';
-import { evaluate, getFilters } from 'amis-formula';
-import { filter } from './tpl.js';
-import 'moment';
-import 'tslib';
-import 'lodash/isPlainObject';
-import { getVariable } from './getVariable.js';
-import { resolveVariableAndFilter } from './resolveVariableAndFilter.js';
-import './filter.js';
-import { collectVariables } from './grammar.js';
-
-/**
- * formulaExec 运算器：根据当前字符串类型执行对应运算，也可按指定执行模式执行运算
- *
- * 运算模式（execMode）支持以下取值:
- * 1. tpl: 按模板字符串执行（JavaScript 模板引擎），比如：Hello ${amisUser.email}、<h1>Hello</h1>, <span>${amisUser.email}</span>；
- *    备注: 在模板中可以自由访问变量，详细请见：https://www.lodashjs.com/docs/lodash.template；
- * 2. formula: 按新版公式表达式执行，用于执行 ${ xxx } 格式的表达式；
- *    支持从window、localStorage、sessionStorage获取数据，比如：${num1 + 2}、${ls:env}、${window:document}、${window:document.URL}、${amisUser.email}；
- *    详细请见：https://aisuda.bce.baidu.com/amis/zh-CN/docs/concepts/data-mapping#namespace
- * 3. evalFormula: 按新版公式表达式执行，用于执行 ${ xxx } 和 非${ xxx } 格式的表达式（evalMode 为 true，不用 ${} 包裹也可以执行），功能同 formula 运算模式；
- * 4. js: 按Javascript执行，表达式中可以通过data.xxx来获取指定数据，并且支持简单运算；
- *    比如：data.num1 + 2、this.num1 + 2、num1 + 2；（备注：三个表达式是等价的，这里的 this 就是 data。）
- * 5. var: 以此字符串作为key值从当前数据域data中获取数值；性能最高（运行期间不会生成ast和表达式运算）；
- * 6. true 或者 false: 当execMode设置为true时，不用 ${} 包裹也可以执行表达式；
- * 7. collect: 用于从表达式中获取所有变量；
- *
- * 备注1: 用户也可以使用 registerFormulaExec 注册一个自定义运算器；
- * 备注2: 模板字符串 和 Javascript 模板引擎 不可以交叉使用；
- * 备注3: amis 现有的 evalFormula 方法，可执行 ${} 格式类表达式，但不支持 filter 过滤器，所以这里用 resolveValueByName 实现；
- * 备注4: 后续可考虑将 amis现有的运算器都放这里管理，充当统一的运算器入口。
- */
-// 缓存，用于提升性能
-var FORMULA_EVAL_CACHE = {};
-/**
- * 用于存储当前可用运算器，默认支持 tpl、formula、js、var 四种类型运算器
- * 备注：在这里统一参数。
- */
-var FormulaExec = {
-    tpl: function (expression, data) {
-        var curData = data || {};
-        return filter(expression, curData);
-    },
-    formula: function (expression, data) {
-        // 邮箱格式直接返回，后续需要在 amis-formula 中处理
-        if (/^\$\{([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+((.[a-zA-Z0-9_-]{2,3}){1,2})\}$/.test(expression)) {
-            return expression.substring(2, expression.length - 1); // 剔除前后特殊字符
-        }
-        var curData = data || {};
-        var result = undefined;
-        try {
-            // 执行 ${} 格式类表达式，且支持 filter 过滤器。（备注: isPureVariable 可用于判断是否有 过滤器。）
-            result = resolveVariableAndFilter(expression, curData, '| raw');
-        }
-        catch (e) {
-            console.warn('[formula]表达式执行异常，当前表达式: ', expression, '，当前上下文数据: ', data);
-            return expression;
-        }
-        // 备注: 此处不用 result ?? expression 是为了避免 没有对应结果时直接显示 expression: ${xxx}
-        return result;
-    },
-    evalFormula: function (expression, data) {
-        var curData = data || {};
-        var result = undefined;
-        try {
-            result = evaluate(expression, curData, {
-                evalMode: true,
-                allowFilter: false
-            });
-        }
-        catch (e) {
-            console.warn('[evalFormula]表达式执行异常，当前表达式: ', expression, '，当前上下文数据: ', data);
-            return expression;
-        }
-        return result !== null && result !== void 0 ? result : expression;
-    },
-    js: function (expression, data) {
-        var debug = false;
-        var idx = expression.indexOf('debugger');
-        if (~idx) {
-            debug = true;
-            expression = expression.replace(/debugger;?/, '');
-        }
-        var fn;
-        if (expression in FORMULA_EVAL_CACHE) {
-            fn = FORMULA_EVAL_CACHE[expression];
-        }
-        else {
-            fn = new Function('data', 'utils', "with(data) {".concat(debug ? 'debugger;' : '', "return (").concat(expression, ");}"));
-            FORMULA_EVAL_CACHE[expression] = fn;
-        }
-        data = data || {};
-        var curResult = undefined;
-        try {
-            curResult = fn.call(data, data, getFilters());
-        }
-        catch (e) {
-            console.warn('[formula:js]表达式执行异常，当前表达式: ', expression, '，当前上下文数据: ', data);
-            return expression;
-        }
-        return curResult;
-    },
-    var: function (expression, data) {
-        var curData = data || {};
-        var result = getVariable(curData, expression); // 不支持过滤器
-        return result !== null && result !== void 0 ? result : expression;
-    },
-    collect: function (expression) {
-        var variables = [];
-        if (isObjectByLodash(expression) || isString(expression)) {
-            // 仅对 Object类型 和 String类型 进行变量提取
-            variables = collectVariables(expression);
-        }
-        else {
-            variables = [];
-        }
-        return variables;
-    }
-};
-// 根据表达式类型自动匹配指定运算器，也可以通过设置 execMode 直接指定运算器
-function formulaExec(value, data, execMode) {
-    if (!value) {
-        return '';
-    }
-    var OpenFormulaExecEvalMode = false;
-    var curExecMode = '';
-    if (isBoolean(execMode)) {
-        // OpenFormulaExecEvalMode 设置为 true 后，非 ${ xxx } 格式也使用表达式运算器
-        OpenFormulaExecEvalMode = execMode;
-    }
-    else if (isString(execMode)) {
-        // 指定 execMode 可以直接选用对应的运算器
-        curExecMode = execMode;
-    }
-    if (!isString(value)) {
-        // 非字符串类型，直接返回，比如：boolean、number类型、Object、Array类型
-        return value;
-    }
-    else if (curExecMode && FormulaExec[curExecMode]) {
-        return FormulaExec[curExecMode](value, data);
-    }
-    var curValue = value.trim(); // 剔除前后空格
-    // OpenFormulaExecEvalMode 为 true 时，非 ${ xxx } 格式也会尝试使用表达式运算器
-    if (OpenFormulaExecEvalMode && /^[0-9a-zA-Z_]+$/.test(curValue)) {
-        // 普通字符串类型（非表达式），先试一下从上下文中获取数据
-        var curValueTemp = FormulaExec['var'](curValue, data);
-        // 备注: 其他特殊格式，比如邮箱、日期
-        return curValueTemp !== null && curValueTemp !== void 0 ? curValueTemp : curValue;
-    }
-    else if (curValue.startsWith('${') && curValue.endsWith('}')) {
-        // ${ xxx } 格式 使用 formula 运算器
-        return FormulaExec['formula'](curValue, data);
-    }
-    else if (isExpression(curValue)) {
-        // 表达式格式使用 formula 运算器
-        return FormulaExec['formula'](curValue, data);
-    }
-    else if (/(\${).+(\})/.test(curValue)) {
-        // 包含 ${ xxx } 则使用 tpl 运算器
-        return FormulaExec['tpl'](curValue, data); // 可识别 <% %> 语法
-    }
-    else if (OpenFormulaExecEvalMode) {
-        // 支持 ${} 和 非 ${} 表达式
-        return FormulaExec['evalFormula'](curValue, data);
-    }
-    else {
-        return curValue;
-    }
-}
-// 用于注册自定义 formulaExec 运算器
-function registerFormulaExec(execMode, formulaExec) {
-    if (FormulaExec[execMode]) {
-        console.error("registerFormulaExec: \u8FD0\u7B97\u5668\u6CE8\u518C\u5931\u8D25\uFF0C\u5B58\u5728\u540C\u540D\u8FD0\u7B97\u5668\uFF08$(execMode)\uFF09\u3002");
-    }
-    else {
-        FormulaExec[execMode] = formulaExec;
-    }
-}
-// 用于判断是否优先使用value。
-function isExpression(expression) {
-    if (!expression || !isString(expression)) {
-        // 非字符串类型，比如：Object、Array类型、boolean、number类型
-        return false;
-    }
-    // 备注1: "\\${xxx}"不作为表达式，至少含一个${xxx}才算是表达式
-    // 备注2: safari 不支持 /(?<!\\)(\${).+(\})/.test(expression)
-    return /(^|[^\\])\$\{.+\}/.test(expression);
-}
-// 用于判断是否需要执行表达式:
-function isNeedFormula(expression, prevData, curData) {
-    try {
-        var variables = FormulaExec.collect(expression);
-        return variables.some(function (variable) {
-            return FormulaExec.var(variable, prevData) !== FormulaExec.var(variable, curData);
-        });
-    }
-    catch (e) {
-        console.warn('[isNeedFormula]表达式执行异常，当前表达式: ', expression, '，当前上下文数据: ', curData);
-        return false;
-    }
-}
-// 将 \${xx} 替换成 ${xx}
-function replaceExpression(expression) {
-    if (expression &&
-        isString(expression) &&
-        /(\\)(\${).+(\})/.test(expression)) {
-        return expression.replace(/\\\$\{/g, '${');
-    }
-    return expression;
-}
-
-export { FormulaExec, formulaExec, isExpression, isNeedFormula, registerFormulaExec, replaceExpression };

package/esm/utils/getVariable.d.ts

@@ -1,3 +0,0 @@
-export declare function getVariable(data: {
-    [propName: string]: any;
-}, key: string | undefined, canAccessSuper?: boolean): any;

package/esm/utils/getVariable.js

@@ -1,25 +0,0 @@
-/**
- * amis-core v2.6.0
- * Copyright 2018-2022 fex
- */
-
-import { keyToPath } from './keyToPath.js';
-
-function getVariable(data, key, canAccessSuper) {
-    if (canAccessSuper === void 0) { canAccessSuper = true; }
-    if (!data || !key) {
-        return undefined;
-    }
-    else if (canAccessSuper ? key in data : data.hasOwnProperty(key)) {
-        return data[key];
-    }
-    return keyToPath(key).reduce(function (obj, key) {
-        return obj &&
-            typeof obj === 'object' &&
-            (canAccessSuper ? key in obj : obj.hasOwnProperty(key))
-            ? obj[key]
-            : undefined;
-    }, data);
-}
-
-export { getVariable };

package/esm/utils/grammar.d.ts

@@ -1,4 +0,0 @@
-/**
- * @file 公式语法解析
- */
-export declare function collectVariables(strOrAst: string | Object, execMode?: boolean): Array<string>;

package/esm/utils/grammar.js

@@ -1,50 +0,0 @@
-/**
- * amis-core v2.6.0
- * Copyright 2018-2022 fex
- */
-
-import { parse } from 'amis-formula';
-
-/**
- * @file 公式语法解析
- */
-function traverseAst(ast, iterator) {
-    if (!ast || !ast.type) {
-        return;
-    }
-    iterator(ast);
-    Object.keys(ast).forEach(function (key) {
-        var value = ast[key];
-        if (Array.isArray(value)) {
-            value.forEach(function (child) { return traverseAst(child, iterator); });
-        }
-        else {
-            traverseAst(value, iterator);
-        }
-    });
-}
-// 缓存，用于提升性能
-var COLLECT_EXPRESSION_CACHE = {};
-// 提取表达式中有哪些变量
-function collectVariables(strOrAst, execMode) {
-    var variables = [];
-    if (typeof strOrAst === 'string' && COLLECT_EXPRESSION_CACHE[strOrAst]) {
-        return COLLECT_EXPRESSION_CACHE[strOrAst];
-    }
-    var ast = typeof strOrAst === 'string'
-        ? parse(strOrAst, {
-            evalMode: execMode !== null && execMode !== void 0 ? execMode : false
-        })
-        : strOrAst;
-    traverseAst(ast, function (item) {
-        if (item.type === 'variable') {
-            variables.push(item.name);
-        }
-    });
-    if (typeof strOrAst === 'string') {
-        COLLECT_EXPRESSION_CACHE[strOrAst] = variables;
-    }
-    return variables;
-}
-
-export { collectVariables };

package/esm/utils/handleAction.d.ts

@@ -1,7 +0,0 @@
-/**
- * 后续好多地方可能都要支持 action，所以提取公共功能
- */
-/// <reference types="react" />
-import { RendererProps } from '../factory';
-export declare function handleAction(e: React.MouseEvent<any>, action: any, props: RendererProps, data?: any): void;
-export default handleAction;

package/esm/utils/handleAction.js

@@ -1,34 +0,0 @@
-/**
- * amis-core v2.6.0
- * Copyright 2018-2022 fex
- */
-
-import { str2function, normalizeApi } from './api.js';
-
-/**
- * 后续好多地方可能都要支持 action，所以提取公共功能
- */
-function handleAction(e, action, props, data) {
-    // https://reactjs.org/docs/legacy-event-pooling.html
-    e.persist(); // 等 react 17之后去掉 event pooling 了，这个应该就没用了
-    var onAction = props.onAction;
-    var onClick = action.onClick;
-    if (typeof onClick === 'string') {
-        onClick = str2function(onClick, 'event', 'props', 'data');
-    }
-    var result = onClick && onClick(e, props, data || props.data);
-    if (e.isDefaultPrevented() || result === false || !onAction) {
-        return;
-    }
-    e.preventDefault();
-    // download 是一种 ajax 的简写
-    if (action.actionType === 'download') {
-        action.actionType = 'ajax';
-        var api = normalizeApi(action.api);
-        api.responseType = 'blob';
-        action.api = api;
-    }
-    onAction(e, action, data || props.data);
-}
-
-export { handleAction as default, handleAction };

package/esm/utils/helper.d.ts

@@ -1,323 +0,0 @@
-/// <reference types="react" />
-import { Schema, PlainObject, FunctionPropertyNames } from '../types';
-import qs from 'qs';
-import { IIRendererStore } from '../store';
-import { autobindMethod } from './autobind';
-import { cloneObject, createObject, deleteVariable, extendObject, isObject, setVariable } from './object';
-import { string2regExp } from './string2regExp';
-import { getVariable } from './getVariable';
-import { keyToPath } from './keyToPath';
-export { createObject, cloneObject, isObject, string2regExp, getVariable, setVariable, deleteVariable, keyToPath, extendObject };
-export declare function preventDefault(event: TouchEvent | Event): void;
-export declare function isMobile(): any;
-export declare function range(num: number, min: number, max: number): number;
-/**
- * 给目标对象添加其他属性，可读取但是不会被遍历。
- * @param target
- * @param props
- */
-export declare function injectPropsToObject(target: any, props: any): any;
-export declare function isSuperDataModified(data: any, prevData: any, store: IIRendererStore): boolean;
-export declare function syncDataFromSuper(data: any, superObject: any, prevSuperObject: any, store: IIRendererStore, force: boolean): any;
-/**
- * 生成 8 位随机数字。
- *
- * @return {string} 8位随机数字
- */
-export declare function guid(): string;
-export declare function findIndex(arr: Array<any>, detect: (item?: any, index?: number) => boolean): number;
-export declare function hasOwnPropertyInPath(data: {
-    [propName: string]: any;
-}, key: string): boolean;
-export declare function noop(): void;
-export declare function anyChanged(attrs: string | Array<string>, from: {
-    [propName: string]: any;
-}, to: {
-    [propName: string]: any;
-}, strictMode?: boolean): boolean;
-export declare function rmUndefined(obj: PlainObject): PlainObject;
-export declare function isObjectShallowModified(prev: any, next: any, strictMode?: boolean, ignoreUndefined?: boolean, statck?: Array<any>): boolean;
-export declare function isArrayChildrenModified(prev: Array<any>, next: Array<any>, strictMode?: boolean): boolean;
-export declare function immutableExtends(to: any, from: any, deep?: boolean): any;
-export declare function makeColumnClassBuild(steps: number, classNameTpl?: string): (schema: Schema) => any;
-export declare function hasVisibleExpression(schema: {
-    visibleOn?: string;
-    hiddenOn?: string;
-    visible?: boolean;
-    hidden?: boolean;
-}): string | undefined;
-export declare function isVisible(schema: {
-    visibleOn?: string;
-    hiddenOn?: string;
-    visible?: boolean;
-    hidden?: boolean;
-}, data?: object): boolean;
-export declare function isUnfolded(node: any, config: {
-    foldedField?: string;
-    unfoldedField?: string;
-}): boolean;
-/**
- * 过滤掉被隐藏的数组元素
- */
-export declare function visibilityFilter(items: any, data?: object): any;
-export declare function isDisabled(schema: {
-    disabledOn?: string;
-    disabled?: boolean;
-}, data?: object): boolean | "" | undefined;
-export declare function hasAbility(schema: any, ability: string, data?: object, defaultValue?: boolean): boolean;
-export declare function makeHorizontalDeeper(horizontal: {
-    left: string;
-    right: string;
-    offset: string;
-    leftFixed?: any;
-}, count: number): {
-    left: string | number;
-    right: string | number;
-    offset: string | number;
-    leftFixed?: any;
-};
-export declare function promisify<T extends Function>(fn: T): (...args: Array<any>) => Promise<any> & {
-    raw: T;
-};
-/**
- *
- * @param node 当前元素
- * @param compute 自定义计算，找到的父元素是否满足特殊场景
- * @returns 返回控制当前元素滚动的父元素
- */
-export declare function getScrollParent(node: HTMLElement, compute?: (parent: HTMLElement) => boolean): HTMLElement | null;
-/**
- * Deep diff between two object, using lodash
- * @param  {Object} object Object compared
- * @param  {Object} base   Object to compare with
- * @return {Object}        Return a new object who represent the diff
- */
-export declare function difference<T extends {
-    [propName: string]: any;
-}, U extends {
-    [propName: string]: any;
-}>(object: T, base: U, keepProps?: Array<string>): {
-    [propName: string]: any;
-};
-export declare const padArr: (arr: Array<any>, size?: number, fillUndefined?: boolean) => Array<Array<any>>;
-export declare function __uri(id: string): string;
-export declare function isBreakpoint(str: string): boolean;
-export declare function until(fn: () => Promise<any>, when: (ret: any) => boolean, getCanceler: (fn: () => any) => void, interval?: number): Promise<unknown>;
-export declare function omitControls(controls: Array<any>, omitItems: Array<string>): Array<any>;
-export declare function isEmpty(thing: any): boolean;
-/**
- * 基于时间戳的 uuid
- *
- * @returns uniqueId
- */
-export declare const uuid: () => string;
-export declare const uuidv4: () => string;
-export interface TreeItem {
-    children?: TreeArray;
-    [propName: string]: any;
-}
-export interface TreeArray extends Array<TreeItem> {
-}
-/**
- * 类似于 arr.map 方法，此方法主要针对类似下面示例的树形结构。
- * [
- *     {
- *         children: []
- *     },
- *     // 其他成员
- * ]
- *
- * @param {Tree} tree 树形数据
- * @param {Function} iterator 处理函数，返回的数据会被替换成新的。
- * @return {Tree} 返回处理过的 tree
- */
-export declare function mapTree<T extends TreeItem>(tree: Array<T>, iterator: (item: T, key: number, level: number, paths: Array<T>) => T, level?: number, depthFirst?: boolean, paths?: Array<T>): any[];
-/**
- * 遍历树
- * @param tree
- * @param iterator
- */
-export declare function eachTree<T extends TreeItem>(tree: Array<T>, iterator: (item: T, key: number, level: number, paths?: Array<T>) => any, level?: number, paths?: Array<T>): void;
-/**
- * 在树中查找节点。
- * @param tree
- * @param iterator
- */
-export declare function findTree<T extends TreeItem>(tree: Array<T>, iterator: (item: T, key: number, level: number, paths: Array<T>) => any): T | null;
-/**
- * 在树中查找节点, 返回下标数组。
- * @param tree
- * @param iterator
- */
-export declare function findTreeIndex<T extends TreeItem>(tree: Array<T>, iterator: (item: T, key: number, level: number, paths: Array<T>) => any): Array<number> | undefined;
-export declare function getTree<T extends TreeItem>(tree: Array<T>, idx: Array<number> | number): T | undefined | null;
-/**
- * 过滤树节点
- *
- * @param tree
- * @param iterator
- */
-export declare function filterTree<T extends TreeItem>(tree: Array<T>, iterator: (item: T, key: number, level: number) => any, level?: number, depthFirst?: boolean): T[];
-/**
- * 判断树中每个节点是否满足某个条件。
- * @param tree
- * @param iterator
- */
-export declare function everyTree<T extends TreeItem>(tree: Array<T>, iterator: (item: T, key: number, level: number, paths: Array<T>, indexes: Array<number>) => boolean, level?: number, paths?: Array<T>, indexes?: Array<number>): boolean;
-/**
- * 判断树中是否有某些节点满足某个条件。
- * @param tree
- * @param iterator
- */
-export declare function someTree<T extends TreeItem>(tree: Array<T>, iterator: (item: T, key: number, level: number, paths: Array<T>) => boolean): boolean;
-/**
- * 将树打平变成一维数组，可以传入第二个参数实现打平节点中的其他属性。
- *
- * 比如：
- *
- * flattenTree([
- *     {
- *         id: 1,
- *         children: [
- *              { id: 2 },
- *              { id: 3 },
- *         ]
- *     }
- * ], item => item.id); // 输出为 [1, 2, 3]
- *
- * @param tree
- * @param mapper
- */
-export declare function flattenTree<T extends TreeItem>(tree: Array<T>): Array<T>;
-export declare function flattenTree<T extends TreeItem, U>(tree: Array<T>, mapper: (value: T, index: number, level: number, paths?: Array<T>) => U): Array<U>;
-/**
- * 将树打平变成一维数组，用法和flattenTree类似，区别是结果仅保留叶节点
- *
- * 比如：
- *
- * flattenTreeWithLeafNodes([
- *     {
- *         id: 1,
- *         children: [
- *              { id: 2 },
- *              { id: 3 },
- *         ]
- *     }
- * ], item => item.id); // 输出为 [2, 3]
- *
- * @param tree
- * @param mapper
- */
-export declare function flattenTreeWithLeafNodes<T extends TreeItem>(tree: Array<T>): Array<T>;
-export declare function flattenTreeWithLeafNodes<T extends TreeItem, U>(tree: Array<T>, mapper: (value: T, index: number) => U): Array<U>;
-/**
- * 操作树，遵循 imutable, 每次返回一个新的树。
- * 类似数组的 splice 不同的地方这个方法不修改原始数据，
- * 同时第二个参数不是下标，而是下标数组，分别代表每一层的下标。
- *
- * 至于如何获取下标数组，请查看 findTreeIndex
- *
- * @param tree
- * @param idx
- * @param deleteCount
- * @param ...items
- */
-export declare function spliceTree<T extends TreeItem>(tree: Array<T>, idx: Array<number> | number, deleteCount?: number, ...items: Array<T>): Array<T>;
-/**
- * 计算树的深度
- * @param tree
- */
-export declare function getTreeDepth<T extends TreeItem>(tree: Array<T>): number;
-/**
- * 从树中获取某个值的所有祖先
- * @param tree
- * @param value
- */
-export declare function getTreeAncestors<T extends TreeItem>(tree: Array<T>, value: T, includeSelf?: boolean): Array<T> | null;
-/**
- * 从树中获取某个值的上级
- * @param tree
- * @param value
- */
-export declare function getTreeParent<T extends TreeItem>(tree: Array<T>, value: T): T | null;
-export declare function ucFirst(str?: string): string | undefined;
-export declare function lcFirst(str?: string): string;
-export declare function camel(str?: string): string;
-export declare function getWidthRate(value: any, strictMode?: boolean): number;
-export declare function getLevelFromClassName(value: string, defaultValue?: string): string;
-export declare function pickEventsProps(props: any): any;
-export declare const autobind: typeof autobindMethod;
-export declare const bulkBindFunctions: <T extends {
-    [propName: string]: any;
-}>(context: T, funNames: FunctionPropertyNames<T>[]) => void;
-export declare function sortArray<T extends any>(items: Array<T>, field: string, dir: -1 | 1): Array<T>;
-export declare function hasFile(object: any): boolean;
-export declare function qsstringify(data: any, options?: any, keepEmptyArray?: boolean): string;
-export declare function qsparse(data: string, options?: any): qs.ParsedQs;
-export declare function object2formData(data: any, options?: any, fd?: FormData): any;
-export declare function chainFunctions(...fns: Array<(...args: Array<any>) => void>): (...args: Array<any>) => void;
-export declare function chainEvents(props: any, schema: any): any;
-export declare function mapObject(value: any, fn: Function, skipFn?: (value: any) => boolean): any;
-export declare function loadScript(src: string): Promise<void>;
-export declare class SkipOperation extends Error {
-}
-/**
- * 深度查找具有某个 key 名字段的对象，实际实现是 internalFindObjectsWithKey，这里包一层是为了做循环引用检测
- * @param obj
- * @param key
- */
-export declare function findObjectsWithKey(obj: any, key: string): any[];
-/**
- * 获取浏览器滚动条宽度 https://stackoverflow.com/a/13382873
- */
-export declare function getScrollbarWidth(): number;
-export declare function getPropValue<T extends {
-    value?: any;
-    name?: string;
-    data?: any;
-    defaultValue?: any;
-}>(props: T, getter?: (props: T) => any, canAccessSuper?: boolean): any;
-export declare function detectPropValueChanged<T extends {
-    value?: any;
-    name?: string;
-    data?: any;
-    defaultValue?: any;
-}>(props: T, prevProps: T, onChange: (value: any) => void, getter?: (props: T) => any): void;
-export declare function removeHTMLTag(str: string): string;
-/**
- * 将路径格式的value转换成普通格式的value值
- *
- * @example
- *
- * 'a/b/c' => 'c';
- * {label: 'A/B/C', value: 'a/b/c'} => {label: 'C', value: 'c'};
- * 'a/b/c,a/d' => 'c,d';
- * ['a/b/c', 'a/d'] => ['c', 'd'];
- * [{label: 'A/B/C', value: 'a/b/c'},{label: 'A/D', value: 'a/d'}] => [{label: 'C', value: 'c'},{label: 'D', value: 'd'}]
- */
-export declare function normalizeNodePath(value: any, enableNodePath: boolean, labelField?: string, valueField?: string, pathSeparator?: string, delimiter?: string): {
-    nodeValueArray: any[];
-    nodePathArray: any[];
-};
-export declare function isClickOnInput(e: React.MouseEvent<HTMLElement>): boolean;
-export declare function hashCode(s: string): number;
-/**
- * 遍历 schema
- * @param json
- * @param mapper
- */
-export declare function JSONTraverse(json: any, mapper: (value: any, key: string | number, host: Object) => any): void;
-export declare function convertArrayValueToMoment(value: number[], types: string[], mom: moment.Moment): moment.Moment;
-export declare function getRange(min: number, max: number, step?: number): number[];
-export declare function repeatCount(count: number, iterator: (index: number) => any): any[];
-export declare function isNumeric(value: any): boolean;
-/**
- * 获取URL链接中的query参数（包含hash mode）
- *
- * @param location Location对象，或者类Location结构的对象
- */
-export declare function parseQuery(location?: Location | {
-    query?: any;
-    search?: any;
-    [propName: string]: any;
-}): Record<string, any>;