How to use the node-opcua-variant.VariantArrayType.Scalar function in node-opcua-variant

const inputArguments: Variant[] = inputArgsDef.map((arg: any) => {

            const dataType = convertNodeIdToDataType(arg.dataType);

            const arrayType = (arg.valueRank === 1) ? VariantArrayType.Array : VariantArrayType.Scalar;

            // xx console.log("xxx ",arg.toString());
            const propName = lowerFirstLetter(arg.name);

            const value = inputArgs[propName];
            if (value === undefined) {
                throw new Error("expecting input argument " + propName);
            }
            if (arrayType === VariantArrayType.Array) {
                if (!_.isArray(value)) {
                    throw new Error("expecting value to be an Array or a TypedArray");
                }
            }
            return new Variant({arrayType, dataType, value});
        });

function adjustVariant(uaVariable, variant) {

    const self = uaVariable;

    // convert Variant( Scalar|ByteString) =>  Variant(Array|ByteArray)
    const addressSpace = self.addressSpace;

    const basicType = addressSpace.findCorrespondingBasicDataType(uaVariable.dataType);

    if (basicType === DataType.Byte && uaVariable.valueRank === 1) {
        if (variant.arrayType === VariantArrayType.Scalar && variant.dataType === DataType.ByteString) {

            if ((uaVariable.dataType.value === DataType.Byte.value) && (self.dataType.namespace === 0)) { // Byte
                variant.arrayType = VariantArrayType.Array;
                variant.dataType = DataType.Byte;
                assert(variant.dataType === DataType.Byte);
                assert(!variant.value || variant.value instanceof Buffer);
            }
        }
    }
    if (basicType === DataType.ByteString && uaVariable.valueRank === -1 /* Scalar*/) {

        if (variant.arrayType === VariantArrayType.Array && variant.dataType === DataType.Byte) {
            if ((self.dataType.value === DataType.ByteString.value) && (self.dataType.namespace === 0)) { // Byte
                variant.arrayType = VariantArrayType.Scalar;
                variant.dataType = DataType.ByteString;
                assert(variant.dataType === DataType.ByteString);

function makeVariant(dataTypeName, isArray, current_value) {

    isArray = (isArray === null) ? false : isArray;
    let arrayType = VariantArrayType.Scalar;
    if (isArray) {
        arrayType = VariantArrayType.Array;
    }
    const dataType = _findDataType(dataTypeName);
    assert(!dataType.isAbstract);

    const validatorFunc = getValidatorFuncForType(dataType);

    validate_value_or_array(isArray, current_value, validatorFunc);

    const variant = new Variant({
        dataType: dataType,
        arrayType: arrayType,
        value: current_value
    });
    return variant;

export async function resolveDynamicExtensionObject(
    variant: Variant,
    extraDataType: ExtraDataTypeManager
): Promise {

    if (variant.dataType !== DataType.ExtensionObject) {
        return;
    }
    if (variant.arrayType !== VariantArrayType.Scalar) {

        if (variant.value instanceof Array) {
            variant.value = (variant.value as any[]).map((v: any) => {

                if (!(v instanceof OpaqueStructure)) {
                    return v;
                }
                const obj = resolveDynamicExtensionObjectV(v as OpaqueStructure, extraDataType);
                return obj;
            });
        }
        return;
    }

    if (!(variant.value instanceof OpaqueStructure)) {
        return;

async function _createSigningRequest(
  this: UAMethod,
  inputArguments: Variant[],
  context: SessionContext
): Promise {

    const certificateGroupIdVariant = inputArguments[0];
    const certificateTypeIdVariant = inputArguments[1];
    const subjectNameVariant = inputArguments[2];
    const regeneratePrivateKeyVariant = inputArguments[3];
    const nonceVariant = inputArguments[4];

    if (!expected(certificateGroupIdVariant, DataType.NodeId, VariantArrayType.Scalar)) {
        return { statusCode: StatusCodes.BadInvalidArgument };
    }
    if (!expected(certificateTypeIdVariant, DataType.NodeId, VariantArrayType.Scalar)) {
        return { statusCode: StatusCodes.BadInvalidArgument };
    }
    if (!expected(subjectNameVariant, DataType.String, VariantArrayType.Scalar)) {
        return { statusCode: StatusCodes.BadInvalidArgument };
    }
    if (!expected(regeneratePrivateKeyVariant, DataType.Boolean, VariantArrayType.Scalar)) {
        return { statusCode: StatusCodes.BadInvalidArgument };
    }
    if (!expected(regeneratePrivateKeyVariant, DataType.Boolean, VariantArrayType.Scalar)) {
        return { statusCode: StatusCodes.BadInvalidArgument };
    }

    if (!hasEncryptedChannel(context)) {

public async write(data: Buffer): Promise {
        await this.ensureInitialized();
        if (!this.fileHandle) {
            throw new Error("File has node been opened yet");
        }
        const result = await this.session.call({
            inputArguments: [
                { dataType: DataType.UInt32, value: this.fileHandle },
                {
                    arrayType: VariantArrayType.Scalar,
                    dataType: DataType.ByteString,
                    value: data
                }
            ],
            methodId: this.writeNodeId,
            objectId: this.fileNodeId
        });
        if (result.statusCode !== StatusCodes.Good) {
            throw new Error("Error " + result.statusCode.toString());
        }
        return;
    }

finish: function () {
                    const base64text = this.text;
                    const byteString = Buffer.from(base64text, "base64");
                    this.parent.parent.obj.value = {
                        dataType: DataType.ByteString,
                        arrayType: VariantArrayType.Scalar,
                        value: byteString
                    };
                }
            },

function canRange(dataValue) {
    return dataValue.value && ((dataValue.value.arrayType !== VariantArrayType.Scalar) ||
        ((dataValue.value.arrayType === VariantArrayType.Scalar) && (dataValue.value.dataType === DataType.ByteString)) ||
        ((dataValue.value.arrayType === VariantArrayType.Scalar) && (dataValue.value.dataType === DataType.String)));
}

function canRange(dataValue: DataValue): boolean {
  return dataValue.value && ((dataValue.value.arrayType !== VariantArrayType.Scalar) ||
    ((dataValue.value.arrayType === VariantArrayType.Scalar) && (dataValue.value.dataType === DataType.ByteString))
    ||
    ((dataValue.value.arrayType === VariantArrayType.Scalar) && (dataValue.value.dataType === DataType.String)));
}