@gct-paas/core 0.1.4-dev.1 → 0.1.4-dev.11

package/es/constants/expression-type/function.mjs

@@ -0,0 +1,875 @@
+import '../../enums/app-designer/index.mjs';
+import '../../enums/page-designer/designer.mjs';
+import '../../enums/breakpointEnum.mjs';
+
+const functionGroup = [
+  {
+    id: "LOGIC",
+    name: "逻辑",
+    children: [
+      {
+        desc: "IF(expr, a, b)\n根据条件表达式，返回不同的值, 当expr执行为true，返回a, 否则返回b。\n参数 expr: 条件表达式 a: 值 b: 另一个值 返回值 a|b\n示例\nIF(1 > 2, 1, 2); 返回 2",
+        definition: "declare function IF<T>(expr: boolean, v: T, l: T): T;"
+      },
+      {
+        desc: "ISEMPTY(a)\n判断参数a是否为空，a为空则返回true\n参数a支持的类型：String，Array，Object，返回值 true|false\n示例\nISEMPTY('')   返回 true\nISEMPTY(null)   返回 true\nISEMPTY(undefined) 返回 true\nISEMPTY([])  返回 true\nISEMPTY({})  返回 true\n",
+        definition: "declare function ISEMPTY<T>(val: T): boolean;"
+      },
+      {
+        desc: `ISNULL(a)
+    判断参数a是否为null，a为null则返回true
+    示例
+    ISNULL('')   返回 false
+    ISNULL(null)   返回 true
+    ISNULL(undefined) 返回 false`,
+        definition: "declare function ISNULL<T>(val: T): Promise<boolean>;"
+      },
+      {
+        desc: `ISUNDEFINED(a)
+    判断参数a是否为undefined，a为undefined则返回true
+    示例
+    ISUNDEFINED('')   返回 false
+    ISUNDEFINED(null)   返回 false
+    ISUNDEFINED(undefined) 返回 true`,
+        definition: "declare function ISUNDEFINED<T>(val: T): Promise<boolean>;"
+      },
+      {
+        desc: `AND(conditions): boolean
+    根据一组表达式判断是否为真，只要有一个为false，则返回false
+    参数 conditions: 条件表达式列表 返回值 true|false
+    示例
+    IF(AND(1==1,1 > 2,3==3),'正确','错误'); 返回 错误`,
+        definition: "declare function AND<T>(...e: T[]): Promise<boolean>;"
+      },
+      {
+        desc: `OR(conditions)
+    根据一组表达式判断是否为真，只要有一个为true，则返回true
+    参数 conditions: 条件表达式数组 返回值 true|false
+    示例
+    IF(AND(1==1,1 > 2,3==3),'正确','错误'); 返回 正确`,
+        definition: "declare function OR<T>(...e: T[]): Promise<boolean>;"
+      },
+      {
+        desc: `EQ(a, b)
+    比较两个值是否相等，如果相等则返回true
+    参数a/b支持的类型：Number，String ，Boolean ， Date ， Array ， Object，Array及Object比较数值型知否相等，参数 a: 一个值 b: 另一个值 返回值 true|false
+    示例
+    EQ(1, 1);   返回 true
+    EQ("a", "c");   返回 false
+    EQ([1,2,3],[1,2,3])  返回 true
+    EQ({a:1,b:1},{a:1,b:1})  返回 true`,
+        definition: "declare function EQ<T, K>(v: T, o: K): Promise<boolean>;"
+      },
+      {
+        desc: `NE(a, b)
+    比较两个值是否不相等，如果不相等则返回true
+    参数a/b支持的类型：Number，String ，Boolean ， Date ， Array ， Object，Array及Object比较数值型知否不相等， 参数 a: 一个值 b: 另一个值 返回值 true|false
+    示例
+    NE(1, 1);   返回 false
+    NE("a", "c");   返回 true
+    NE([1,2,3],[1,2,3])  返回 false
+    NE({a:1,b:1},{a:1,b:1})  返回 false`,
+        definition: "declare function NE<T>(v: T, o: T): Promise<boolean>;"
+      },
+      {
+        desc: `LE(a, b)
+    比较两个值大小，a小于等于b返回true
+    参数a/b支持的类型：Number，String，Date， 参数 a: 一个值 b: 另一个值 返回值 true|false
+    示例
+    LE(1, 1);   返回 true
+    LE(2, 1);   返回 false
+    LE('2023-07-12',''2023-07-13'')  返回 true
+    LE('12:00',''13:00'')  返回 true`,
+        definition: "declare function LE<T>(v: T, o: T): Promise<boolean>;"
+      },
+      {
+        desc: `LT(a, b)
+    比较两个值大小，a小于b返回true
+    参数a/b支持的类型：Number，String，Date， 参数 a: 一个值 b: 另一个值 返回值 true|false
+    示例
+    LT(1, 1);   返回 false
+    LT(1, 2);   返回 true
+    LT('2023-07-12',''2023-07-13'')  返回 true
+    LT('13:00',''12:00'')  返回 true`,
+        definition: "declare function LT<T>(v: T, o: T): Promise<boolean>;"
+      },
+      {
+        desc: `GE(a, b)
+    比较两个值大小，a大于等于b返回true
+    参数a/b支持的类型：Number，String，Date， 参数 a: 一个值 b: 另一个值 返回值 true|false
+    示例
+    GE(1, 1);   返回 true
+    GE(2, 3);   返回 false
+    GE('2023-07-13','2023-07-12')  返回 true
+    GE('13:00','12:00')  返回 true`,
+        definition: "declare function GE<T>(v: T, o: T): Promise<boolean>;"
+      },
+      {
+        desc: `GT(a, b)
+    比较两个值大小，a大于b返回true
+    参数a/b支持的类型：Number，String，Date， 参数 a: 一个值 b: 另一个值 返回值 true|false
+    示例
+    GT(1, 1);   返回 false
+    GT(2, 1);   返回 false
+    GT('2023-07-13','2023-07-12')  返回 true
+    GT('13:00','12:00')  返回 true`,
+        definition: "declare function GT<T>(v: T, o: T): Promise<boolean>;"
+      }
+    ]
+  },
+  {
+    id: "STRING",
+    name: "字符串",
+    children: [
+      {
+        desc: `LEN(a)
+    返回字符串长度
+    示例
+    LEN('aa');   返回 2`,
+        definition: "declare function LEN(v: string): Promise<number>;"
+      },
+      {
+        desc: `CONCAT(a,b....)
+    拼接参数a和b，返回拼接后的字符串
+    参数a/b支持字符串，返回字符串
+    示例
+    CONCAT('a','b','c') 返回abc`,
+        definition: "declare function CONCAT(...args: string[]): Promise<string>;"
+      },
+      {
+        desc: `SUBSTRING(str,start,end)
+    截取字符串str，从start开始截取到end，start从0开始，如果start和end为负数表示从最后开始截取，start为-1表示从最后一位开始截取，返回截取的字符串
+    示例
+    SUBSTRING('abcd',0,2) 返回abc
+    SUBSTRING('abcd',-1,-2) 返回 cd`,
+        definition: "declare function SUBSTRING(v: string, s: number, e: number): Promise<string>;"
+      },
+      {
+        desc: `SUBSTR(str,start,len)
+    截取字符串str，从start开始截取len长度，start从0开始，如果start为负数表示从最后开始截取，start为-1表示从最后一位开始截取，返回截取的字符串
+    SUBSTR('abcd',0,2) 返回ab
+    SUBSTRING('abcd',-1,2) 返回 cd`,
+        definition: "declare function SUBSTR(v: string, s: number, l: number): Promise<string>;"
+      },
+      {
+        desc: `UPPER(a)
+    字符串a转化为大写，参数a支持字符串
+    示例
+    UPPER('aa') 返回 AA `,
+        definition: "declare function UPPER(v: string): Promise<string>;"
+      },
+      {
+        desc: `LOWER(a)
+    字符串a转化为小写，参数a支持字符串
+    示例
+    LOWER('AA') 返回 aa`,
+        definition: "declare function LOWER(v: string): Promise<string>;"
+      },
+      {
+        desc: `TRIM(a)
+    字符串a去前后空格
+    示例
+    TRIM(' ab ')  返回 'ab'`,
+        definition: "declare function TRIM(v: string): Promise<string>;"
+      },
+      {
+        desc: `LTRIM(a)
+    字符串a去前空格
+    示例
+    LTRIM(' ab ') 返回 'ab '`,
+        definition: "declare function LTRIM(v: string): Promise<string>;"
+      },
+      {
+        desc: `RTRIM(a)
+    字符串a去前空格
+    示例
+    LTRIM(' ab ') 返回 ' ab'`,
+        definition: "declare function RTRIM(v: string): Promise<string>;"
+      },
+      {
+        desc: `REPEAT(str,a)
+    字符串a在str中重复的次数，返回重复次数
+    示例
+    REPEAT('aabbcc','a') 返回 2`,
+        definition: "declare function REPEAT(v: string, c: string): Promise<number | null>;"
+      },
+      {
+        desc: `REPLACE(str,a,b)
+    字符串str中把所有的a替换成b
+    示例
+    REPLACE('aabbcc','a','1') 返回 11bbcc`,
+        definition: "declare function REPLACE(v: string, o: string, t: string): Promise<string>;"
+      },
+      {
+        desc: `FINDSTR(str,a)
+    在字符串str中查找字符串a，如果存在返回true，不存在返回false
+    示例
+    FINDSTR('aabbcc','a') 返回 true`,
+        definition: "declare function FINDSTR(v: string, c: string): Promise<boolean>;"
+      },
+      {
+        desc: `SEARCHSTR(str,a)
+    在字符串str中查找字符串a，返回a在str中出现的次数，如果不存在则返回0
+    示例
+    SEARCHSTR('aabbcc','a')  返回 2`,
+        definition: "declare function SEARCHSTR(v: string, c: string): Promise<number>;"
+      },
+      {
+        desc: `PARSENUMBER(str)
+    字符串str转化为数值
+    示例
+    PARSENUMBER('1')  返回 1
+    PARSENUMBER('0.1') 返回 0.1`,
+        definition: "declare function PARSENUMBER(v: string): Promise<number | null>;"
+      },
+      {
+        desc: `SPLIET(str,a)
+    字符串str根据a分割转化为数组，返回数组
+    参数仅支持Number类型
+    示例
+    SPLIT('aa-bb-cc','-') 返回 ['aa','bb','cc']`,
+        definition: "declare function SPLIT(v: string, c: string): Promise<string[]>;"
+      }
+    ]
+  },
+  {
+    id: "NUMBER",
+    name: "数值",
+    children: [
+      {
+        desc: `SUM(a,b,c...)
+    参数a、b、c...相加，返回相加后的数值
+    示例
+    SUM(1,2,3) 返回 6`,
+        definition: "declare function SUM(...args: number[]): Promise<number>;"
+      },
+      {
+        desc: `REDUCE(a,b,c...)
+    参数a、b、c...相减，返回相减后的数值
+    示例
+    REDUCE(2,1) 返回 1
+    REDUCE(5,1,2) 返回 2`,
+        definition: "declare function REDUCE(...args: number[]): Promise<number>;"
+      },
+      {
+        desc: `MULTIPLICATION(a,b,c...)
+    参数a、b、c...相乘，返回相乘后的数值
+    示例
+    MULTIPLICATION(2,1) 返回 2
+    MULTIPLICATION(5,1,2) 返回 10`,
+        definition: "declare function MULTIPLICATION(...args: number[]): Promise<number>;"
+      },
+      {
+        desc: `DIVISION(a,b,c...)
+    参数a、b、c...相除，返回相除后的数值
+    示例
+    DIVISION(2,1) 返回 2
+    DIVISION(10,5,2) 返回 1`,
+        definition: "declare function DIVISION(...args: number[]): Promise<number>;"
+      },
+      {
+        desc: `FIXED(value,num)
+    参数value保留num位小数，返回数值
+    示例
+    FIXED(2.01,1) 返回 2.0
+    FIXED(2.015,2) 返回 2.01`,
+        definition: "declare function FIXED(v: number, n: number): Promise<number | Promise<Error>>;"
+      },
+      {
+        desc: `ROUND(value,num)
+    参数value保留num位四舍五入后的小数，返回数值
+    示例
+    ROUND(2.01,1) 返回 2.0
+    ROUND(2.015,2) 返回 2.02`,
+        definition: "declare function ROUND(v: number, n: number): Promise<number | Promise<Error>>;"
+      },
+      {
+        desc: `ROUNDUP(value,num)
+    将数字向上舍入到指定的位数。无论数字正负，舍入方向始终向绝对值更大的方向进行。
+    示例
+    ROUNDUP(3.141,2) 返回 3.15`,
+        definition: "declare function ROUNDUP(v: number, n: number): Promise<number | Promise<Error>>;"
+      },
+      {
+        desc: `MAX([value1, value2...])
+    从数组参数中获取最大的数，返回数值
+    参数必须为Number类型数组
+    示例
+    MAX([2, 1]) 返回 2
+    MAX([2.1, 2.2]) 返回 2.2`,
+        definition: "declare function MAX(v: number[]): Promise<number>;"
+      },
+      {
+        desc: `LARGE([value1, value2...], n)
+    从数组参数中获取第n大数值，返回数值
+    参数必须为Number类型数组
+    示例
+    LARGE([5, 4, 3, 2, 1],2) 返回 4
+LARGE([2.5, 2.4, 2.3, 2.2, 2.1], 3) 返回 2.3`,
+        definition: "declare function LARGE(v: number[], n: number): Promise<number | Promise<Error>>;"
+      },
+      {
+        desc: `MIN([value1, value2...])
+从数组参数中获取最小的数，返回数值
+参数必须为Number类型数组
+示例
+MIN([2, 1]) 返回 1
+MIN([2.1, 2.2]) 返回 2.1`,
+        definition: "declare function MIN(v: number[]): Promise<number>;"
+      },
+      {
+        desc: `SMALL([value1, value2...], n)
+从数组参数中获取第n小数值，返回数值
+参数必须为Number类型数组
+示例
+SMALL([5, 4, 3, 2, 1], 2) 返回 2
+SMALL([2.5, 2.4, 2.3, 2.2, 2.1], 3) 返回 2.3`,
+        definition: "declare function SMALL(v: number[], n: number): Promise<number | Promise<Error>>;"
+      },
+      {
+        desc: `AVERAGE([value1, value2...])
+取数组中所有数值的平均值，返回数值
+参数必须为Number类型数组
+示例
+AVERAGE([5, 4, 3, 2, 1]) 返回 3`,
+        definition: "declare function AVERAGE(v: number[]): Promise<number | Promise<Error>>;"
+      },
+      {
+        desc: `ABS(value)
+取数值参数value的绝对值，返回数值
+参数必须为Number类型
+示例
+ABS(-1) 返回 1`,
+        definition: "declare function ABS(v: number): Promise<number>;"
+      },
+      {
+        desc: `MOD(value1, value2)
+取数value1除以value2的余数，返回数值
+参数必须为Number类型
+示例
+MOD(4, 3) 返回 1`,
+        definition: "declare function MOD(v: number, n: number): Promise<number | Promise<Error>>;"
+      },
+      {
+        desc: `POWER(value, n)
+获取数值value的n次乘幂，返回数值
+参数必须为Number类型
+示例
+POWER(4, 2) 返回 16`,
+        definition: "declare function POWER(v: number, n: number): Promise<number>;"
+      },
+      {
+        desc: `SQRT(value)
+获取数值value的平方根，返回数值
+参数必须为Number类型
+示例
+SQRT(4) 返回 2`,
+        definition: "declare function SQRT(v: number): Promise<number>;"
+      },
+      {
+        desc: `SUMSQ
+    SUMSQ(数字1, 数字2, ...) 计算一组数值的平方和。
+    示例
+    SUMSQ(2,3)=2²+3²=13`,
+        definition: "declare function SUMSQ(...args: number[]): Promise<number>;"
+      },
+      {
+        desc: `STDEV
+    STDEV(数字1, 数字2, ...) 计算一组数值的标准差。
+    示例
+    STDEV([10, 12, 23, 23, 16, 23, 21, 16])=5.237229365663817`,
+        definition: "declare function STDEV(...args: number[]): Promise<number>;"
+      }
+    ]
+  },
+  {
+    id: "OBJECT,ARRAY",
+    name: "对象/数组",
+    children: [
+      {
+        desc: `TUPLE(1, 2, 3)
+把多个参数转化为数组结构
+示例
+TUPLE(1, 2, 3) 返回[1, 2, 3]`,
+        definition: "declare function TUPLE(x:any): any[]"
+      },
+      {
+        desc: `SEQMAP('a', 1, 'b', 'c')
+把多个参数转化对象
+示例
+SEQMAP('a', 1, 'b', 'c') 返回 { a: 1, b: 'c' } `,
+        definition: "declare function SEQMAP(a:string,b:any): object"
+      },
+      {
+        desc: `GET(a, b)
+如果a是对象，则获取对象a中属性b的值，如果a是数组，则获取下标b的数据项
+参数a支持的类型： Array ， Object，参数b支持的类型: Number，String
+示例
+GET(['A', 'B', 'C'], 1)  返回 A
+GET({ a: 1, b: 2, c: 3 }, 'a')  返回 B`,
+        definition: "declare function GET<T extends object | any[]>(v: T, p: number | keyof T): Promise<T[keyof T]>;"
+      },
+      {
+        desc: `PUT(a, b, c)
+如果a是对象，则b为对象中的属性，c为需要设置的属性值，如果a是数组，则b数组的下标，c为该下标需要设置的数据项
+参数a支持的类型： Array ， Object，参数b支持的类型: Number，String ，参数c泛型
+示例
+PUT(['A', 'B', 'C'], 1, 'D')  返回['A', 'D', 'C']
+PUT({ a: 1, b: 2, c: 3 }, 'a', 4)  返回 { a: 4, b: 2, c: 3 } `,
+        definition: "declare function PUT<T>(a: T, b: keyof T, c: T[keyof T | any]): Promise<T | Promise<Error>>;"
+      },
+      {
+        desc: `PUSH(a, b)
+在数组对象a末尾追加b
+参数a的类型为Array, 参数b泛型，返回数组
+示例
+PUSH([1, 2, 3], 4)  返回[1, 2, 3, 4]`,
+        definition: "declare function PUSH<T>(v: any[], n: T): Promise<T[] | Promise<Error>>;"
+      },
+      {
+        desc: `HEADPUSH(a, b)
+在数组对象a头部追加b
+参数a的类型为Array, 参数b泛型，返回数组
+示例
+HEADPUSH([1, 2, 3], 0)  返回[0, 1, 2, 3]`,
+        definition: "declare function HEADPUSH<T>(v: any[], n: T): Promise<T[] | Promise<Error>>;"
+      },
+      {
+        desc: `COUNT
+    COUNT([数字1, 数字2, ...]) 计算数组的数量。
+    示例
+    COUNT([10, 12, 23, 23, 16, 23, 21, 16])=8`,
+        definition: "declare function COUNT(v: number[]): Promise<number>;"
+      }
+    ]
+  },
+  {
+    id: "DATE",
+    name: "日期",
+    children: [
+      {
+        desc: `TIMESTAMP2DATE(dtstr)
+时间戳转化为日期对象，参数dtstr为时间戳类型，返回日期时间对象
+示例
+TIMESTAMP2DATE(1689558261)  返回 2023-07 - 17 9: 44: 21`,
+        definition: "declare function TIMESTAMP2DATE(v: number): Promise<string | Promise<Error>>;"
+      },
+      {
+        desc: `DATE2TIMESTAMP(dt)
+日期转时间戳，参数dt为日期类型，返回时间戳
+示例
+DATE2TIMESTAMP()`,
+        definition: "declare function DATE2TIMESTAMP(v: string): Promise<number>;"
+      },
+      {
+        desc: `DATEFORMAT(dt, format)
+日期转字符串，参数dt为日期类型，format为格式
+示例
+DATEFORMAT(NOW(), YYYY-MM-DD HH:mm)`,
+        definition: "declare function DATEFORMAT(v: Date, f: string): Promise<string>;"
+      },
+      {
+        desc: `NOW()
+获取当前日期时间
+NOW()  返回 2023-07 - 17 9: 44: 21`,
+        definition: "declare function NOW(): Promise<string>;"
+      },
+      {
+        desc: "TODAY(获取当天日期TODAY()  返回2023-07-17",
+        definition: "declare function TODAY(): Promise<string>;"
+      },
+      {
+        desc: `YEAR(dt)
+获取参数dt类型的年份
+YEAR(NOW())  返回 2024`,
+        definition: "declare function YEAR(v: string | number | Date | null | undefined): number;"
+      },
+      {
+        desc: `MONTH(dt)
+获取参数dt类型的月份
+MONTH(NOW())  返回 7`,
+        definition: "declare function MONTH(v: string | number | Date | null | undefined): Promise<number>;"
+      },
+      {
+        desc: `DAY(dt)
+获取参数dt类型的日
+DAY(NOW())  返回 17`,
+        definition: "declare function DAY(v: string | number | Date | null | undefined): Promise<number>;"
+      },
+      {
+        desc: `HOUR(dt)
+获取参数dt类型的小时
+HOUR(NOW()) 返回 10`,
+        definition: "declare function HOUR(v: string | number | Date | null | undefined): Promise<number>;"
+      },
+      {
+        desc: `MINUTE(dt)
+获取参数dt类型的分钟
+MINUTE(NOW()) 返回 44`,
+        definition: "declare function MINUTE(v: string | number | Date | null | undefined): Promise<number>;"
+      },
+      {
+        desc: `WEEKRANGE()
+获取本周开始及结束日期
+WEEKRANGE()  返回[2023-07 - 17 00:00:00.000000000 +0800 CST, 2023-07 - 23 23: 59: 59.000000000 +0800 CST]`,
+        definition: "declare function WEEKRANGE(): Promise<[string, string]>;"
+      },
+      {
+        desc: `LASTWEEKRANGE()
+获取本周开始及结束日期
+LASTWEEKRANGE()  返回[2023-07 - 10 00:00:00.000000000 +0800 CST, 2023-07 - 16 23: 59: 59.000000000 +0800 CST]`,
+        definition: "declare function LASTWEEKRANGE(): Promise<[string, string]>;"
+      },
+      {
+        desc: `MONTHRANGE()
+获取本月开始及结束日期
+MONTHRANGE()  返回[2023-07-01 00:00:00.000000000 +0800 CST, 2023-07 - 31 23: 59: 59.000000000 +0800 CST]`,
+        definition: "declare function MONTHRANGE(): Promise<[string, string]>;"
+      },
+      {
+        desc: `LASTMONTHRANGE()
+获取上月开始及结束日期
+MONTHRANGE()  返回[2023-06-01 00:00:00.000000000 +0800 CST, 2023-06 - 30 23: 59: 59.000000000 +0800 CST]`,
+        definition: "declare function LASTMONTHRANGE(): Promise<[string, string]>;"
+      },
+      {
+        desc: `YEARRANGE()
+获取本年开始及结束日期
+YEARRANGE()  返回[2023-01-01 00:00:00.000000000 +0800 CST, 2023 - 12 - 31 23: 59: 59.000000000 +0800 CST]`,
+        definition: "declare function YEARRANGE(): Promise<[string, string]>;"
+      },
+      {
+        desc: `LASTYEARRANGE()
+获取上一年开始及结束日期
+LASTYEARRANGE()  返回[2022-01-01 00:00:00.000000000 +0800 CST, 2022 - 12 - 31 23: 59: 59.000000000 +0800 CST]`,
+        definition: "declare function LASTYEARRANGE(): Promise<[string, string]>;"
+      },
+      {
+        desc: `QUARTER()
+获取本季度开始及结束日期
+QUARTER()  返回[2022-07-01 00:00:00.000000000 +0800 CST, 2022 -09 - 30 23: 59: 59.000000000 +0800 CST]`,
+        definition: "declare function QUARTER(): Promise<[string, string]>;"
+      },
+      {
+        desc: `LASTQUARTER()
+获取上季度开始及结束日期
+LASTQUARTER()  返回[2022-04-01 00:00:00.000000000 +0800 CST, 2022-06 - 30 23: 59: 59.000000000 +0800 CST]`,
+        definition: "declare function LASTQUARTER(): Promise<[string, string]>;"
+      },
+      {
+        desc: `ISDATERANGE(dt, [startDate, endDate])
+判断参数dt是否在给定的区间范围内，如果在则返回true，反之返回false
+ISDATERANGE(NOW(), WEEKRANGE())  返回 true`,
+        definition: "declare function ISDATERANGE(v: Date, r: [Date, Date]): Promise<boolean>;"
+      },
+      {
+        desc: `ISTIMERANGE(dt, [startTime, endTime])
+判断参数dt是否在给定的区间范围内，如果在则返回true，反之返回false
+参数dt、startTime、endTime为时间字符串，如果startTime大于endTime则跨天
+ISTIMERANGE(DATEFORMAT(NOW(), HH:mm), ['06:00', '12:00'])  返回 true
+ISTIMERANGE(DATEFORMAT(NOW(), HH:mm), ['13:00', '07:00'])  返回 true `,
+        definition: "declare function ISTIMERANGE(v: string, r: [string, string]): Promise<boolean>;"
+      }
+    ]
+  }
+].map((group) => {
+  group.children = (group.children ?? []).map((item) => {
+    const matchId = item.definition.match(/(?<=declare function )([A-Z0-9]+)/g);
+    const id = matchId?.[0] ?? "UNKNOWN";
+    const args = (item.definition.match(/([a-z]:)+/g) || []).length;
+    Object.assign(item, {
+      id,
+      name: id,
+      idToChildren: false,
+      _args_: args
+    });
+    return item;
+  });
+  return group;
+});
+const functionMap = functionGroup.reduce(
+  (map, g) => {
+    g.children.forEach((item) => {
+      map[item.id] = item;
+    });
+    return map;
+  },
+  {}
+);
+const ipaasBackFunctionGroup = [
+  {
+    id: "INNER",
+    name: "内置",
+    children: [
+      {
+        desc: "MD5(str) 计算输入字符串的MD5值\n示例: MD5('abc')\n返回 900150983cd24fb0d6963f7d28e17f72\n",
+        definition: "declare function MD5(str: string): string;"
+      },
+      {
+        desc: "SHA1(str) 计算输入字符串的HASH值\n示例: SHA1('abc')\n返回 a9993e364706816aba3e25717850c26c9cd0d89d",
+        definition: "declare function SHA1(str: string): string;"
+      },
+      {
+        desc: "SHA256(str) 计算输入字符串的HASH值\n",
+        definition: "declare function SHA256(str: string): string;"
+      },
+      {
+        desc: "SHA512(str) 计算输入字符串的HASH值\n示例: SHA512('abc')\n返回 ddaf35a193617abacc417349ae20...",
+        definition: "declare function SHA512(str: string): string;"
+      },
+      {
+        desc: "RANDOMSTR(number) 生成随机字符串\nnumber:为随机字符串的长度\n示例: RandomStr(6)\n返回 o4EX1D",
+        definition: "declare function RANDOMSTR(number: number): string;"
+      },
+      {
+        desc: "NOW(format) 生成指定格式的当前时间戳\nformat为时间格式,可选值参考'yyyy-MM-dd','yyyy-MM-dd HH:mm:ss','HH:mm:ss'\n示例: NOW('yyyy-MM-dd')\n返回 1970-01-01",
+        definition: "declare function NOW(format: string): string;"
+      },
+      {
+        desc: "CONCAT(a,b....)\n拼接参数a和b，返回拼接后的字符串\n参数a/b支持字符串，返回字符串\n示例 CONCAT('a','b','c')\n返回abc",
+        definition: "declare function CONCAT(...args: string[]): string;"
+      },
+      {
+        desc: `UNIX10()
+返回10位的时间戳
+UNIX10()  返回 1677811200`,
+        definition: "declare function UNIX10(): number;"
+      },
+      {
+        desc: `UNIX13()
+返回13位的时间戳
+UNIX13()  返回 1677811200000`,
+        definition: "declare function UNIX13(): number;"
+      }
+    ]
+  }
+].map((group) => {
+  group.children = group.children.map((item) => {
+    const id = item.definition.match(/(?<=declare function )([A-Z0-9]+)/g)[0];
+    const args = (item.definition.match(/([a-z]:)+/g) || []).length;
+    Object.assign(item, {
+      id,
+      name: id,
+      idToChildren: false,
+      _args_: args
+    });
+    return item;
+  });
+  return group;
+});
+const ipaasBackFunctionMap = functionGroup.reduce((map, g) => {
+  g.children.forEach((item) => {
+    map[item.id] = item;
+  });
+  return map;
+}, {});
+const biBackFunctionGroup = [
+  {
+    id: "COMMON",
+    name: "常用",
+    children: [
+      {
+        desc: "将多个字段合并成一个字符串\n示例: CONCAT('a', '-', 'b') = 'a-b'\n",
+        definition: "declare function CONCAT( ...any: string[]): string;"
+      },
+      {
+        desc: "返回日期的指定中加上指定的数字 后的日期\n示例: DATEADD('2020-09-29', 100, days) = 2021-01-07\n",
+        definition: "declare function DATEADD(data: string, interval: number, date_part: string): string;"
+      },
+      {
+        desc: "返回 <date1> 与 <date2> 之差。以 <date_part> 的单位表示，只计算完整<date_part>\n示例: DATEDIFF('2024-05-22', '2020-09-29', 'year') = 3\n",
+        definition: "declare function DATEDIFF(date1: string, date2: string, date_part: string): number;"
+      },
+      {
+        desc: "将日期进行格式化，并输出文本\n示例: DATEFORMAT(2020-09-29, yyyyMMdd) = '20200929'\n",
+        definition: "declare function DATEFORMAT(date: any, format: string): string;"
+      },
+      {
+        desc: "以<format>格式解析字符串<date_string>，并转化为日期类型。\n示例: TODATE('2020-09-29', 'yyyy-MM-dd') = 2020-09-29\n",
+        definition: "declare function TODATE(date_string: string, format:string): any;"
+      },
+      {
+        desc: "NULLIF函数接受两个参数，如果两个参数相等则返回NULL，否则返回第一个参数,可以用来避免分母为0的情况\n示例: 如果field为0 则返回null,NULLIF(<field>,0) = null\n",
+        definition: "declare function NULLIF(arg1: any,arg2:any): any;"
+      }
+    ]
+  },
+  {
+    id: "NUMBER",
+    name: "数值",
+    children: [
+      {
+        desc: "返回多个参数中的最大值，至少输入2个参数\n示例: GREATEST(10, 5, 7) = 10\n",
+        definition: "declare function GREATEST( ...any: number[]): number;"
+      },
+      {
+        desc: "返回多个参数中的最小值，至少输入2个参数\n示例: LEAST(10, 5, 7) = 5\n",
+        definition: "declare function LEAST( ...any: number[]): number;"
+      },
+      {
+        desc: "将<number> 舍入为指定位数。 <decimals>指定输出结果的小数位数精度。如果省略decimals，则输出为整数\n示例: ROUND(1/3, 2) = 0.33\n",
+        definition: "declare function ROUND(number: number, decimals?: number): number"
+      }
+    ]
+  },
+  {
+    id: "TEXT",
+    name: "文本",
+    children: [
+      {
+        desc: "将多个字段合并成一个字符串\n示例: CONCAT('a', '-', 'b') = 'a-b'\n",
+        definition: "declare function CONCAT( ...any: string[]): string;"
+      },
+      {
+        desc: "如果给定字符串包含指定子字符串，则返回 true\n示例: CONTAINS('Hello World', ' ') = true\n",
+        definition: "declare function CONTAINS(string: string, substring: string): boolean;"
+      },
+      {
+        desc: "返回子字符串在字符串中的索引位置，从指定的索引<start>开始查找（<start>可不填）。如果未找到子字符串，则返回 0。字符串中第一个字符的位置为 1\n示例: FIND('World', 'Hello World') = 7\nFIND('Computer', 'Hello World') = 0\n",
+        definition: "declare function FIND(substring: string, string: string, start?: number): number;"
+      },
+      {
+        desc: "返回字符串长度\n示例: LEN('Hello World') = 11\n",
+        definition: "declare function LEN(string: string): number;"
+      },
+      {
+        desc: "返回<string>从指定<start>位置处开始的字符串。字符串中第一个字符的位置为 1。 如果添加了可选数字参数<length>，则返回的字符串仅包含该数量的字符\n示例: MID('Hello World', 2) = 'ello World'\nMID('Hello World', 2, 4) ='ello'\n",
+        definition: "declare function MID(string: string, start: number, length?: number): string"
+      },
+      {
+        desc: "在 <string> 中搜索 <substring> 并将其替换为 <replacement>。如果未找到 <substring>，则字符串保持不变。\n示例: REPLACE('Hello World', ' ', '-') = 'Hello-World'\n",
+        definition: "declare function REPLACE(string: string, substring: string, replacement: string): string"
+      },
+      {
+        desc: "移除 <string> 的所有前置空格和尾随空格\n示例: TRIM(' Hello World ') = 'Hello World'\n",
+        definition: "declare function TRIM(string: string): string"
+      }
+    ]
+  },
+  {
+    id: "DATE",
+    name: "日期",
+    children: [
+      {
+        desc: "返回日期的指定中加上指定的数字 后的日期\n示例: DATEADD('2020-09-29', 100, days) = 2021-01-07\n",
+        definition: "declare function DATEADD(data: string, interval: number, date_part: string): string;"
+      },
+      {
+        desc: "以整数的形式返回给定 <date> 的天\n示例: DAY('2020-09-29') = 29\n",
+        definition: "declare function DAY(date: string): number;"
+      },
+      {
+        desc: "以整数形式返回给定 <date> 的月份\n示例: MONTH('2020-09-29') = 9\n",
+        definition: "declare function MONTH(date: string): number;"
+      },
+      {
+        desc: "返回一个依据指定 <year>、<month> 和 <day> 构造的日期值\n示例: MAKEDATE(2020, 9, 29) = 2020-09-29\n",
+        definition: "declare function MAKEDATE(year: number, month: number, day: number): any;"
+      },
+      {
+        desc: "返回当前时间\n示例: NOW() = 2024-05-22 09:29:29\n",
+        definition: "declare function NOW(): any;"
+      },
+      {
+        desc: "以整数形式返回给定 <date> 的季度\n示例: QUARTER('2020-09-29') = 3\n",
+        definition: "declare function QUARTER(date: string): number;"
+      },
+      {
+        desc: "返回当前日期\n示例: TODAY() = 2024-05-22\n",
+        definition: "declare function TODAY(): any;"
+      },
+      {
+        desc: "以整数形式返回给定 <date> 的周\n示例: WEEK('2010-01-01') = 52\nWEEK('2010-01-06') = 1\n",
+        definition: "declare function WEEK(date: string): number;"
+      },
+      {
+        desc: "以整数形式返回给定 <date> 的年份\n示例: YEAR('2020-09-29') = 2020\n",
+        definition: "declare function YEAR(date: string): number;"
+      }
+    ]
+  },
+  {
+    id: "PARSE",
+    name: "转换",
+    children: [
+      {
+        desc: "将日期进行格式化，并输出文本\n示例: DATEFORMAT(2020-09-29, yyyyMMdd) = '20200929'\n",
+        definition: "declare function DATEFORMAT(date: any, format: string): string;"
+      },
+      {
+        desc: "以<format>格式解析字符串<date_string>，并转化为日期类型。\n示例: TODATE('2020-09-29', 'yyyy-MM-dd') = 2020-09-29\n",
+        definition: "declare function TODATE(date_string: string, format:string): any;"
+      },
+      {
+        desc: "将文本或数值转为浮点数\n示例: TODOUBLE('123.21') = 123.21\nTODOUBLE(3) = 3.0\n",
+        definition: "declare function TODOUBLE(expression: string | number): number;"
+      },
+      {
+        desc: "将文本或数值转为整数，若存在小数部分将舍弃\nTOINT('123.9') = 123\n",
+        definition: "declare function TOINT(expression: string | number) : number;"
+      },
+      {
+        desc: "将数值转为字符串\nTOSTR(123) = '123'\n",
+        definition: "declare function TOSTR(expression: number) : string;"
+      }
+    ]
+  },
+  {
+    id: "AGG",
+    name: "聚合",
+    children: [
+      {
+        desc: "平均值\n示例: AVG([订单金额])\n根据图表中使用的维度进行聚合，求订单金额的平均值\n",
+        definition: "declare function AVG(number: number): number;"
+      },
+      {
+        desc: "计数\n示例: COUNT([订单ID])\n根据图表中使用的维度进行聚合，求订单的数量\n",
+        definition: "declare function COUNT(expression: string | number): number;"
+      },
+      {
+        desc: "去重计数\n示例: COUNTD([订单ID])\n根据图表中使用的维度进行聚合，求订单ID去重后的数量\n",
+        definition: "declare function COUNTD(expression: string | number): number;"
+      },
+      {
+        desc: "最大值\n示例: MAX([订单金额])\n根据图表中使用的维度进行聚合，求订单金额的最大值\n",
+        definition: "declare function MAX(expression: number): number;"
+      },
+      {
+        desc: "中位数\n示例: MEDIAN([订单金额])\n根据图表中使用的维度进行聚合，求订单金额的中位数\n",
+        definition: "declare function MEDIAN(number: number): number;"
+      },
+      {
+        desc: "最小值\n示例: MIN([订单金额])\n根据图表中使用的维度进行聚合，求订单金额的最小值\n",
+        definition: "declare function MIN(expression: number): number;"
+      },
+      {
+        desc: "求和\n示例: SUM([订单金额])\n根据图表中使用的维度进行聚合，求订单金额的总和\n",
+        definition: "declare function SUM(number: number): number;"
+      }
+    ]
+  }
+].map((group) => {
+  group.children = group.children.map((item) => {
+    const id = item.definition.match(/(?<=declare function )([A-Z0-9_]+)/g)[0];
+    const args = (item.definition.match(/([a-z]:)+/g) || []).length;
+    Object.assign(item, {
+      id,
+      name: id,
+      idToChildren: false,
+      _args_: args
+    });
+    return item;
+  });
+  return group;
+});
+const biBackFunctionMap = biBackFunctionGroup.reduce(
+  (map, g) => {
+    g.children.forEach((item) => {
+      map[item.id] = item;
+    });
+    return map;
+  },
+  {}
+);
+
+export { biBackFunctionGroup, biBackFunctionMap, functionGroup, functionMap, ipaasBackFunctionGroup, ipaasBackFunctionMap };