af-mobile-client-vue3 1.2.31 → 1.2.33

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "af-mobile-client-vue3",
   "type": "module",
-  "version": "1.2.31",
+  "version": "1.2.33",
   "packageManager": "pnpm@10.12.3",
   "description": "Vue + Vite component lib",
   "engines": {

package/src/expression/ExpressionRunner.ts

@@ -0,0 +1,28 @@
+import type Delegate from './core/Delegate'
+import type JSONObject from './instances/JSONObject'
+import Program from './core/Program'
+
+export default class ExpressionRunner {
+  /**
+   * Runs an expression with parameters
+   *
+   * @param source Expression source
+   * @param params Expression parameters
+   * @returns The result of the expression
+   */
+  public static run(source: string, params: JSONObject): any {
+    const delegate: Delegate = this.getDelegate(source)
+    return delegate.invoke(params)
+  }
+
+  /**
+   * Gets the delegate for the expression
+   *
+   * @param source Expression source
+   * @returns A delegate to invoke
+   */
+  public static getDelegate(source: string): Delegate {
+    // Parse the source and return a delegate
+    return new Program(source).parse()
+  }
+}

package/src/expression/TestExpression.ts

@@ -0,0 +1,510 @@
+import Program from './core/Program'
+import JSONObject from './instances/JSONObject'
+import LogicConsole from './instances/LogicConsole'
+
+console.info('1.========testValidate========')
+testValidate()
+console.info('2.========testAssert========')
+testAssert()
+console.info('3.========testTry========')
+testTry()
+console.info('4.========testPropertyType========')
+testPropertyType()
+console.info('5.========testJSONArrayIndex========')
+testJSONArrayIndex()
+console.info('6.========testArrayIndex========')
+testArrayIndex()
+console.info('7.========testCompare========')
+testCompare()
+console.info('8.========testJSONObject========')
+testJSONObject()
+console.info('9.========testJSONArray========')
+testJSONArray()
+console.info('10.========testFunctionCall========')
+testFunctionCall()
+console.info('11.========testMath========')
+testMath()
+console.info('12.========testString========')
+testString()
+console.info('13.========testCondition========')
+testCondition()
+console.info('14.========testThrow========')
+testThrow()
+console.info('15.========testJSONArrayLoop========')
+testJSONArrayLoop()
+console.info('16.========testJSONObjectLoop========')
+testJSONObjectLoop()
+console.info('17.========testIntLoop========')
+testIntLoop()
+console.info('18.========testContinueAndBreak========')
+testContinueAndBreak()
+console.info('19.========testComment========')
+testComment()
+console.info('20.========testReturn========')
+testReturn()
+console.info('21.========testLambda========')
+testLambda()
+
+/**
+ * validate
+ */
+function testValidate() {
+  const expression = `
+    validate {
+        model: {
+            required: true,
+        },
+        visible: {
+            default: 1 + 1,
+        },
+        isAep: {
+            default: 3
+        },
+        testJson: {
+            required: true,
+            items: {
+                userid: {
+                    required: true
+                }
+            }
+        },
+        testGroup: {
+            mode: "atLeastOne",
+            fields: [
+                "test1",
+                "test2"
+            ]
+        }
+    },
+    data.isAep == 3 :(
+        log.info(123)
+    ),null,
+    log.info(data)
+  `
+  const data = {
+    model: 'a',
+    test1: 'b',
+    isAep: null,
+    testJson: {
+      userid: {},
+    },
+  }
+  runExpression(expression, data)
+}
+
+/**
+ * assert
+ */
+function testAssert() {
+  const expression = `
+    c = 1,
+    assert c == 1,
+    log.debug("ok"),
+    a = 1 + c,
+    assert a == 2,
+    log.debug("ok2")`
+  runExpression(expression)
+}
+
+/**
+ * try
+ */
+function testTry() {
+  const expression = `
+    a = 0,
+    log.debug(a),
+    try {
+        assert c == 2
+    } catch (WebException e) {
+        log.debug(e),
+        a = 1 + 1
+    } catch (Exception e) {
+        log.debug(e),
+        a = 1 + 2
+    },
+    log.debug(a)
+  `
+  runExpression(expression)
+}
+
+/**
+ * property
+ */
+function testPropertyType() {
+  const expression = `
+    a = 1,
+    b = 2.0,
+    c = {
+        d: 1,
+        e: {
+            str: "123",
+            你好: "中国"
+        }
+    },
+    c.a = 1,
+    log.debug(c.e.你好),
+    log.debug(c["e"].str),
+    e = c.d,
+    f = "123",
+    g = [],
+    名称 = "123=>",
+    log.debug(data.testArray[0]),
+    return 名称
+  `
+  const data = {
+    testArray: 'zhang|b|c'.split('\|'),
+  }
+  runExpression(expression, data)
+}
+
+/**
+ * JSONArray index
+ */
+function testJSONArrayIndex() {
+  const expression = `
+    a = [1,2,3,4,5],
+    return a[4]
+  `
+  runExpression(expression)
+}
+
+/**
+ * array index
+ */
+function testArrayIndex() {
+  const expression = `
+    return data.a[4]
+  `
+  const data = {
+    a: [1, 2, 3, 4, 5],
+  }
+  runExpression(expression, data)
+}
+
+function testCompare() {
+  const expression = `
+    a = 0,
+    a >= 0 :(
+        a = a + 1,
+        b = 1,
+        a == b :(
+            c = 3.0,
+            a < c :(
+                a + 2,
+                a <= c :(
+                    strA = $a$,
+                    strB = $b$,
+                    strC = $c$,
+                    strA < strB && strA != strC :(
+                        return $ok$
+                    ),null
+                ),null
+            ),null
+        ),null
+    ),null
+  `
+  runExpression(expression)
+}
+
+/**
+ * JSONObject
+ */
+function testJSONObject() {
+  const expression = `
+    datas = {
+        name: "张三",
+        年龄: 15,
+    },
+    datas
+  `
+  runExpression(expression)
+}
+
+/**
+ * JSONArray
+ */
+function testJSONArray() {
+  const expression = `
+    datas = ["a","b","c"],
+    datas
+  `
+  runExpression(expression)
+}
+
+/**
+ * function call
+ */
+function testFunctionCall() {
+  const expression = `
+    log.debug("test is ok")
+  `
+  runExpression(expression)
+}
+
+/**
+ * math
+ */
+function testMath() {
+  const expression = `
+    a = 1,
+    b = 2,
+    c = a + b,
+    c = c - 1,
+    d = 5 * 8,
+    e = d / 10,
+    e = e % 2,
+    c
+  `
+  runExpression(expression)
+}
+
+/**
+ * string
+ */
+function testString() {
+  const expression = `
+    test1 = {}.toString(),
+    log.debug(test1),
+    a = $part1$,
+    log.debug(a),
+    b = "part2",
+    log.debug(b),
+    c = "{a}:{b}",
+    log.debug(c),
+    d = "{name}:张三",
+    log.debug(d),
+    e = "\\{name\\}:张三",
+    log.debug(e),
+    f = "\\"123\\"",
+    log.debug(f),
+    g = "\\$15.7",
+    log.debug(g),
+    h = $\\$15.7$,
+    log.debug(h),
+    i = "http:\\\\www.baidu.com",
+    log.debug(i),
+    j = $http://www.baidu.com$,
+    log.debug(j)
+  `
+  runExpression(expression)
+}
+
+/**
+ * condition
+ */
+function testCondition() {
+  const expression = `
+    1 != 1 :(
+        throw "异常"
+    ),null,
+    1 + 1 != 2 :(
+        throw "异常"
+    ),null,
+    !(2 > 3) && !(3 > 2):(
+        throw "异常"
+    ),null,
+    2 > 3 :(
+        throw "异常"
+    ),null,
+    !(3 > 2) :(
+        throw "异常"
+    ),null,
+    y = 1 > 0,
+    !y && 1 > 0 :(
+        throw "异常"
+    ),null
+  `
+  const data = {
+    type: '1',
+  }
+  runExpression(expression, data)
+}
+
+/**
+ * throw
+ */
+function testThrow() {
+  const expression = `
+    data.type == 2 :(
+        throw "error",
+        log.debug(result)
+    ),null
+  `
+  const data = {
+    type: '1',
+  }
+  runExpression(expression, data)
+}
+
+/**
+ * JSONArray loop
+ */
+function testJSONArrayLoop() {
+  const expression = `
+    log.debug("test-JSONArray"),
+    datas = [1,2,3,4,5],
+    datas.each(
+        log.debug(\${row}\$)
+    ),
+    log.debug("test-Set"),
+    data.testSet.each(
+        log.debug(\${row}\$)
+    ),
+    log.debug("test-Array"),
+    data.testArray.each(
+        log.debug(\${row}\$)
+    )
+  `
+  const data = {
+    testSet: [1, 2, 3, 4, 5],
+    testArray: 'a|b|c'.split('\|'),
+  }
+  runExpression(expression, data)
+}
+
+/**
+ * JSONObject loop
+ */
+function testJSONObjectLoop() {
+  const expression = `
+    log.debug("test-JSONObject"),
+    datas = {name: 1, age: 2},
+    datas.each(
+        log.debug(\${rowKey}：{row}$)
+    ),
+    log.debug("test-Map"),
+    data.testMap.each(
+        log.debug(\${rowKey}：{row}$)
+    )
+  `
+  const data = {
+    testMap: {
+      name: 'xxx',
+      age: 18,
+      gender: '男',
+    },
+  }
+  runExpression(expression, data)
+}
+
+/**
+ * int loop
+ */
+function testIntLoop() {
+  const expression = `
+    a = 5,
+    a.each(
+        log.debug(row)
+    ),
+    (0,5).each(
+        log.debug(row)
+    ),
+    null
+  `
+  runExpression(expression)
+}
+
+/**
+ * continue and break
+ */
+function testContinueAndBreak() {
+  const expression = `
+    datas = [1,2,3,4,5,6,7],
+    datas.each(
+        row == 3 :(
+          continue
+        ),row == 5:(
+          break
+        ),
+        log.debug(row)
+    )
+  `
+  runExpression(expression)
+}
+
+/**
+ * comment
+ */
+function testComment() {
+  const expression = `
+    $//排序单表查询
+    select {items}
+    from {tablename}
+    where {condition}
+    order by {orderitem}
+  `
+  runExpression(expression)
+}
+
+/**
+ * return
+ */
+function testReturn() {
+  const expression = `
+    data.type == 1 :(
+        return "123",
+        log.debug(123)
+    ),(
+        return 2
+    ),
+    log.debug(123)
+  `
+  const data = {
+    type: 1,
+  }
+  runExpression(expression, data)
+}
+
+/**
+ * lambda
+ */
+function testLambda() {
+  const expression = `
+    log.debug("进入外层逻辑，参数：{data}"),
+    age = 13,
+    // 声明一个lambda块
+    lambdaObj = (data) => {
+        index = 1,
+        log.debug("进入lambda了"),
+        log.debug("传入lambda块的参数：{data}"),
+        log.debug("外层的只读参数：{age}"),
+        return "执行lambda完成"
+    },
+    log.debug("age参数:{age}"),
+    result = lambdaObj.apply({
+        name: "江超"
+    }),
+    result = lambdaObj.apply({
+        name: "大神"
+    }),
+    log.debug("result:{result}"),
+    return {
+        func: lambdaObj
+    }
+  `
+  const data = {
+    type: 1,
+  }
+  runExpression(expression, data)
+}
+
+function runExpression(expression: string, data?: any) {
+  const program = new Program(expression)
+  const d = program.parse()
+  const params: any = {}
+  if (data == null) {
+    data = {}
+  }
+  params.data = data
+  params.log = new LogicConsole()
+  params.b = 5
+  // eslint-disable-next-line no-useless-catch
+  try {
+    const result = d.invoke(new JSONObject(params))
+    console.log(result)
+    return result
+  }
+  catch (e) {
+    throw e
+  }
+}

package/src/expression/core/Delegate.ts

@@ -0,0 +1,116 @@
+import type Expression from './Expression'
+import ExpressionType from '../enums/ExpressionType'
+import ReturnWayException from '../exception/ReturnWayException'
+import JSONObject from '../instances/JSONObject'
+
+export default class Delegate {
+  private exp: Expression
+  private source: string
+  private lambdaOutProps: string[] = []
+  private objectNames: JSONObject
+
+  constructor(exp: Expression, source: string, objectNames?: JSONObject) {
+    this.exp = exp
+    this.source = source
+    if (objectNames) {
+      this.objectNames = objectNames
+    }
+    else {
+      this.objectNames = new JSONObject()
+    }
+  }
+
+  // 执行程序，执行前，参数必须实例化
+  invoke(params?: JSONObject): any {
+    if (params == null) {
+      params = new JSONObject()
+    }
+    // 把初始参数给参数表
+    this.objectNames = params
+    // 沿根Expression节点遍历，把delegate传递下去
+    this.putDelegate(this.exp)
+    // 调用exp的执行过程
+    try {
+      return this.exp.invoke()
+    }
+    catch (returnWay) {
+      if (returnWay instanceof ReturnWayException) {
+        return returnWay.getReturnObject()
+      }
+      throw returnWay
+    }
+  }
+
+  // 沿根节点递归，传递delegate的过程
+  private putDelegate(parent: Expression): void {
+    for (const child of parent.children) {
+      // 有些节点会放空的子节点
+      if (child == null) {
+        continue
+      }
+      // try特殊处理
+      if (child.type === ExpressionType.Try) {
+        const exps: Expression[] = child.value as Expression[]
+        if (exps[0] != null) {
+          exps[0].setDelegate(this)
+          this.putDelegate(exps[0])
+        }
+        if (exps[1] != null) {
+          exps[1].setDelegate(this)
+          this.putDelegate(exps[1])
+        }
+      }
+      child.setDelegate(this)
+      this.putDelegate(child)
+    }
+  }
+
+  // 获取表达式
+  getExp(): Expression {
+    return this.exp
+  }
+
+  // 获取对象值存储
+  getObjectNames(): JSONObject {
+    return this.objectNames
+  }
+
+  // 获取lambda外层参数名
+  getLambdaOutProps(): string[] {
+    return this.lambdaOutProps
+  }
+
+  // 存储对象值
+  put(key: string, value: any): void {
+    this.objectNames.put(key, value)
+  }
+
+  // 获取对象值
+  get(key: string): any {
+    return this.objectNames.get(key)
+  }
+
+  // 检查是否包含某个键
+  containsKey(key: string): boolean {
+    return this.objectNames.has(key)
+  }
+
+  // 获取源代码
+  getSource(): string {
+    return this.source
+  }
+
+  // 使用参数调用
+  apply(params?: JSONObject): any {
+    if (params === null) {
+      params = new JSONObject()
+    }
+    const map = this.objectNames
+    if (this.lambdaOutProps.length === 0) {
+      this.lambdaOutProps.push(...map.keySet())
+    }
+    const lambdaMap = new JSONObject(map)
+    lambdaMap.put('data', params)
+    return this.invoke(lambdaMap)
+  }
+}