wowok 1.8.3 → 2.1.9

package/dist/cjs/w/call/personal.d.ts

@@ -0,0 +1,51 @@
+import type { Transaction } from "../../transactions/Transaction.js";
+import type { CallEnv, PassportObject } from "../common.js";
+import type { AccountOrMark_Address, ManyAccountOrMark_Address } from "../local/index.js";
+import type { CallResult } from "./base.js";
+import { CallBase } from "./base.js";
+import type { RecordsInEntity } from "./entity.js";
+import type { GuardSubmissionToFill } from "./guard.js";
+export interface CallPersonal_Data {
+    description?: string;
+    referrer?: AccountOrMark_Address | null;
+    information?: {
+        op: "add";
+        data: RecordsInEntity[];
+    } | {
+        op: "remove";
+        name: string[];
+    } | {
+        op: "clear";
+    };
+    mark?: {
+        op: "add";
+        data: {
+            address: AccountOrMark_Address;
+            name?: string;
+            tags?: string[];
+        }[];
+    } | {
+        op: "remove";
+        data: {
+            address: AccountOrMark_Address;
+            tags?: string[];
+        }[];
+    } | {
+        op: "clear";
+        address: ManyAccountOrMark_Address;
+    } | {
+        op: "transfer";
+        to: AccountOrMark_Address;
+    } | {
+        op: "replace";
+        new_mark_object: string;
+    } | {
+        op: "destroy";
+    };
+}
+export declare class CallPersonal extends CallBase {
+    data: CallPersonal_Data;
+    constructor(data: CallPersonal_Data);
+    call(env: CallEnv): Promise<CallResult>;
+    operate(env: CallEnv, tx: Transaction, _passport?: PassportObject, _submission?: GuardSubmissionToFill[]): Promise<void>;
+}

package/dist/cjs/w/call/personal.js

