wowok 2.1.10 → 2.1.13

package/dist/esm/w/call/progress.js

@@ -1,827 +1,655 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import {
-  toTxObject,
-  toTxString,
-  isValidName,
-  isValidLongName,
-  PackageAddress,
-  MAX_LONG_NAME_LENGTH,
-  MAX_NAME_LENGTH,
-  GetObjectExisted
-} from "../common.js";
+// Copyright (c) Wowok.
+// SPDX-License-Identifier: Apache-2.0
+import { toTxObject, toTxString, isValidName, isValidLongName, PackageAddress, MAX_LONG_NAME_LENGTH, MAX_NAME_LENGTH, GetObjectExisted, } from "../common.js";
 import { W_ERROR, WErrors } from "../exception.js";
 import { GetManyAccountOrMark_Address } from "../local/index.js";
 import { LocalMark } from "../local/local.js";
-import {
-  ObjectType,
-  query_objects,
-  queryTableItem_MachineNode
-} from "../query/object.js";
+import { ObjectType, query_objects, queryTableItem_MachineNode, } from "../query/object.js";
 import { validObjects } from "../util.js";
 import { CallBase } from "./base.js";
-class CallProgress extends CallBase {
-  constructor(data) {
-    super();
-    __publicField(this, "data");
-    __publicField(this, "object_address");
-    __publicField(this, "machine");
-    this.data = data;
-  }
-  async prepare(env) {
-    await super.prepare(env);
-    if (!this.object_address) {
-      this.object_address = await GetObjectExisted(this.data?.object);
-    }
-    if (this.object_address) {
-      await this.update_content(
-        env,
-        ObjectType.Progress,
-        this.object_address
-      );
-      if (!this.content) {
-        W_ERROR(
-          WErrors.InvalidParam,
-          "CallProgress_Data.data.object:" + this.object_address
-        );
-      }
-      const r = await query_objects({
-        objects: [this.content.machine],
-        no_cache: false,
-        network: env.network
-      });
-      if (!r.objects || r.objects.length !== 1 || r.objects[0].type !== ObjectType.Machine) {
-        W_ERROR(
-          WErrors.InvalidParam,
-          `fetch machine ${this.content.machine} failed`
-        );
-      }
-      this.machine = r.objects[0];
-    } else {
-      W_ERROR(
-        WErrors.InvalidParam,
-        "CallProgress_Data.data.object:" + this.data?.object
-      );
-    }
-  }
-  async call(env) {
-    await this.prepare(env);
-    const guards = [];
-    const progressObj = this.content;
-    const add_guard = (guard) => {
-      if (!guards.includes(guard)) {
-        guards.push(guard);
-      }
-    };
-    if (this.data?.operate != null) {
-      const f = await getMachineNodeForward(
-        env,
-        this.machine?.object,
-        progressObj.current,
-        this.data.operate.operation.next_node_name,
-        this.data.operate.operation.forward
-      );
-      if (f) {
-        if (f?.guard?.guard) {
-          add_guard(f.guard.guard);
+export class CallProgress extends CallBase {
+    data;
+    object_address = undefined;
+    machine = undefined;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    async prepare(env) {
+        await super.prepare(env);
+        if (!this.object_address) {
+            this.object_address = await GetObjectExisted(this.data?.object);
         }
-      } else {
-        W_ERROR(
-          WErrors.InvalidParam,
-          `CallProgress_Data.data.operate.operation.forward:${this.data?.operate.operation.forward} not found`
-        );
-      }
-    }
-    if (guards.length > 0) {
-      return await this.check_guard_and_call(env, guards);
-    }
-    return await this.exec(env);
-  }
-  async operate(env, tx, passport, submission) {
-    const content = this.content;
-    if (this.data?.task) {
-      if (content.task) {
-        W_ERROR(
-          WErrors.InvalidParam,
-          `CallProgress_Data.data.task:${this.data?.task} is set; and once set, it can not be changed`
-        );
-      }
-      const t = await LocalMark.Instance().get_address(this.data?.task);
-      if (t) {
-        task_set(
-          tx,
-          this.object_address,
-          this.machine?.object,
-          this.machine?.permission,
-          t,
-          passport
-        );
-      } else {
-        W_ERROR(
-          WErrors.InvalidParam,
-          `CallProgress_Data.data.task:${this.data?.task} invalid`
-        );
-      }
-    }
-    if (this.data?.repository) {
-      switch (this.data.repository.op) {
-        case "add":
-        case "set": {
-          if (this.data.repository.objects.length > MAX_CONTEXT_REPOSITORY_COUNT - (content?.context_repositories?.length ?? 0)) {
-            W_ERROR(
-              WErrors.InvalidParam,
-              `CallProgress_Data.data.repository.objects exceeds max count:${this.data.repository.objects}`
-            );
-          }
-          if (this.data.repository.op === "set") {
-            context_repository_clear(
-              tx,
-              this.object_address,
-              this.machine?.object,
-              this.machine?.permission
-            );
-          }
-          const r = await LocalMark.Instance().get_many_address_availables(
-            this.data.repository.objects
-          );
-          r.forEach((repo) => {
-            context_repository_add(
-              tx,
-              this.object_address,
-              this.machine?.object,
-              this.machine?.permission,
-              repo,
-              passport
-            );
-          });
-          break;
+        if (this.object_address) {
+            await this.update_content(env, ObjectType.Progress, this.object_address);
+            if (!this.content) {
+                W_ERROR(WErrors.InvalidParam, "CallProgress_Data.data.object:" + this.object_address);
+            }
+            const r = await query_objects({
+                objects: [this.content.machine],
+                no_cache: false,
+                network: env.network,
+            });
+            if (!r.objects ||
+                r.objects.length !== 1 ||
+                r.objects[0].type !== ObjectType.Machine) {
+                W_ERROR(WErrors.InvalidParam, `fetch machine ${this.content.machine} failed`);
+            }
+            this.machine = r.objects[0];
         }
-        case "remove": {
-          if (this.data.repository.objects.length > (content?.context_repositories?.length ?? 0)) {
-            W_ERROR(
-              WErrors.InvalidParam,
-              `CallProgress_Data.data.repository.objects exceeds max count:${this.data.repository.objects}`
-            );
-          }
-          const addrs = await LocalMark.Instance().get_many_address_availables(
-            this.data.repository.objects
-          );
-          context_repository_remove(
-            tx,
-            this.object_address,
-            this.machine?.object,
-            this.machine?.permission,
-            addrs,
-            passport
-          );
-          break;
+        else {
+            W_ERROR(WErrors.InvalidParam, "CallProgress_Data.data.object:" + this.data?.object);
         }
-        case "clear":
-          context_repository_clear(
-            tx,
-            this.object_address,
-            this.machine?.object,
-            this.machine?.permission,
-            passport
-          );
-          break;
-      }
-    }
-    if (this.data?.progress_namedOperator) {
-      switch (this.data.progress_namedOperator.op) {
-        case "add": {
-          const r = await GetManyAccountOrMark_Address(
-            this.data.progress_namedOperator.operators
-          );
-          namedOperator_add(
-            tx,
-            this.object_address,
-            this.machine?.object,
-            this.machine?.permission,
-            this.data.progress_namedOperator.name,
-            r,
-            passport
-          );
-          break;
+    }
+    async call(env) {
+        await this.prepare(env); // prepare first.
+        const guards = [];
+        const progressObj = this.content;
+        const add_guard = (guard) => {
+            if (!guards.includes(guard)) {
+                guards.push(guard);
+            }
+        };
+        if (this.data?.operate != null) {
+            const f = await getMachineNodeForward(env, this.machine?.object, progressObj.current, this.data.operate.operation.next_node_name, this.data.operate.operation.forward);
+            //console.dir(f, { depth: null, colors: true });
+            if (f) {
+                if (f?.guard?.guard) {
+                    //console.dir(f, { depth: null, colors: true });
+                    add_guard(f.guard.guard);
+                }
+            }
+            else {
+                W_ERROR(WErrors.InvalidParam, `CallProgress_Data.data.operate.operation.forward:${this.data?.operate.operation.forward} not found`);
+            }
         }
-        case "set": {
-          const r = await GetManyAccountOrMark_Address(
-            this.data.progress_namedOperator.operators
-          );
-          namedOperator_set(
-            tx,
-            this.object_address,
-            this.machine?.object,
-            this.machine?.permission,
-            this.data.progress_namedOperator.name,
-            r,
-            passport
-          );
-          break;
+        if (guards.length > 0) {
+            return await this.check_guard_and_call(env, guards);
         }
-        case "remove": {
-          const r = await GetManyAccountOrMark_Address(
-            this.data.progress_namedOperator.operators
-          );
-          namedOperator_remove(
-            tx,
-            this.object_address,
-            this.machine?.object,
-            this.machine?.permission,
-            this.data.progress_namedOperator.name,
-            r,
-            passport
-          );
-          break;
+        return await this.exec(env);
+    }
+    async operate(env, tx, passport, submission) {
+        const content = this.content;
+        if (this.data?.task) {
+            if (content.task) {
+                W_ERROR(WErrors.InvalidParam, `CallProgress_Data.data.task:${this.data?.task} is set; and once set, it can not be changed`);
+            }
+            const t = await LocalMark.Instance().get_address(this.data?.task);
+            if (t) {
+                task_set(tx, this.object_address, this.machine?.object, this.machine?.permission, t, passport);
+            }
+            else {
+                W_ERROR(WErrors.InvalidParam, `CallProgress_Data.data.task:${this.data?.task} invalid`);
+            }
         }
-      }
-    }
-    if (this.data.operate != null) {
-      if ("hold" in this.data.operate) {
-        if (this.data.operate.adminUnhold) {
-          adminUnhold(
-            tx,
-            this.object_address,
-            this.machine?.object,
-            this.machine?.permission,
-            this.data.operate.operation.next_node_name,
-            this.data.operate.operation.forward,
-            this.data.operate.message ?? "",
-            passport
-          );
-        } else {
-          let order = void 0;
-          if (content.task) {
-            const r = await query_objects({
-              objects: [content.task],
-              no_cache: false,
-              network: env.network
-            });
-            if (r.objects && r.objects.length === 1 && r.objects[0].type === ObjectType.Order) {
-              order = r.objects[0].object;
+        if (this.data?.repository) {
+            switch (this.data.repository.op) {
+                case "add":
+                case "set": {
+                    if (this.data.repository.objects.length >
+                        MAX_CONTEXT_REPOSITORY_COUNT -
+                            (content?.context_repositories?.length ?? 0)) {
+                        W_ERROR(WErrors.InvalidParam, `CallProgress_Data.data.repository.objects exceeds max count:${this.data.repository.objects}`);
+                    }
+                    if (this.data.repository.op === "set") {
+                        context_repository_clear(tx, this.object_address, this.machine?.object, this.machine?.permission);
+                    }
+                    const r = await LocalMark.Instance().get_many_address_availables(this.data.repository.objects);
+                    r.forEach((repo) => {
+                        context_repository_add(tx, this.object_address, this.machine?.object, this.machine?.permission, repo, passport);
+                    });
+                    break;
+                }
+                case "remove": {
+                    if (this.data.repository.objects.length >
+                        (content?.context_repositories?.length ?? 0)) {
+                        W_ERROR(WErrors.InvalidParam, `CallProgress_Data.data.repository.objects exceeds max count:${this.data.repository.objects}`);
+                    }
+                    const addrs = await LocalMark.Instance().get_many_address_availables(this.data.repository.objects);
+                    context_repository_remove(tx, this.object_address, this.machine?.object, this.machine?.permission, addrs, passport);
+                    break;
+                }
+                case "clear":
+                    context_repository_clear(tx, this.object_address, this.machine?.object, this.machine?.permission, passport);
+                    break;
+            }
+        }
+        if (this.data?.progress_namedOperator) {
+            switch (this.data.progress_namedOperator.op) {
+                case "add": {
+                    const r = await GetManyAccountOrMark_Address(this.data.progress_namedOperator.operators);
+                    namedOperator_add(tx, this.object_address, this.machine?.object, this.machine?.permission, this.data.progress_namedOperator.name, r, passport);
+                    break;
+                }
+                case "set": {
+                    const r = await GetManyAccountOrMark_Address(this.data.progress_namedOperator.operators);
+                    namedOperator_set(tx, this.object_address, this.machine?.object, this.machine?.permission, this.data.progress_namedOperator.name, r, passport);
+                    break;
+                }
+                case "remove": {
+                    const r = await GetManyAccountOrMark_Address(this.data.progress_namedOperator.operators);
+                    namedOperator_remove(tx, this.object_address, this.machine?.object, this.machine?.permission, this.data.progress_namedOperator.name, r, passport);
+                    break;
+                }
             }
-          }
-          hold(
-            tx,
-            this.object_address,
-            this.machine?.object,
-            this.machine?.permission,
-            this.data.operate.operation.next_node_name,
-            this.data.operate.operation.forward,
-            this.data.operate.message ?? "",
-            this.data.operate.hold,
-            order,
-            passport
-          );
         }
-      } else {
-        let order = void 0;
-        if (content.task) {
-          const r = await query_objects({
-            objects: [content.task],
-            no_cache: false,
-            network: env.network
-          });
-          if (r.objects && r.objects.length === 1 && r.objects[0].type === ObjectType.Order) {
-            order = r.objects[0].object;
-          }
+        if (this.data.operate != null) {
+            if ("hold" in this.data.operate) {
+                if (this.data.operate.adminUnhold) {
+                    adminUnhold(tx, this.object_address, this.machine?.object, this.machine?.permission, this.data.operate.operation.next_node_name, this.data.operate.operation.forward, this.data.operate.message ?? "", passport);
+                }
+                else {
+                    let order = undefined;
+                    if (content.task) {
+                        const r = await query_objects({
+                            objects: [content.task],
+                            no_cache: false,
+                            network: env.network,
+                        });
+                        if (r.objects &&
+                            r.objects.length === 1 &&
+                            r.objects[0].type === ObjectType.Order) {
+                            order = r.objects[0].object;
+                        }
+                    }
+                    hold(tx, this.object_address, this.machine?.object, this.machine?.permission, this.data.operate.operation.next_node_name, this.data.operate.operation.forward, this.data.operate.message ?? "", this.data.operate.hold, order, passport);
+                }
+            }
+            else {
+                let order = undefined;
+                if (content.task) {
+                    const r = await query_objects({
+                        objects: [content.task],
+                        no_cache: false,
+                        network: env.network,
+                    });
+                    if (r.objects &&
+                        r.objects.length === 1 &&
+                        r.objects[0].type === ObjectType.Order) {
+                        order = r.objects[0].object;
+                    }
+                }
+                accomplish(tx, this.object_address, this.machine?.object, this.machine?.permission, this.data.operate.operation.next_node_name, this.data.operate.operation.forward, this.data.operate.message ?? "", order, passport);
+            }
         }
-        accomplish(
-          tx,
-          this.object_address,
-          this.machine?.object,
-          this.machine?.permission,
-          this.data.operate.operation.next_node_name,
-          this.data.operate.operation.forward,
-          this.data.operate.message ?? "",
-          order,
-          passport
-        );
-      }
-    }
-  }
+    }
 }
-function progressFn(name) {
-  return `${PackageAddress}::progress::${name}`;
+// ================================================
+export function progressFn(name) {
+    return `${PackageAddress}::progress::${name}`;
 }
-const MAX_CONTEXT_REPOSITORY_COUNT = 30;
-const MAX_NAMED_OPERATOR_COUNT = 60;
-const MAX_NAMED_OPERATOR_ADDRESS_COUNT = 80;
-function newProgress(tx, machine, permission, task, passport) {
-  validObjects([machine, permission, task, passport]);
-  if (passport) {
-    return tx.moveCall({
-      target: progressFn("new_with_passport"),
-      arguments: [
-        toTxObject(tx, machine),
-        toTxObject(tx, permission),
-        passport,
-        tx.pure.option("address", task),
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ]
-    });
-  } else {
+// ================================================
+// 常量定义
+export const MAX_CONTEXT_REPOSITORY_COUNT = 30;
+export const MAX_NAMED_OPERATOR_COUNT = 60;
+export const MAX_NAMED_OPERATOR_ADDRESS_COUNT = 80;
+// ================================================
+// 公共函数调用
+export function newProgress(tx, machine, permission, task, passport) {
+    validObjects([machine, permission, task, passport]);
+    if (passport) {
+        return tx.moveCall({
+            target: progressFn("new_with_passport"),
+            arguments: [
+                toTxObject(tx, machine),
+                toTxObject(tx, permission),
+                passport,
+                tx.pure.option("address", task),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+        });
+    }
+    else {
+        return tx.moveCall({
+            target: progressFn("new"),
+            arguments: [
+                toTxObject(tx, machine),
+                toTxObject(tx, permission),
+                tx.pure.option("address", task),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+        });
+    }
+}
+export function create(tx, progress) {
+    validObjects([progress]);
     return tx.moveCall({
-      target: progressFn("new"),
-      arguments: [
-        toTxObject(tx, machine),
-        toTxObject(tx, permission),
-        tx.pure.option("address", task),
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ]
+        target: progressFn("create"),
+        arguments: [toTxObject(tx, progress)],
     });
-  }
 }
-function create(tx, progress) {
-  validObjects([progress]);
-  return tx.moveCall({
-    target: progressFn("create"),
-    arguments: [toTxObject(tx, progress)]
-  });
-}
-function namedOperator_add(tx, progress, machine, permission, name, operators, passport) {
-  if (operators.length === 0) {
-    return;
-  }
-  if (operators.length > MAX_NAMED_OPERATOR_ADDRESS_COUNT) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Named operator address count ${operators.length} is not valid`
-    );
-  }
-  validObjects([progress, machine, permission, passport, ...operators]);
-  if (!isValidName(name)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Named operator name ${name} is not valid`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: progressFn("namedOperator_add_with_passport"),
-      arguments: [
-        toTxObject(tx, progress),
-        toTxObject(tx, machine),
-        toTxObject(tx, permission),
-        toTxObject(tx, passport),
-        toTxString(tx, name),
-        tx.pure.vector("address", operators)
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: progressFn("namedOperator_add"),
-      arguments: [
-        toTxObject(tx, progress),
-        toTxObject(tx, machine),
-        toTxObject(tx, permission),
-        toTxString(tx, name),
-        tx.pure.vector("address", operators)
-      ]
-    });
-  }
+export function namedOperator_add(tx, progress, machine, permission, name, operators, passport) {
+    if (operators.length === 0) {
+        return;
+    }
+    if (operators.length > MAX_NAMED_OPERATOR_ADDRESS_COUNT) {
+        W_ERROR(WErrors.InvalidParam, `Named operator address count ${operators.length} is not valid`);
+    }
+    validObjects([progress, machine, permission, passport, ...operators]);
+    if (!isValidName(name)) {
+        W_ERROR(WErrors.InvalidParam, `Named operator name ${name} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: progressFn("namedOperator_add_with_passport"),
+            arguments: [
+                toTxObject(tx, progress),
+                toTxObject(tx, machine),
+                toTxObject(tx, permission),
+                toTxObject(tx, passport),
+                toTxString(tx, name),
+                tx.pure.vector("address", operators),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: progressFn("namedOperator_add"),
+            arguments: [
+                toTxObject(tx, progress),
+                toTxObject(tx, machine),
+                toTxObject(tx, permission),
+                toTxString(tx, name),
+                tx.pure.vector("address", operators),
+            ],
+        });
+    }
 }
-function namedOperator_remove(tx, progress, machine, permission, name, operators, passport) {
-  if (operators.length === 0) {
-    return;
-  }
-  if (operators.length > MAX_NAMED_OPERATOR_ADDRESS_COUNT) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Named operator address count ${operators.length} is not valid`
-    );
-  }
-  validObjects([progress, machine, permission, passport, ...operators]);
-  if (!isValidName(name)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Named operator name ${name} is not valid`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: progressFn("namedOperator_remove_with_passport"),
-      arguments: [
-        toTxObject(tx, progress),
-        toTxObject(tx, machine),
-        toTxObject(tx, permission),
-        toTxObject(tx, passport),
-        toTxString(tx, name),
-        tx.pure.vector("address", operators)
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: progressFn("namedOperator_remove"),
-      arguments: [
-        toTxObject(tx, progress),
-        toTxObject(tx, machine),
-        toTxObject(tx, permission),
-        toTxString(tx, name),
-        tx.pure.vector("address", operators)
-      ]
-    });
-  }
+export function namedOperator_remove(tx, progress, machine, permission, name, operators, passport) {
+    if (operators.length === 0) {
+        return;
+    }
+    if (operators.length > MAX_NAMED_OPERATOR_ADDRESS_COUNT) {
+        W_ERROR(WErrors.InvalidParam, `Named operator address count ${operators.length} is not valid`);
+    }
+    validObjects([progress, machine, permission, passport, ...operators]);
+    if (!isValidName(name)) {
+        W_ERROR(WErrors.InvalidParam, `Named operator name ${name} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: progressFn("namedOperator_remove_with_passport"),
+            arguments: [
+                toTxObject(tx, progress),
+                toTxObject(tx, machine),
+                toTxObject(tx, permission),
+                toTxObject(tx, passport),
+                toTxString(tx, name),
+                tx.pure.vector("address", operators),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: progressFn("namedOperator_remove"),
+            arguments: [
+                toTxObject(tx, progress),
+                toTxObject(tx, machine),
+                toTxObject(tx, permission),
+                toTxString(tx, name),
+                tx.pure.vector("address", operators),
+            ],
+        });
+    }
 }
-function namedOperator_set(tx, progress, machine, permission, name, operators, passport) {
-  validObjects([progress, machine, permission, passport, ...operators]);
-  if (operators.length > MAX_NAMED_OPERATOR_ADDRESS_COUNT) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Named operator address count ${operators.length} is not valid`
-    );
-  }
-  if (!isValidName(name)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Named operator name ${name} is not valid`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: progressFn("namedOperator_set_with_passport"),
-      arguments: [
-        toTxObject(tx, progress),
-        toTxObject(tx, machine),
-        toTxObject(tx, permission),
-        toTxObject(tx, passport),
-        toTxString(tx, name),
-        tx.pure.vector("address", operators)
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: progressFn("namedOperator_set"),
-      arguments: [
-        toTxObject(tx, progress),
-        toTxObject(tx, machine),
-        toTxObject(tx, permission),
-        toTxString(tx, name),
-        tx.pure.vector("address", operators)
-      ]
-    });
-  }
+export function namedOperator_set(tx, progress, machine, permission, name, operators, passport) {
+    validObjects([progress, machine, permission, passport, ...operators]);
+    if (operators.length > MAX_NAMED_OPERATOR_ADDRESS_COUNT) {
+        W_ERROR(WErrors.InvalidParam, `Named operator address count ${operators.length} is not valid`);
+    }
+    if (!isValidName(name)) {
+        W_ERROR(WErrors.InvalidParam, `Named operator name ${name} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: progressFn("namedOperator_set_with_passport"),
+            arguments: [
+                toTxObject(tx, progress),
+                toTxObject(tx, machine),
+                toTxObject(tx, permission),
+                toTxObject(tx, passport),
+                toTxString(tx, name),
+                tx.pure.vector("address", operators),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: progressFn("namedOperator_set"),
+            arguments: [
+                toTxObject(tx, progress),
+                toTxObject(tx, machine),
+                toTxObject(tx, permission),
+                toTxString(tx, name),
+                tx.pure.vector("address", operators),
+            ],
+        });
+    }
 }
-function task_set(tx, progress, machine, permission, task, passport) {
-  validObjects([progress, machine, permission, passport, task]);
-  if (passport) {
-    tx.moveCall({
-      target: progressFn("task_set_with_passport"),
-      arguments: [
-        toTxObject(tx, progress),
-        toTxObject(tx, machine),
-        toTxObject(tx, permission),
-        toTxObject(tx, passport),
-        tx.pure.address(task)
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: progressFn("task_set"),
-      arguments: [
-        toTxObject(tx, progress),
-        toTxObject(tx, machine),
-        toTxObject(tx, permission),
-        tx.pure.address(task)
-      ]
-    });
-  }
+export function task_set(tx, progress, machine, permission, task, passport) {
+    validObjects([progress, machine, permission, passport, task]);
+    if (passport) {
+        tx.moveCall({
+            target: progressFn("task_set_with_passport"),
+            arguments: [
+                toTxObject(tx, progress),
+                toTxObject(tx, machine),
+                toTxObject(tx, permission),
+                toTxObject(tx, passport),
+                tx.pure.address(task),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: progressFn("task_set"),
+            arguments: [
+                toTxObject(tx, progress),
+                toTxObject(tx, machine),
+                toTxObject(tx, permission),
+                tx.pure.address(task),
+            ],
+        });
+    }
 }
-function context_repository_add(tx, progress, machine, permission, repository, passport) {
-  validObjects([progress, machine, permission, passport, repository]);
-  if (passport) {
-    tx.moveCall({
-      target: progressFn("context_repository_add_with_passport"),
-      arguments: [
-        toTxObject(tx, progress),
-        toTxObject(tx, machine),
-        toTxObject(tx, permission),
-        toTxObject(tx, passport),
-        toTxObject(tx, repository),
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: progressFn("context_repository_add"),
-      arguments: [
-        toTxObject(tx, progress),
-        toTxObject(tx, machine),
-        toTxObject(tx, permission),
-        toTxObject(tx, repository),
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ]
-    });
-  }
+export function context_repository_add(tx, progress, machine, permission, repository, passport) {
+    validObjects([progress, machine, permission, passport, repository]);
+    if (passport) {
+        tx.moveCall({
+            target: progressFn("context_repository_add_with_passport"),
+            arguments: [
+                toTxObject(tx, progress),
+                toTxObject(tx, machine),
+                toTxObject(tx, permission),
+                toTxObject(tx, passport),
+                toTxObject(tx, repository),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: progressFn("context_repository_add"),
+            arguments: [
+                toTxObject(tx, progress),
+                toTxObject(tx, machine),
+                toTxObject(tx, permission),
+                toTxObject(tx, repository),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+        });
+    }
 }
-function context_repository_remove(tx, progress, machine, permission, repositories, passport) {
-  validObjects([progress, machine, permission, passport, ...repositories]);
-  if (passport) {
-    tx.moveCall({
-      target: progressFn("context_repository_remove_with_passport"),
-      arguments: [
-        toTxObject(tx, progress),
-        toTxObject(tx, machine),
-        toTxObject(tx, permission),
-        toTxObject(tx, passport),
-        tx.pure.vector("address", repositories),
-        tx.object.mutRegistrar()
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: progressFn("context_repository_remove"),
-      arguments: [
-        toTxObject(tx, progress),
-        toTxObject(tx, machine),
-        toTxObject(tx, permission),
-        tx.pure.vector("address", repositories),
-        tx.object.mutRegistrar()
-      ]
-    });
-  }
+export function context_repository_remove(tx, progress, machine, permission, repositories, passport) {
+    validObjects([progress, machine, permission, passport, ...repositories]);
+    if (passport) {
+        tx.moveCall({
+            target: progressFn("context_repository_remove_with_passport"),
+            arguments: [
+                toTxObject(tx, progress),
+                toTxObject(tx, machine),
+                toTxObject(tx, permission),
+                toTxObject(tx, passport),
+                tx.pure.vector("address", repositories),
+                tx.object.mutRegistrar(),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: progressFn("context_repository_remove"),
+            arguments: [
+                toTxObject(tx, progress),
+                toTxObject(tx, machine),
+                toTxObject(tx, permission),
+                tx.pure.vector("address", repositories),
+                tx.object.mutRegistrar(),
+            ],
+        });
+    }
 }
-function context_repository_clear(tx, progress, machine, permission, passport) {
-  validObjects([progress, machine, permission, passport]);
-  if (passport) {
-    tx.moveCall({
-      target: progressFn("context_repository_clear_with_passport"),
-      arguments: [
-        toTxObject(tx, progress),
-        toTxObject(tx, machine),
-        toTxObject(tx, permission),
-        toTxObject(tx, passport),
-        tx.object.mutRegistrar()
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: progressFn("context_repository_clear"),
-      arguments: [
-        toTxObject(tx, progress),
-        toTxObject(tx, machine),
-        toTxObject(tx, permission),
-        tx.object.mutRegistrar()
-      ]
-    });
-  }
+export function context_repository_clear(tx, progress, machine, permission, passport) {
+    validObjects([progress, machine, permission, passport]);
+    if (passport) {
+        tx.moveCall({
+            target: progressFn("context_repository_clear_with_passport"),
+            arguments: [
+                toTxObject(tx, progress),
+                toTxObject(tx, machine),
+                toTxObject(tx, permission),
+                toTxObject(tx, passport),
+                tx.object.mutRegistrar(),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: progressFn("context_repository_clear"),
+            arguments: [
+                toTxObject(tx, progress),
+                toTxObject(tx, machine),
+                toTxObject(tx, permission),
+                tx.object.mutRegistrar(),
+            ],
+        });
+    }
 }
-function hold(tx, progress, machine, permission, next_node, forward, message, bHold, order, passport) {
-  validObjects([progress, machine, permission, passport, order]);
-  if (!next_node || !isValidName(next_node)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Next node ${next_node} is exceeds maximum length ${MAX_NAME_LENGTH}`
-    );
-  }
-  if (forward && !isValidName(forward)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Forward ${forward} is exceeds maximum length ${MAX_NAME_LENGTH}`
-    );
-  }
-  if (!isValidLongName(message)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Message ${message} is exceeds maximum length ${MAX_LONG_NAME_LENGTH}`
-    );
-  }
-  if (passport) {
-    if (order) {
-      tx.moveCall({
-        target: progressFn("order_hold_with_passport"),
-        arguments: [
-          toTxObject(tx, progress),
-          toTxObject(tx, machine),
-          toTxObject(tx, permission),
-          passport,
-          toTxObject(tx, order),
-          toTxString(tx, next_node),
-          toTxString(tx, forward),
-          tx.pure.bool(bHold),
-          toTxString(tx, message),
-          tx.object.clock()
-        ]
-      });
-    } else {
-      tx.moveCall({
-        target: progressFn("hold_with_passport"),
-        arguments: [
-          toTxObject(tx, progress),
-          toTxObject(tx, machine),
-          toTxObject(tx, permission),
-          passport,
-          toTxString(tx, next_node),
-          toTxString(tx, forward),
-          tx.pure.bool(bHold),
-          toTxString(tx, message),
-          tx.object.clock()
-        ]
-      });
-    }
-  } else {
-    if (order) {
-      tx.moveCall({
-        target: progressFn("order_hold"),
-        arguments: [
-          toTxObject(tx, progress),
-          toTxObject(tx, machine),
-          toTxObject(tx, permission),
-          toTxObject(tx, order),
-          toTxString(tx, next_node),
-          toTxString(tx, forward),
-          tx.pure.bool(bHold),
-          toTxString(tx, message),
-          tx.object.clock()
-        ]
-      });
-    } else {
-      tx.moveCall({
-        target: progressFn("hold"),
-        arguments: [
-          toTxObject(tx, progress),
-          toTxObject(tx, machine),
-          toTxObject(tx, permission),
-          toTxString(tx, next_node),
-          toTxString(tx, forward),
-          tx.pure.bool(bHold),
-          toTxString(tx, message),
-          tx.object.clock()
-        ]
-      });
-    }
-  }
+export function hold(tx, progress, machine, permission, next_node, forward, message, bHold, order, passport) {
+    validObjects([progress, machine, permission, passport, order]);
+    if (!next_node || !isValidName(next_node)) {
+        W_ERROR(WErrors.InvalidParam, `Next node ${next_node} is exceeds maximum length ${MAX_NAME_LENGTH}`);
+    }
+    if (forward && !isValidName(forward)) {
+        W_ERROR(WErrors.InvalidParam, `Forward ${forward} is exceeds maximum length ${MAX_NAME_LENGTH}`);
+    }
+    if (!isValidLongName(message)) {
+        W_ERROR(WErrors.InvalidParam, `Message ${message} is exceeds maximum length ${MAX_LONG_NAME_LENGTH}`);
+    }
+    if (passport) {
+        if (order) {
+            tx.moveCall({
+                target: progressFn("order_hold_with_passport"),
+                arguments: [
+                    toTxObject(tx, progress),
+                    toTxObject(tx, machine),
+                    toTxObject(tx, permission),
+                    passport,
+                    toTxObject(tx, order),
+                    toTxString(tx, next_node),
+                    toTxString(tx, forward),
+                    tx.pure.bool(bHold),
+                    toTxString(tx, message),
+                    tx.object.clock(),
+                ],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: progressFn("hold_with_passport"),
+                arguments: [
+                    toTxObject(tx, progress),
+                    toTxObject(tx, machine),
+                    toTxObject(tx, permission),
+                    passport,
+                    toTxString(tx, next_node),
+                    toTxString(tx, forward),
+                    tx.pure.bool(bHold),
+                    toTxString(tx, message),
+                    tx.object.clock(),
+                ],
+            });
+        }
+    }
+    else {
+        if (order) {
+            tx.moveCall({
+                target: progressFn("order_hold"),
+                arguments: [
+                    toTxObject(tx, progress),
+                    toTxObject(tx, machine),
+                    toTxObject(tx, permission),
+                    toTxObject(tx, order),
+                    toTxString(tx, next_node),
+                    toTxString(tx, forward),
+                    tx.pure.bool(bHold),
+                    toTxString(tx, message),
+                    tx.object.clock(),
+                ],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: progressFn("hold"),
+                arguments: [
+                    toTxObject(tx, progress),
+                    toTxObject(tx, machine),
+                    toTxObject(tx, permission),
+                    toTxString(tx, next_node),
+                    toTxString(tx, forward),
+                    tx.pure.bool(bHold),
+                    toTxString(tx, message),
+                    tx.object.clock(),
+                ],
+            });
+        }
+    }
 }
-function adminUnhold(tx, progress, machine, permission, next_node, forward, message, passport) {
-  validObjects([progress, machine, permission, passport]);
-  if (!next_node || !isValidName(next_node)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Next node ${next_node} is exceeds maximum length ${MAX_NAME_LENGTH}`
-    );
-  }
-  if (forward && !isValidName(forward)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Forward ${forward} is exceeds maximum length ${MAX_NAME_LENGTH}`
-    );
-  }
-  if (!isValidLongName(message)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Message ${message} is exceeds maximum length ${MAX_LONG_NAME_LENGTH}`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: progressFn("unhold_with_passport"),
-      arguments: [
-        toTxObject(tx, progress),
-        toTxObject(tx, passport),
-        toTxObject(tx, machine),
-        toTxObject(tx, permission),
-        passport,
-        toTxString(tx, next_node),
-        toTxString(tx, forward),
-        toTxString(tx, message),
-        tx.object.clock()
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: progressFn("unhold"),
-      arguments: [
-        toTxObject(tx, progress),
-        toTxObject(tx, machine),
-        toTxObject(tx, permission),
-        toTxString(tx, next_node),
-        toTxString(tx, forward),
-        toTxString(tx, message),
-        tx.object.clock()
-      ]
-    });
-  }
+export function adminUnhold(tx, progress, machine, permission, next_node, forward, message, passport) {
+    validObjects([progress, machine, permission, passport]);
+    if (!next_node || !isValidName(next_node)) {
+        W_ERROR(WErrors.InvalidParam, `Next node ${next_node} is exceeds maximum length ${MAX_NAME_LENGTH}`);
+    }
+    if (forward && !isValidName(forward)) {
+        W_ERROR(WErrors.InvalidParam, `Forward ${forward} is exceeds maximum length ${MAX_NAME_LENGTH}`);
+    }
+    if (!isValidLongName(message)) {
+        W_ERROR(WErrors.InvalidParam, `Message ${message} is exceeds maximum length ${MAX_LONG_NAME_LENGTH}`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: progressFn("unhold_with_passport"),
+            arguments: [
+                toTxObject(tx, progress),
+                toTxObject(tx, passport),
+                toTxObject(tx, machine),
+                toTxObject(tx, permission),
+                passport,
+                toTxString(tx, next_node),
+                toTxString(tx, forward),
+                toTxString(tx, message),
+                tx.object.clock(),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: progressFn("unhold"),
+            arguments: [
+                toTxObject(tx, progress),
+                toTxObject(tx, machine),
+                toTxObject(tx, permission),
+                toTxString(tx, next_node),
+                toTxString(tx, forward),
+                toTxString(tx, message),
+                tx.object.clock(),
+            ],
+        });
+    }
 }
-function accomplish(tx, progress, machine, permission, next_node, forward, message, order, passport) {
-  validObjects([progress, machine, permission, passport, order]);
-  if (!isValidName(next_node)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Next node ${next_node} is exceeds maximum length ${MAX_NAME_LENGTH}`
-    );
-  }
-  if (forward && !isValidName(forward)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Forward ${forward} is exceeds maximum length ${MAX_NAME_LENGTH}`
-    );
-  }
-  if (!isValidLongName(message)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Message ${message} is exceeds maximum length ${MAX_LONG_NAME_LENGTH}`
-    );
-  }
-  if (passport) {
-    if (order) {
-      tx.moveCall({
-        target: progressFn("order_next_with_passport"),
-        arguments: [
-          toTxObject(tx, progress),
-          toTxObject(tx, machine),
-          toTxObject(tx, permission),
-          toTxObject(tx, passport),
-          toTxObject(tx, order),
-          toTxString(tx, next_node),
-          toTxString(tx, forward),
-          toTxString(tx, message),
-          tx.object.clock()
-        ]
-      });
-    } else {
-      tx.moveCall({
-        target: progressFn("next_with_passport"),
-        arguments: [
-          toTxObject(tx, progress),
-          toTxObject(tx, machine),
-          toTxObject(tx, permission),
-          toTxObject(tx, passport),
-          toTxString(tx, next_node),
-          toTxString(tx, forward),
-          toTxString(tx, message),
-          tx.object.clock()
-        ]
-      });
-    }
-  } else {
-    if (order) {
-      tx.moveCall({
-        target: progressFn("order_next"),
-        arguments: [
-          toTxObject(tx, progress),
-          toTxObject(tx, machine),
-          toTxObject(tx, permission),
-          toTxObject(tx, order),
-          toTxString(tx, next_node),
-          toTxString(tx, forward),
-          toTxString(tx, message),
-          tx.object.clock()
-        ]
-      });
-    } else {
-      tx.moveCall({
-        target: progressFn("next"),
-        arguments: [
-          toTxObject(tx, progress),
-          toTxObject(tx, machine),
-          toTxObject(tx, permission),
-          toTxString(tx, next_node),
-          toTxString(tx, forward),
-          toTxString(tx, message),
-          tx.object.clock()
-        ]
-      });
-    }
-  }
+export function accomplish(tx, progress, machine, permission, next_node, forward, message, order, passport) {
+    validObjects([progress, machine, permission, passport, order]);
+    if (!isValidName(next_node)) {
+        W_ERROR(WErrors.InvalidParam, `Next node ${next_node} is exceeds maximum length ${MAX_NAME_LENGTH}`);
+    }
+    if (forward && !isValidName(forward)) {
+        W_ERROR(WErrors.InvalidParam, `Forward ${forward} is exceeds maximum length ${MAX_NAME_LENGTH}`);
+    }
+    if (!isValidLongName(message)) {
+        W_ERROR(WErrors.InvalidParam, `Message ${message} is exceeds maximum length ${MAX_LONG_NAME_LENGTH}`);
+    }
+    if (passport) {
+        if (order) {
+            tx.moveCall({
+                target: progressFn("order_next_with_passport"),
+                arguments: [
+                    toTxObject(tx, progress),
+                    toTxObject(tx, machine),
+                    toTxObject(tx, permission),
+                    toTxObject(tx, passport),
+                    toTxObject(tx, order),
+                    toTxString(tx, next_node),
+                    toTxString(tx, forward),
+                    toTxString(tx, message),
+                    tx.object.clock(),
+                ],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: progressFn("next_with_passport"),
+                arguments: [
+                    toTxObject(tx, progress),
+                    toTxObject(tx, machine),
+                    toTxObject(tx, permission),
+                    toTxObject(tx, passport),
+                    toTxString(tx, next_node),
+                    toTxString(tx, forward),
+                    toTxString(tx, message),
+                    tx.object.clock(),
+                ],
+            });
+        }
+    }
+    else {
+        if (order) {
+            tx.moveCall({
+                target: progressFn("order_next"),
+                arguments: [
+                    toTxObject(tx, progress),
+                    toTxObject(tx, machine),
+                    toTxObject(tx, permission),
+                    toTxObject(tx, order),
+                    toTxString(tx, next_node),
+                    toTxString(tx, forward),
+                    toTxString(tx, message),
+                    tx.object.clock(),
+                ],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: progressFn("next"),
+                arguments: [
+                    toTxObject(tx, progress),
+                    toTxObject(tx, machine),
+                    toTxObject(tx, permission),
+                    toTxString(tx, next_node),
+                    toTxString(tx, forward),
+                    toTxString(tx, message),
+                    tx.object.clock(),
+                ],
+            });
+        }
+    }
 }
-async function getMachineNodeForward(env, machine, node, next_node, forward) {
-  const r = await queryTableItem_MachineNode({
-    parent: machine,
-    key: next_node,
-    no_cache: env.no_cache,
-    network: env.network
-  });
-  if (r && r.type === ObjectType.TableItem_MachineNode) {
-    const n = r;
-    const pair = n.value.find((item) => item.prev_node === node);
-    if (pair) {
-      return pair.forwards.find((item) => item.name === forward);
-    }
-  }
-  return void 0;
+export async function getMachineNodeForward(env, machine, node, next_node, forward) {
+    const r = await queryTableItem_MachineNode({
+        parent: machine,
+        key: next_node,
+        no_cache: env.no_cache,
+        network: env.network,
+    });
+    if (r && r.type === ObjectType.TableItem_MachineNode) {
+        const n = r;
+        const pair = n.value.find((item) => item.prev_node === node);
+        if (pair) {
+            return pair.forwards.find((item) => item.name === forward);
+        }
+    }
+    return undefined;
 }
-export {
-  CallProgress,
-  MAX_CONTEXT_REPOSITORY_COUNT,
-  MAX_NAMED_OPERATOR_ADDRESS_COUNT,
-  MAX_NAMED_OPERATOR_COUNT,
-  accomplish,
-  adminUnhold,
-  context_repository_add,
-  context_repository_clear,
-  context_repository_remove,
-  create,
-  getMachineNodeForward,
-  hold,
-  namedOperator_add,
-  namedOperator_remove,
-  namedOperator_set,
-  newProgress,
-  progressFn,
-  task_set
-};
+//# sourceMappingURL=progress.js.map