node-opcua-address-space 2.180.0 → 2.181.0

package/source/helpers/argument_list.ts

@@ -1,310 +0,0 @@
-/**
- * @module node-opcua-address-space
- */
-
-import type { IAddressSpace, UAMethod, UAObject } from "node-opcua-address-space-base";
-import { assert } from "node-opcua-assert";
-import { decodeArray, encodeArray } from "node-opcua-basic-types";
-import { type BinaryStream, BinaryStreamSizeCalculator, type OutputBinaryStream } from "node-opcua-binary-stream";
-import { DataTypeIds } from "node-opcua-constants";
-import { NodeClass } from "node-opcua-data-model";
-import { checkDebugFlag, make_debugLog, make_warningLog } from "node-opcua-debug";
-import { type BasicTypeDefinition, findBuiltInType } from "node-opcua-factory";
-import { coerceNodeId, type NodeId, resolveNodeId } from "node-opcua-nodeid";
-import type { Argument } from "node-opcua-service-call";
-import { type StatusCode, StatusCodes } from "node-opcua-status-code";
-import { DataType, type Variant, VariantArrayType } from "node-opcua-variant";
-
-const debugLog = make_debugLog(__filename);
-const warningLog = make_warningLog(__filename);
-const doDebug = checkDebugFlag(__filename);
-
-function myfindBuiltInType(dataType: DataType): BasicTypeDefinition {
-    return findBuiltInType(DataType[dataType]);
-}
-export interface ArgumentDef {
-    dataType: DataType;
-    valueRank?: undefined | number;
-}
-export function encode_ArgumentList(definition: ArgumentDef[], args: unknown[], stream: OutputBinaryStream): void {
-    assert(definition.length === args.length);
-
-    assert(Array.isArray(definition));
-    assert(Array.isArray(args));
-    assert(definition.length === args.length);
-    assert(definition.length >= 0);
-
-    // we only encode arguments by following the definition
-
-    for (let i = 0; i < definition.length; i++) {
-        const def = definition[i];
-        const value = args[i];
-
-        const encodeFunc = myfindBuiltInType(def.dataType).encode;
-        if (!encodeFunc) {
-            throw new Error(
-                "This BaseDataType cannot be encoded because it has no definition.\n" +
-                    "Please construct a BaseDataType({definition : [{dataType: DataType.UInt32 }]});"
-            );
-        }
-        // assert((def.valueRank === -1) || (def.valueRank === 0));
-
-        // todo : handle -3 -2
-        const isArray = def.valueRank && (def.valueRank === 1 || def.valueRank !== -1);
-
-        if (isArray) {
-            encodeArray(value as unknown[], stream, encodeFunc);
-        } else {
-            encodeFunc(value, stream);
-        }
-    }
-}
-
-export function decode_ArgumentList(definition: ArgumentDef[], stream: BinaryStream): unknown[] {
-    // c8 ignore next
-    if (!Array.isArray(definition)) {
-        throw new Error(
-            "This BaseDataType cannot be decoded because it has no definition.\n" +
-                "Please construct a BaseDataType({definition : [{dataType: DataType.UInt32 }]});"
-        );
-    }
-
-    const args: unknown[] = [];
-    let value: unknown;
-
-    for (const def of definition) {
-        const decodeFunc = myfindBuiltInType(def.dataType).decode;
-        if (!decodeFunc) {
-            throw new Error(
-                "This BaseDataType cannot be decoded because it has no definition.\n" +
-                    "Please construct a BaseDataType({definition : [{dataType: DataType.UInt32 }]});"
-            );
-        }
-        // assert(def.valueRank === -1 || def.valueRank==0);
-        // todo : handle -3 -2
-        // xx assert(def.valueRank === -1 || def.valueRank==0);
-        const isArray = def.valueRank === 1 || def.valueRank === -1;
-
-        if (isArray) {
-            value = decodeArray(stream, decodeFunc);
-        } else {
-            value = decodeFunc(stream);
-        }
-        args.push(value);
-    }
-    return args;
-}
-
-export function binaryStoreSize_ArgumentList(description: ArgumentDef[], args: unknown[]): number {
-    assert(Array.isArray(description));
-    assert(Array.isArray(args));
-    assert(args.length === description.length);
-
-    const stream = new BinaryStreamSizeCalculator();
-    encode_ArgumentList(description, args, stream);
-    return stream.length;
-}
-
-export function getMethodDeclaration_ArgumentList(
-    addressSpace: IAddressSpace,
-    objectId: NodeId,
-    methodId: NodeId
-): { statusCode: StatusCode; methodDeclaration?: UAMethod } {
-    // find object in address space
-    const obj = addressSpace.findNode(objectId) as UAObject;
-    if (!obj) {
-        // c8 ignore next
-        doDebug && debugLog("cannot find node ", objectId.toString());
-
-        return { statusCode: StatusCodes.BadNodeIdUnknown };
-    }
-    let objectMethod = obj.getMethodById(methodId) as UAMethod;
-    if (!objectMethod) {
-        // the method doesn't belong to the object, nevertheless
-        // the method can be called
-        objectMethod = addressSpace.findNode(methodId) as UAMethod;
-        if (!objectMethod || objectMethod.nodeClass !== NodeClass.Method) {
-            warningLog("cannot find method with id", methodId.toString(), "object Id = ", objectId.toString());
-            return { statusCode: StatusCodes.BadMethodInvalid };
-        }
-    }
-
-    const methodDeclarationId = objectMethod.methodDeclarationId;
-    const methodDeclaration = addressSpace.findNode(methodDeclarationId) as UAMethod;
-    if (!methodDeclaration) {
-        //  return {statusCode: StatusCodes.BadMethodInvalid};
-        return { statusCode: StatusCodes.Good, methodDeclaration: objectMethod };
-    }
-    // c8 ignore next
-    if (methodDeclaration.nodeClass !== NodeClass.Method) {
-        throw new Error("Expecting a Method here");
-    }
-    return { statusCode: StatusCodes.Good, methodDeclaration };
-}
-
-function checkValueRank(argDefinition: Argument, arg: Variant) {
-    const isArray = arg.arrayType === VariantArrayType.Array;
-    const isMatrix = arg.arrayType === VariantArrayType.Matrix;
-
-    if (argDefinition.valueRank > 0) {
-        if (argDefinition.valueRank === 1) {
-            if (!isArray) {
-                return false;
-            }
-        } else {
-            if (!isMatrix) {
-                return false;
-            }
-        }
-    } else if (argDefinition.valueRank === -1) {
-        // SCALAR
-        if (isArray || isMatrix) {
-            return false;
-        }
-    } else if (argDefinition.valueRank === -2) {
-        // ANY
-    } else if (argDefinition.valueRank === -3) {
-        // Scalar or OneDim
-        if (isMatrix) {
-            return false;
-        }
-    } else if (argDefinition.valueRank === 0) {
-        // array or matrix
-        if (!isArray && !isMatrix) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * @private
- */
-export function isArgumentValid(addressSpace: IAddressSpace, argDefinition: Argument, arg: Variant): boolean {
-    assert(Object.hasOwn(argDefinition, "dataType"));
-    assert(Object.hasOwn(argDefinition, "valueRank"));
-
-    const argDefDataType = addressSpace.findDataType(argDefinition.dataType);
-    const argDataType = addressSpace.findDataType(resolveNodeId(arg.dataType));
-
-    // c8 ignore next
-    if (!argDefDataType) {
-        // c8 ignore next
-        doDebug && debugLog("dataType ", argDefinition.dataType.toString(), "doesn't exist");
-        return false;
-    }
-
-    if (argDefinition.valueRank >= 0 && arg.dataType === DataType.Null) {
-        // this is valid to receive an empty array ith DataType.Null;
-        return true;
-    }
-
-    if (!checkValueRank(argDefinition, arg)) {
-        return false;
-    }
-
-    // c8 ignore next
-    if (!argDataType) {
-        doDebug && debugLog(" cannot find dataType ", arg.dataType, resolveNodeId(arg.dataType));
-        doDebug && debugLog(" arg = ", arg.toString());
-        doDebug && debugLog(" def =", argDefinition.toString());
-        return false;
-    }
-
-    // c8 ignore next
-    if (doDebug) {
-        doDebug && debugLog(" checking argDefDataType ", argDefDataType.toString());
-        doDebug && debugLog(" checking argDataType ", argDataType.toString());
-    }
-
-    if (argDataType.nodeId.value === argDefDataType?.nodeId.value) {
-        return true;
-    }
-
-    // check that dataType is of the same type (derived )
-    if (argDefDataType.isSubtypeOf(argDataType)) {
-        // like argDefDataType IntegerId and argDataType Uint32
-        return true;
-    }
-    if (argDataType.isSubtypeOf(argDefDataType)) {
-        // like argDefDataType BaseDataType and argDataType any Type
-        return true;
-    }
-
-    // special case for Enumeration
-    if (arg.dataType === DataType.Int32) {
-        const enumDataType = addressSpace.findDataType(coerceNodeId(DataTypeIds.Enumeration));
-        if (enumDataType && argDefDataType.isSubtypeOf(enumDataType)) {
-            return true;
-        }
-    }
-    return false;
-}
-
-/**
- */
-export function verifyArguments_ArgumentList(
-    addressSpace: IAddressSpace,
-    methodInputArguments: Argument[],
-    inputArguments: Variant[]
-): {
-    inputArgumentResults?: StatusCode[];
-    statusCode: StatusCode;
-} {
-    const inputArgumentResults: StatusCode[] = methodInputArguments.map((methodInputArgument, index) => {
-        const argument = inputArguments?.[index];
-        if (!argument) {
-            return StatusCodes.BadNoData;
-        } else if (!isArgumentValid(addressSpace, methodInputArgument, argument)) {
-            return StatusCodes.BadTypeMismatch;
-        } else {
-            return StatusCodes.Good;
-        }
-    });
-
-    if (methodInputArguments.length > inputArguments.length) {
-        // c8 ignore next
-        doDebug &&
-            debugLog(
-                "verifyArguments_ArgumentList " +
-                    "\n       The client did  specify too many input arguments for the method.  " +
-                    "\n        expected : " +
-                    methodInputArguments.length +
-                    "" +
-                    "\n        actual   : " +
-                    inputArguments.length
-            );
-
-        return { inputArgumentResults, statusCode: StatusCodes.BadArgumentsMissing };
-    }
-
-    if (methodInputArguments.length < inputArguments.length) {
-        // c8 ignore next
-        doDebug &&
-            debugLog(
-                " verifyArguments_ArgumentList " +
-                    "\n        The client did not specify all of the input arguments for the method. " +
-                    "\n        expected : " +
-                    methodInputArguments.length +
-                    "" +
-                    "\n        actual   : " +
-                    inputArguments.length
-            );
-
-        return { inputArgumentResults, statusCode: StatusCodes.BadTooManyArguments };
-    }
-
-    const hasBadTypeMismatch = inputArgumentResults.includes(StatusCodes.BadTypeMismatch);
-    const hasBadOutOfRange = inputArgumentResults.includes(StatusCodes.BadOutOfRange);
-
-    const statusCode =
-        hasBadTypeMismatch || hasBadOutOfRange
-            ? hasBadTypeMismatch && !hasBadOutOfRange
-                ? StatusCodes.BadTypeMismatch
-                : StatusCodes.BadInvalidArgument
-            : StatusCodes.Good;
-
-    return {
-        inputArgumentResults,
-        statusCode
-    };
-}

package/source/helpers/call_helpers.ts

@@ -1,100 +0,0 @@
-/**
- * @module node-opcua-address-space
- */
-
-import type { IAddressSpace, ISessionContext, UAMethod, UAObject } from "node-opcua-address-space-base";
-import { assert } from "node-opcua-assert";
-import { NodeClass } from "node-opcua-data-model";
-import { NodeId } from "node-opcua-nodeid";
-import type { CallMethodRequest } from "node-opcua-service-call";
-import { StatusCodes } from "node-opcua-status-code";
-import type { CallMethodResultOptions } from "node-opcua-types";
-import type { Variant } from "node-opcua-variant";
-
-import { getMethodDeclaration_ArgumentList, verifyArguments_ArgumentList } from "./argument_list";
-import { resolveOpaqueOnAddressSpace } from "./resolve_opaque_on_address_space";
-
-// Symbolic Id                   Description
-// ----------------------------  -----------------------------------------------------------------------------
-// BadNodeIdInvalid              Used to indicate that the specified object is not valid.
-//
-// BadNodeIdUnknown             Used to indicate that the specified object is not valid.
-//
-// BadArgumentsMissing          The client did not specify all of the input arguments for the method.
-// BadUserAccessDenied
-//
-// BadMethodInvalid             The method id does not refer to a method for the specified object.
-// BadOutOfRange                Used to indicate that an input argument is outside the acceptable range.
-// BadTypeMismatch              Used to indicate that an input argument does not have the correct data type.
-//                               A ByteString is structurally the same as a one dimensional array of Byte.
-//                               A server shall accept a ByteString if an array of Byte is expected.
-// BadNoCommunication
-
-export async function callMethodHelper(
-    context: ISessionContext,
-    addressSpace: IAddressSpace,
-    callMethodRequest: CallMethodRequest
-): Promise<CallMethodResultOptions> {
-    const objectId = callMethodRequest.objectId;
-    const methodId = callMethodRequest.methodId;
-    const inputArguments = callMethodRequest.inputArguments || [];
-
-    assert(objectId instanceof NodeId);
-    assert(methodId instanceof NodeId);
-
-    const object = addressSpace.findNode(objectId) as UAObject;
-    if (!object) {
-        return { statusCode: StatusCodes.BadNodeIdUnknown };
-    }
-    if (object.nodeClass !== NodeClass.Object && object.nodeClass !== NodeClass.ObjectType) {
-        return { statusCode: StatusCodes.BadNodeIdInvalid };
-    }
-
-    const methodObj = addressSpace.findNode(methodId) as UAMethod;
-    if (!methodObj) {
-        return { statusCode: StatusCodes.BadMethodInvalid };
-    }
-    if (methodObj.nodeClass !== NodeClass.Method) {
-        return { statusCode: StatusCodes.BadMethodInvalid };
-    }
-
-    const response1 = getMethodDeclaration_ArgumentList(addressSpace, objectId, methodId);
-
-    if (response1.statusCode.isNotGood()) {
-        return { statusCode: response1.statusCode };
-    }
-    const methodDeclaration = response1.methodDeclaration;
-    if (!methodDeclaration) {
-        return { statusCode: StatusCodes.BadMethodInvalid };
-    }
-
-    // verify input Parameters
-    const methodInputArguments = methodDeclaration.getInputArguments();
-
-    const response = verifyArguments_ArgumentList(addressSpace, methodInputArguments, inputArguments);
-    if (response.statusCode.isNotGood()) {
-        return response;
-    }
-
-    try {
-        await resolveOpaqueOnAddressSpace(addressSpace, inputArguments);
-
-        const callMethodResponse = await methodObj.execute(object, inputArguments, context);
-        callMethodResponse.inputArgumentResults = callMethodResponse.inputArgumentResults || response.inputArgumentResults || [];
-        assert(callMethodResponse.statusCode);
-
-        if (callMethodResponse.statusCode?.isGood()) {
-            assert(Array.isArray(callMethodResponse.outputArguments));
-        }
-
-        assert(Array.isArray(callMethodResponse.inputArgumentResults));
-        assert(callMethodResponse.inputArgumentResults?.length === methodInputArguments.length);
-
-        const outputArguments = callMethodResponse.outputArguments || [];
-        await resolveOpaqueOnAddressSpace(addressSpace, outputArguments as Variant[]);
-
-        return callMethodResponse;
-    } catch (_err) {
-        return { statusCode: StatusCodes.BadInternalError };
-    }
-}

package/source/helpers/coerce_enum_value.ts

@@ -1,33 +0,0 @@
-/**
- * @module node-opcua-address-space
- */
-import { assert } from "node-opcua-assert";
-import { coerceInt64, type Int64 } from "node-opcua-basic-types";
-import { coerceLocalizedText } from "node-opcua-data-model";
-import { EnumValueType } from "node-opcua-types";
-import type { EnumValueTypeOptionsLike } from "../address_space_ts";
-
-export function coerceEnumValues(enumValues: EnumValueTypeOptionsLike[] | { [key: string]: number | Int64 }): EnumValueType[] {
-    if (Array.isArray(enumValues)) {
-        //
-        return enumValues.map((en) => {
-            assert(Object.hasOwn(en, "value"));
-            assert(Object.hasOwn(en, "displayName"));
-            return new EnumValueType({
-                displayName: coerceLocalizedText(en.displayName),
-                value: coerceInt64(en.value || 0)
-            });
-        });
-    } else {
-        return coerceEnumValues(
-            Object.entries(enumValues as { [key: string]: Int64 }).map((entry: [string, Int64]) => {
-                const [key, value] = entry;
-                return new EnumValueType({
-                    description: coerceLocalizedText(key),
-                    displayName: coerceLocalizedText(key),
-                    value: coerceInt64(value)
-                });
-            })
-        );
-    }
-}

package/source/helpers/dump_tools.ts

@@ -1,90 +0,0 @@
-/**
- * @module node-opcua-address-space
- */
-import chalk from "chalk";
-import type { BaseNode, IAddressSpace, UAReference, UAReferenceType as UAReferenceTypePublic } from "node-opcua-address-space-base";
-import { assert } from "node-opcua-assert";
-import { BrowseDirection } from "node-opcua-data-model";
-import type { NodeId, NodeIdLike } from "node-opcua-nodeid";
-import { BrowseDescription, type BrowseDescriptionOptions, type ReferenceDescription } from "node-opcua-types";
-
-import { resolveReferenceType } from "../../src/reference_impl";
-
-export function referenceTypeToString(addressSpace: IAddressSpace, referenceTypeId: NodeIdLike | null): string {
-    // c8 ignore next
-    if (!referenceTypeId) {
-        return "<null> ";
-    } else {
-        const referenceType = addressSpace.findNode(referenceTypeId) as UAReferenceTypePublic | null;
-        if (!referenceType) {
-            return `${referenceTypeId.toString()} <unknown reference type>`;
-        }
-        return `${referenceTypeId.toString()} ${referenceType.browseName.toString()}/${referenceType.inverseName?.text}`;
-    }
-}
-
-function nodeIdInfo(addressSpace: IAddressSpace, nodeId: NodeId): string {
-    const obj = addressSpace.findNode(nodeId);
-    const name = obj ? obj.browseName.toString() : " <????>";
-    return `${nodeId.toString()} [ ${name} ]`;
-}
-
-export function dumpReferenceDescription(addressSpace: IAddressSpace, referenceDescription: ReferenceDescription): void {
-    assert(referenceDescription.referenceTypeId); // must be known;
-
-    console.log(chalk.red("referenceDescription"));
-    console.log("    referenceTypeId : ", referenceTypeToString(addressSpace, referenceDescription.referenceTypeId));
-    console.log("    isForward       : ", referenceDescription.isForward ? "true" : "false");
-    console.log("    nodeId          : ", nodeIdInfo(addressSpace, referenceDescription.nodeId));
-    console.log("    browseName      : ", referenceDescription.browseName.toString());
-    console.log("    nodeClass       : ", referenceDescription.nodeClass.toString());
-    console.log("    typeDefinition  : ", nodeIdInfo(addressSpace, referenceDescription.typeDefinition));
-}
-
-export function dumpReferenceDescriptions(addressSpace: IAddressSpace, referenceDescriptions: ReferenceDescription[]): void {
-    referenceDescriptions.forEach((r: ReferenceDescription) => {
-        dumpReferenceDescription(addressSpace, r);
-    });
-}
-
-export function dumpBrowseDescription(node: BaseNode, _browseDescription: BrowseDescriptionOptions): void {
-    const browseDescription = new BrowseDescription(_browseDescription);
-
-    const addressSpace = node.addressSpace;
-
-    console.log(" Browse Node :");
-
-    if (browseDescription.nodeId) {
-        console.log(" nodeId : ", chalk.cyan(browseDescription.nodeId.toString()));
-    }
-
-    console.log(" nodeId : ", chalk.cyan(node.browseName.toString()), "(", node.nodeId.toString(), ")");
-    console.log("   referenceTypeId :", referenceTypeToString(addressSpace, browseDescription.referenceTypeId));
-
-    console.log("   browseDirection :", chalk.cyan(BrowseDirection[browseDescription.browseDirection]));
-    console.log("   includeSubType  :", browseDescription.includeSubtypes ? "true" : "false");
-    console.log("   nodeClassMask   :", browseDescription.nodeClassMask);
-    console.log("   resultMask      :", browseDescription.resultMask);
-}
-
-/**
- */
-export function dumpReferences(addressSpace: IAddressSpace, references: UAReference[] | MapIterator<UAReference>): void {
-    assert(addressSpace);
-    for (const reference of references) {
-        const referenceType = resolveReferenceType(addressSpace, reference);
-        if (!referenceType) {
-            // unknown type ... this may happen when the address space is not fully build
-            return;
-        }
-        const dir = reference.isForward ? "(=>)" : "(<-)";
-        const objectName = nodeIdInfo(addressSpace, reference.nodeId);
-        console.log(
-            " referenceType : ",
-            dir,
-            referenceType ? referenceType.browseName.toString() : reference.referenceType.toString(),
-            " ",
-            objectName
-        );
-    }
-}

package/source/helpers/ensure_secure_access.ts

@@ -1,57 +0,0 @@
-import type { BaseNode, IChannelBase, UAMethod, UAObject, UAVariable } from "node-opcua-address-space-base";
-import { allPermissions, BrowseDirection, makeAccessRestrictionsFlag, makePermissionFlag, NodeClass } from "node-opcua-data-model";
-import { MessageSecurityMode } from "node-opcua-types";
-import { WellKnownRoles } from "../session_context";
-
-function _isChannelSecure(channel: IChannelBase): boolean {
-    if (channel.securityMode === MessageSecurityMode.SignAndEncrypt) {
-        return true;
-    }
-    return false;
-}
-
-/**
- * make sure that the given ia node can only be read
- * by Administrator user on a encrypted channel
- * @param node
-
-*/
-const restrictedPermissions = [
-    { roleId: WellKnownRoles.SecurityAdmin, permissions: allPermissions },
-    { roleId: WellKnownRoles.ConfigureAdmin, permissions: allPermissions },
-    { roleId: WellKnownRoles.Supervisor, permissions: allPermissions },
-    { roleId: WellKnownRoles.Operator, permissions: makePermissionFlag("Browse") },
-    { roleId: WellKnownRoles.Engineer, permissions: makePermissionFlag("Browse") },
-    { roleId: WellKnownRoles.Observer, permissions: makePermissionFlag("Browse") }
-    /*
-    { roleId: WellKnownRoles.Anonymous, permissions: makePermissionFlag("Browse") },
-    { roleId: WellKnownRoles.AuthenticatedUser, permissions: makePermissionFlag("Browse") },
-*/
-];
-const restrictedAccessFlag = makeAccessRestrictionsFlag("SigningRequired | EncryptionRequired");
-/**
- * this method install the access right restriction on the given node and its children
- * values will only be available to user with role Administrator or supervisor and
- * with a signed and encrypted channel.
- *
- * @param node the node which permissions are to be adjusted
- */
-export function ensureObjectIsSecure(node: BaseNode): void {
-    node.setAccessRestrictions(restrictedAccessFlag);
-    if (node.nodeClass === NodeClass.Variable) {
-        const variable = node as UAVariable;
-        variable.setRolePermissions(restrictedPermissions);
-    }
-    if (node.nodeClass === NodeClass.Method) {
-        const method = node as UAMethod;
-        method.setRolePermissions(restrictedPermissions);
-    }
-    if (node.nodeClass === NodeClass.Object) {
-        const object = node as UAObject;
-        object.setRolePermissions(restrictedPermissions);
-    }
-    const children = node.findReferencesExAsObject("Aggregates", BrowseDirection.Forward);
-    for (const child of children) {
-        ensureObjectIsSecure(child);
-    }
-}

package/source/helpers/multiform_func.ts

@@ -1,78 +0,0 @@
-import { make_warningLog } from "node-opcua-debug";
-import type { CallbackT } from "node-opcua-status-code";
-
-const warningLog = make_warningLog(__filename);
-
-export type StraightFunc<T, This> = (this: This) => T;
-export type PromiseFunc<T, This> = (this: This) => Promise<T>;
-export type CallbackFunc<T, This> = (this: This, callback: CallbackT<T>) => void;
-export type MultiformFunc<T, This> = StraightFunc<T, This> | PromiseFunc<T, This> | CallbackFunc<T, This>;
-
-export function convertToCallbackFunction<T, This>(func: MultiformFunc<T, This>): CallbackFunc<T, This> {
-    if (func.length === 0) {
-        return function (this: This, callback: CallbackT<T>) {
-            /** */
-            let valueOrPromise: T | Promise<T>;
-            try {
-                valueOrPromise = (func as (this: This) => Promise<T> | T).call(this);
-            } catch (err) {
-                return callback(err as Error);
-            }
-            if (valueOrPromise instanceof Promise) {
-                valueOrPromise.then((value: T) => callback(null, value)).catch((err) => callback(err));
-            } else {
-                return callback(null, valueOrPromise);
-            }
-        };
-    } else {
-        if (func.length !== 1) {
-            throw new Error("convertToCallbackFunction: invalid function");
-        }
-
-        return function (this: This, callback: CallbackT<T>) {
-            try {
-                (func as CallbackFunc<T, This>).call(this, callback);
-            } catch (err) {
-                warningLog("internal error", (err as Error).message);
-                callback(err as Error);
-            }
-        };
-    }
-}
-
-export type StraightFunc1<T, P, This> = (this: This, param1: P) => T;
-export type PromiseFunc1<T, P, This> = (this: This, param1: P) => Promise<T>;
-export type CallbackFunc1<T, P, This> = (this: This, param1: P, callback: CallbackT<T>) => void;
-export type MultiformFunc1<T, P, This> = StraightFunc1<T, P, This> | PromiseFunc1<T, P, This> | CallbackFunc1<T, P, This>;
-
-export function convertToCallbackFunction1<T, P, This>(func: MultiformFunc1<T, P, This>): CallbackFunc1<T, P, This> {
-    if (func.length === 1) {
-        return function (this: This, param: P, callback: CallbackT<T>) {
-            /** */
-            let valueOrPromise: T | Promise<T>;
-            try {
-                valueOrPromise = (func as (this: This, param: P) => Promise<T> | T).call(this, param);
-            } catch (err) {
-                return callback(err as Error);
-            }
-            if (valueOrPromise instanceof Promise) {
-                valueOrPromise.then((value: T) => callback(null, value)).catch((err) => callback(err));
-            } else {
-                return callback(null, valueOrPromise);
-            }
-        };
-    } else {
-        if (func.length !== 2) {
-            throw new Error("convertToCallbackFunction: invalid function");
-        }
-
-        return function (this: This, param: P, callback: CallbackT<T>) {
-            try {
-                (func as CallbackFunc1<T, P, This>).call(this, param, callback);
-            } catch (err) {
-                warningLog("internal error", (err as Error).message);
-                callback(err as Error);
-            }
-        };
-    }
-}