@@ -0,0 +1,184 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var personal_exports = {};
+__export(personal_exports, {
+  CallPersonal: () => CallPersonal
+});
+module.exports = __toCommonJS(personal_exports);
+var import_common = require("../common.js");
+var import_exception = require("../exception.js");
+var import_local = require("../local/index.js");
+var import_local2 = require("../local/local.js");
+var import_object = require("../query/object.js");
+var import_base = require("./base.js");
+var import_entity = require("./entity.js");
+var import_resource = require("./resource.js");
+var import_resource2 = require("./resource.js");
+var import_util = require("./util.js");
+class CallPersonal extends import_base.CallBase {
+  constructor(data) {
+    super();
+    __publicField(this, "data");
+    this.data = data;
+  }
+  async call(env) {
+    return await this.exec(env);
+  }
+  async operate(env, tx, _passport, _submission) {
+    await super.prepare(env);
+    let referrer;
+    if (this.data.referrer != null) {
+      referrer = await (0, import_local.GetAccountOrMark_Address)(this.data.referrer);
+    }
+    if (this.data.description != null) {
+      if (!(0, import_common.isValidDescription)(this.data.description)) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.IsValidDescription,
+          `CallPersonal_Data description excceed max length ${import_common.MAX_DESCRIPTION_LENGTH}`
+        );
+      }
+    }
+    if (this.data?.information != null) {
+      switch (this.data.information.op) {
+        case "add": {
+          await (0, import_entity.info_add)(
+            tx,
+            this.data.information.data,
+            this.data.description,
+            referrer
+          );
+          break;
+        }
+        case "remove": {
+          (0, import_entity.info_remove)(tx, this.data.information.name);
+          break;
+        }
+        case "clear": {
+          (0, import_entity.info_clear)(tx);
+          break;
+        }
+      }
+    } else if (this.data.description != null) {
+      (0, import_entity.description_set)(tx, this.data.description, referrer);
+    }
+    if (this.data.mark != null) {
+      if (this.data.mark.op === "destroy" || this.data.mark.op === "transfer") {
+        const entity = await (0, import_object.queryTableItem_EntityRegistrar)({
+          address: await (0, import_util.getCallEnvAccount)(env),
+          no_cache: env.no_cache,
+          network: env.network
+        });
+        if (this.data.mark.op === "destroy" && entity && entity.mark_object) {
+          (0, import_entity.resource_destroy)(tx, entity.mark_object);
+        }
+        if (this.data.mark.op === "transfer" && entity && entity.mark_object) {
+          const addr = await (0, import_local.GetAccountOrMark_Address)(
+            this.data.mark.to
+          );
+          if (addr) {
+            (0, import_entity.resource_transfer)(tx, entity.mark_object, addr);
+          } else {
+            (0, import_exception.W_ERROR)(
+              import_exception.WErrors.IsValidAddress,
+              `CallPersonal_Data mark transfer to address ${this.data.mark.to} is invalid`
+            );
+          }
+        }
+      } else if (this.data.mark.op === "replace") {
+        const r = await import_local2.LocalMark.Instance().get_address(
+          this.data.mark.new_mark_object
+        );
+        if (r) {
+          (0, import_entity.resource_use)(tx, r, referrer ?? null);
+        } else {
+          (0, import_exception.W_ERROR)(
+            import_exception.WErrors.IsValidAddress,
+            `CallPersonal_Data mark replace to address ${this.data.mark.new_mark_object} is invalid`
+          );
+        }
+      } else {
+        const entity = await (0, import_object.queryTableItem_EntityRegistrar)({
+          address: await (0, import_util.getCallEnvAccount)(env),
+          no_cache: env.no_cache,
+          network: env.network
+        });
+        let resource = entity?.mark_object;
+        if (!resource) {
+          resource = (0, import_entity.register_with_resource_forced)(
+            tx,
+            referrer ?? null
+          );
+        }
+        if (!resource) {
+          (0, import_exception.W_ERROR)(
+            import_exception.WErrors.IsValidAddress,
+            `CallPersonal_Data mark fetch/launch resource failed`
+          );
+        }
+        switch (this.data.mark.op) {
+          case "add": {
+            const markData = this.data.mark;
+            if ("data" in markData) {
+              for (const v of markData.data) {
+                const addr = await (0, import_local.GetAccountOrMark_Address)(
+                  v.address
+                );
+                (0, import_resource.addObjectTags)(tx, resource, {
+                  address: addr,
+                  nick: v.name,
+                  tags: v.tags ?? []
+                });
+              }
+            }
+            break;
+          }
+          case "remove": {
+            const markData = this.data.mark;
+            if ("data" in markData) {
+              for (const v of markData.data) {
+                const addr = await (0, import_local.GetAccountOrMark_Address)(
+                  v.address
+                );
+                (0, import_resource.removeObjectTags)(tx, resource, {
+                  address: addr,
+                  tags: v.tags ?? []
+                });
+              }
+            }
+            break;
+          }
+          case "clear": {
+            const addresses = await (0, import_local.GetManyAccountOrMark_Address)(
+              this.data.mark.address
+            );
+            addresses.forEach((addr) => {
+              (0, import_resource.removeObject)(tx, resource, addr);
+            });
+            break;
+          }
+        }
+        if (!entity?.mark_object && resource) {
+          (0, import_resource2.create)(tx, resource);
+        }
+      }
+    }
+  }
+}

package/dist/cjs/w/call/progress.d.ts

@@ -0,0 +1,94 @@
+import type { Transaction } from "../../transactions/index.js";
+import type { ProgressObject, ProgressAddress, PassportObject, PermissionObject, MachineObject, RepositoryObject, CallEnv } from "../common.js";
+import type { ManyAccountOrMark_Address } from "../local/index.js";
+import type { ObjectMachine, MachineForward } from "../query/object.js";
+import type { CallResult } from "./base.js";
+import { CallBase } from "./base.js";
+import type { GuardSubmissionToFill } from "./guard.js";
+export type ProgressNext = {
+    next_node_name: string;
+    forward: string;
+};
+export interface CallProgress_Data {
+    object: string;
+    task?: string;
+    repository?: {
+        op: "add" | "set";
+        objects: string[];
+    } | {
+        op: "remove";
+        objects: string[];
+    } | {
+        op: "clear";
+    };
+    progress_namedOperator?: {
+        op: "add" | "set" | "remove";
+        name: string;
+        operators: ManyAccountOrMark_Address;
+    };
+    operate?: {
+        operation: ProgressNext;
+        hold: boolean;
+        adminUnhold?: boolean;
+        message?: string;
+    } | {
+        operation: ProgressNext;
+        message?: string;
+    };
+}
+export declare class CallProgress extends CallBase {
+    data: CallProgress_Data;
+    object_address: string | undefined;
+    machine: ObjectMachine | undefined;
+    constructor(data: CallProgress_Data);
+    protected prepare(env: CallEnv): Promise<void>;
+    call(env: CallEnv): Promise<CallResult>;
+    operate(env: CallEnv, tx: Transaction, passport?: PassportObject, submission?: GuardSubmissionToFill[]): Promise<void>;
+}
+export declare function progressFn(name: string): string;
+export declare const MAX_CONTEXT_REPOSITORY_COUNT = 30;
+export declare const MAX_NAMED_OPERATOR_COUNT = 60;
+export declare const MAX_NAMED_OPERATOR_ADDRESS_COUNT = 80;
+export interface Holder {
+    forward: string;
+    who?: string;
+    retained_submission: any[];
+    msg: string;
+    accomplished: boolean;
+    time: number | bigint | string;
+}
+export interface Session {
+    next_node: string;
+    forwards: Holder[];
+    weights: number;
+    threshold: number;
+}
+export interface History {
+    node: string;
+    next_node: string;
+    session: Session[];
+    time: number | bigint | string;
+}
+export interface NamedOperator {
+    name: string;
+    operators: string[];
+}
+export interface ProgressEvent {
+    object: string;
+    machine: string;
+    task?: string;
+    node: string;
+}
+export declare function newProgress(tx: Transaction, machine: MachineObject, permission: PermissionObject, task: string | null, passport?: PassportObject): ProgressObject;
+export declare function create(tx: Transaction, progress: ProgressObject): ProgressAddress;
+export declare function namedOperator_add(tx: Transaction, progress: ProgressObject, machine: MachineObject, permission: PermissionObject, name: string, operators: string[], passport?: PassportObject): void;
+export declare function namedOperator_remove(tx: Transaction, progress: ProgressObject, machine: MachineObject, permission: PermissionObject, name: string, operators: string[], passport?: PassportObject): void;
+export declare function namedOperator_set(tx: Transaction, progress: ProgressObject, machine: MachineObject, permission: PermissionObject, name: string, operators: string[], passport?: PassportObject): void;
+export declare function task_set(tx: Transaction, progress: ProgressObject, machine: MachineObject, permission: PermissionObject, task: string, passport?: PassportObject): void;
+export declare function context_repository_add(tx: Transaction, progress: ProgressObject, machine: MachineObject, permission: PermissionObject, repository: RepositoryObject, passport?: PassportObject): void;
+export declare function context_repository_remove(tx: Transaction, progress: ProgressObject, machine: MachineObject, permission: PermissionObject, repositories: string[], passport?: PassportObject): void;
+export declare function context_repository_clear(tx: Transaction, progress: ProgressObject, machine: MachineObject, permission: PermissionObject, passport?: PassportObject): void;
+export declare function hold(tx: Transaction, progress: ProgressObject, machine: MachineObject, permission: PermissionObject, next_node: string, forward: string, message: string, bHold: boolean, order?: string, passport?: PassportObject): void;
+export declare function adminUnhold(tx: Transaction, progress: ProgressObject, machine: MachineObject, permission: PermissionObject, next_node: string, forward: string, message: string, passport?: PassportObject): void;
+export declare function accomplish(tx: Transaction, progress: ProgressObject, machine: MachineObject, permission: PermissionObject, next_node: string, forward: string, message: string, order?: string, passport?: PassportObject): void;
+export declare function getMachineNodeForward(env: CallEnv, machine: string, node: string, next_node: string, forward: string): Promise<MachineForward | undefined>;