@abaplint/runtime 2.7.90 → 2.7.91

package/build/src/console/memory_console.d.ts

@@ -0,0 +1,9 @@
+import { Console } from "./console";
+export declare class MemoryConsole implements Console {
+    private data;
+    clear(): void;
+    add(data: string): void;
+    get(): string;
+    isEmpty(): boolean;
+    getTrimmed(): string;
+}

package/build/src/console/standard_out_console.d.ts

@@ -0,0 +1,9 @@
+import { Console } from "./console";
+export declare class StandardOutConsole implements Console {
+    private empty;
+    clear(): void;
+    add(data: string): void;
+    get(): string;
+    isEmpty(): boolean;
+    getTrimmed(): string;
+}

package/build/src/context.d.ts

@@ -0,0 +1,13 @@
+import { Console } from "./console/console";
+import { DatabaseClient } from "./db/db";
+import * as RFC from "./rfc";
+export declare class Context {
+    console: Console;
+    databaseConnections: {
+        [name: string]: DatabaseClient;
+    };
+    RFCDestinations: {
+        [name: string]: RFC.RFCClient;
+    };
+    defaultDB(): DatabaseClient;
+}

package/build/src/db/db.d.ts

@@ -0,0 +1,55 @@
+export interface DeleteDatabaseOptions {
+    table: string;
+    where: string;
+}
+export interface UpdateDatabaseOptions {
+    table: string;
+    where: string;
+    set: string[];
+}
+export interface InsertDatabaseOptions {
+    table: string;
+    columns: string[];
+    values: string[];
+}
+export interface SelectDatabaseOptions {
+    /** select statement, in ABAP SQL syntax */
+    select: string;
+    /** list of primary key fields, in lower case, if known */
+    primaryKey?: string[];
+}
+export interface SelectRuntimeOptions {
+    appending?: boolean;
+}
+export type DatabaseValue = number | string | Uint8Array | null;
+export type DatabaseRow = {
+    [name: string]: DatabaseValue;
+};
+export type DatabaseRows = DatabaseRow[];
+export interface SelectDatabaseResult {
+    rows: DatabaseRows;
+}
+export interface DatabaseClient {
+    /*** the type/name/identifier of the database */
+    name: string;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    /*** execute any native SQL command */
+    execute(sql: string | string[]): Promise<void>;
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    delete(options: DeleteDatabaseOptions): Promise<{
+        subrc: number;
+        dbcnt: number;
+    }>;
+    update(options: UpdateDatabaseOptions): Promise<{
+        subrc: number;
+        dbcnt: number;
+    }>;
+    insert(options: InsertDatabaseOptions): Promise<{
+        subrc: number;
+        dbcnt: number;
+    }>;
+    select(options: SelectDatabaseOptions): Promise<SelectDatabaseResult>;
+}

package/build/src/expand_dynamic.d.ts

@@ -0,0 +1,2 @@
+import { FieldSymbol } from "./types";
+export declare function expandDynamic(code: string, ev: (name: string) => FieldSymbol | undefined): string;

package/build/src/expand_in.d.ts

@@ -0,0 +1,2 @@
+import { Table } from "./types";
+export declare function expandIN(fieldName: string, table: Table): string;

package/build/src/index.d.ts

@@ -0,0 +1,67 @@
+import { Context } from "./context";
+import { OffsetLength } from "./offset_length";
+import { Statements } from "./statements";
+import { templateFormatting } from "./template_formatting";
+import { UnitTestResult } from "./unit_test";
+import * as builtin from "./builtin";
+import * as compare from "./compare";
+import * as DB from "./db/db";
+import * as operators from "./operators";
+import * as RFC from "./rfc";
+import * as types from "./types";
+import { expandIN } from "./expand_in";
+import { expandDynamic } from "./expand_dynamic";
+import { ClassicError } from "./classic_error";
+import { Console } from "./console/console";
+import { MemoryConsole } from "./console/memory_console";
+import { buildDbTableName } from "./prefix";
+export { UnitTestResult, RFC, types, DB, MemoryConsole };
+export type RuntimeDatabaseOptions = {
+    schemaPrefix?: string;
+    tablePrefix?: string;
+};
+export type RuntimeOptions = {
+    console?: Console;
+    database?: RuntimeDatabaseOptions;
+};
+export declare class ABAP {
+    Classes: {
+        [name: string]: any;
+    };
+    DDIC: {
+        [name: string]: any;
+    };
+    FunctionModules: {
+        [name: string]: any;
+    };
+    Interfaces: {
+        [name: string]: any;
+    };
+    MSAG: {
+        [name: string]: any;
+    };
+    SMIM: {
+        [name: string]: any;
+    };
+    TypePools: {
+        [name: string]: any;
+    };
+    W3MI: {
+        [name: string]: any;
+    };
+    statements: Statements;
+    types: typeof types;
+    builtin: typeof builtin;
+    operators: typeof operators;
+    compare: typeof compare;
+    readonly console: Console;
+    OffsetLength: typeof OffsetLength;
+    templateFormatting: typeof templateFormatting;
+    expandIN: typeof expandIN;
+    expandDynamic: typeof expandDynamic;
+    buildDbTableName: typeof buildDbTableName;
+    ClassicError: typeof ClassicError;
+    readonly context: Context;
+    readonly dbo: RuntimeDatabaseOptions;
+    constructor(input?: RuntimeOptions);
+}

package/build/src/offset_length.d.ts

@@ -0,0 +1,16 @@
+import { Character, Hex, Structure, XString } from "./types";
+import { ICharacter } from "./types/_character";
+import { INumeric } from "./types/_numeric";
+export interface IOffsetLengthOptions {
+    length?: INumeric | number;
+    offset?: INumeric | number;
+}
+export declare class OffsetLength {
+    private readonly obj;
+    private readonly offset?;
+    private readonly length?;
+    private readonly isHex;
+    constructor(obj: ICharacter | Character | Hex | XString | Structure, options: IOffsetLengthOptions);
+    get(): string;
+    set(value: ICharacter | string): void;
+}

package/build/src/operators/_bit_operations.d.ts

@@ -0,0 +1,6 @@
+import { XString } from "../types";
+export declare function get_bit_operation_chunks(left: XString, right: XString): {
+    leftChunk: number;
+    rightChunk: number;
+    chunkLen: number;
+}[];

package/build/src/operators/_parse.d.ts

@@ -0,0 +1,4 @@
+import { Float, Integer } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export declare function parse(val: INumeric | ICharacter | string | number | Float | Integer): number;

package/build/src/operators/add.d.ts

@@ -0,0 +1,4 @@
+import { FieldSymbol, Float, Hex, Integer } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export declare function add(left: INumeric | ICharacter | string | number | Float | Integer | Hex | FieldSymbol, right: INumeric | ICharacter | string | number | Float | Integer | Hex | FieldSymbol): Integer | Float;

package/build/src/operators/bit-and.d.ts

@@ -0,0 +1,2 @@
+import { XString } from "../types";
+export declare function bitand(left: XString, right: XString): XString;

package/build/src/operators/bit-not.d.ts

@@ -0,0 +1,2 @@
+import { Hex, XString } from "../types";
+export declare function bitnot(right: XString | Hex): Hex;

package/build/src/operators/bit-or.d.ts

@@ -0,0 +1,2 @@
+import { XString } from "../types";
+export declare function bitor(left: XString, right: XString): XString;

package/build/src/operators/bit-xor.d.ts

@@ -0,0 +1,2 @@
+import { XString } from "../types";
+export declare function bitxor(left: XString, right: XString): XString;

package/build/src/operators/concat.d.ts

@@ -0,0 +1,4 @@
+import { String } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export declare function concat(left: INumeric | ICharacter | string | number | any[], right: INumeric | ICharacter | string | number): String;

package/build/src/operators/div.d.ts

@@ -0,0 +1,4 @@
+import { Integer, Integer8 } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export declare function div(left: INumeric | ICharacter | string | number, right: INumeric | ICharacter | string | number): Integer | Integer8;

package/build/src/operators/divide.d.ts

@@ -0,0 +1,4 @@
+import { Float } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export declare function divide(left: INumeric | ICharacter | string | number, right: INumeric | ICharacter | string | number): Float;

package/build/src/operators/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./add";
+export * from "./div";
+export * from "./divide";
+export * from "./minus";
+export * from "./mod";
+export * from "./multiply";
+export * from "./power";
+export * from "./bit-and";
+export * from "./bit-not";
+export * from "./bit-or";
+export * from "./bit-xor";
+export * from "./concat";

package/build/src/operators/minus.d.ts

@@ -0,0 +1,4 @@
+import { FieldSymbol, Float, Integer } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export declare function minus(left: INumeric | ICharacter | string | number | Integer | Float | FieldSymbol, right: INumeric | ICharacter | string | number | Integer | Float | FieldSymbol): Integer | Float;

package/build/src/operators/mod.d.ts

@@ -0,0 +1,4 @@
+import { Integer, Integer8 } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export declare function mod(left: INumeric | ICharacter | string | number, right: INumeric | ICharacter | string | number): Integer | Integer8;

package/build/src/operators/multiply.d.ts

@@ -0,0 +1,4 @@
+import { Float, Integer } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export declare function multiply(left: INumeric | ICharacter | string | number, right: INumeric | ICharacter | string | number): Float | Integer;

package/build/src/operators/power.d.ts

@@ -0,0 +1,4 @@
+import { Float } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export declare function power(left: INumeric | ICharacter | string | number, right: INumeric | ICharacter | string | number): Float;

package/build/src/prefix.d.ts

@@ -0,0 +1 @@
+export declare function buildDbTableName(table: string): string;

package/build/src/rfc.d.ts

@@ -0,0 +1,25 @@
+import { FieldSymbol, Structure, Table } from "./types";
+import { ICharacter } from "./types/_character";
+import { INumeric } from "./types/_numeric";
+type TypeType = INumeric | Table | ICharacter | Structure | FieldSymbol;
+export type RFCCallSignature = {
+    exporting?: {
+        [name: string]: TypeType;
+    };
+    importing?: {
+        [name: string]: TypeType;
+    };
+    tables?: {
+        [name: string]: TypeType;
+    };
+    changing?: {
+        [name: string]: TypeType;
+    };
+    exceptions?: {
+        [name: string]: number;
+    };
+};
+export interface RFCClient {
+    call(name: string, signature: RFCCallSignature): Promise<void>;
+}
+export {};

package/build/src/statements/append.d.ts

@@ -0,0 +1,13 @@
+import { DataReference, FieldSymbol, Table, TableRowType } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export interface IAppendOptions {
+    source: TableRowType | FieldSymbol | Table;
+    target: Table | FieldSymbol | undefined;
+    lines?: boolean;
+    assigning?: FieldSymbol;
+    referenceInto?: DataReference;
+    from?: ICharacter | INumeric;
+    to?: ICharacter | INumeric;
+}
+export declare function append(input: IAppendOptions): void;

package/build/src/statements/assert.d.ts

@@ -0,0 +1 @@
+export declare function assert(input: boolean): void;

package/build/src/statements/assign.d.ts

@@ -0,0 +1,12 @@
+import { DataReference, FieldSymbol, Structure, Table } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export interface IAssignInput {
+    source?: INumeric | ICharacter | Table | Structure | DataReference;
+    target: FieldSymbol;
+    dynamicName?: string;
+    dynamicSource?: ICharacter;
+    casting?: boolean;
+    component?: string | ICharacter;
+}
+export declare function assign(input: IAssignInput): void;

package/build/src/statements/call_function.d.ts

@@ -0,0 +1,16 @@
+import { Context } from "../context";
+export interface ICallFunctionOptions {
+    name: string;
+    destination?: string;
+    calling?: (INPUT: any) => any;
+    exporting?: any;
+    importing?: any;
+    tables?: any;
+    changing?: any;
+    exceptions?: any;
+}
+export declare class CallFunction {
+    private readonly context;
+    constructor(context: Context);
+    callFunction(options: ICallFunctionOptions): Promise<void>;
+}

package/build/src/statements/call_transaction.d.ts

@@ -0,0 +1 @@
+export declare function callTransaction(): void;

package/build/src/statements/cast.d.ts

@@ -0,0 +1,2 @@
+import { ABAPObject, FieldSymbol } from "../types";
+export declare function cast(target: ABAPObject | FieldSymbol, source: ABAPObject): Promise<void>;

package/build/src/statements/clear.d.ts

@@ -0,0 +1,4 @@
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+import { Table } from "../types";
+export declare function clear(value: ICharacter | INumeric | Table): void;

package/build/src/statements/collect.d.ts

@@ -0,0 +1,3 @@
+import { Table } from "../types";
+import { ICharacter } from "../types/_character";
+export declare function collect(source: ICharacter, target: Table): void;

package/build/src/statements/commit.d.ts

@@ -0,0 +1 @@
+export declare function commit(): void;

package/build/src/statements/concatenate.d.ts

@@ -0,0 +1,11 @@
+import { INumeric } from "../types/_numeric";
+import { ICharacter } from "../types/_character";
+import { Table } from "../types";
+export interface IConcatenateInput {
+    source: (number | string | INumeric | ICharacter | Table)[];
+    target: ICharacter;
+    separatedBy?: number | string | INumeric | ICharacter;
+    respectingBlanks?: boolean;
+    lines?: boolean;
+}
+export declare function concatenate(input: IConcatenateInput): void;

package/build/src/statements/condense.d.ts

@@ -0,0 +1,4 @@
+import { ICharacter } from "../types/_character";
+export declare function condense(input: ICharacter, options: {
+    nogaps: boolean;
+}): void;

package/build/src/statements/convert.d.ts

@@ -0,0 +1,14 @@
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export interface IConvertSource {
+    date?: ICharacter | string;
+    time?: ICharacter | string;
+    stamp?: ICharacter | INumeric | string;
+    zone: ICharacter | string;
+}
+export interface IConvertTarget {
+    stamp?: ICharacter;
+    date?: ICharacter;
+    time?: ICharacter;
+}
+export declare function convert(source: IConvertSource, target: IConvertTarget): void;

package/build/src/statements/create_data.d.ts

@@ -0,0 +1,17 @@
+import { ABAPObject, DataReference, FieldSymbol, Structure, Table } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+type PointerType = INumeric | Table | ICharacter | ABAPObject | undefined | Structure | FieldSymbol;
+export interface ICreateDataOptions {
+    table?: boolean;
+    name?: string;
+    type?: PointerType;
+    typeName?: string;
+    length?: INumeric;
+    decimals?: INumeric;
+    likeLineOf?: FieldSymbol | Table;
+    typeLineOf?: boolean;
+    like?: any;
+}
+export declare function createData(target: DataReference | FieldSymbol, options?: ICreateDataOptions): void;
+export {};

package/build/src/statements/delete_database.d.ts

@@ -0,0 +1,13 @@
+import { Context } from "../context";
+import { FieldSymbol, Structure, Table } from "../types";
+import { ICharacter } from "../types/_character";
+export interface IDeleteDatabaseOptions {
+    from?: Structure | FieldSymbol;
+    where?: string;
+    table?: Table | FieldSymbol;
+}
+export declare class DeleteDatabase {
+    private readonly context;
+    constructor(context: Context);
+    deleteDatabase(table: string | ICharacter, options: IDeleteDatabaseOptions): Promise<void>;
+}

package/build/src/statements/delete_internal.d.ts

@@ -0,0 +1,12 @@
+import { FieldSymbol, HashedTable, Table } from "../types";
+import { INumeric } from "../types/_numeric";
+export interface IDeleteInternalOptions {
+    where?: (i: any) => boolean;
+    index?: INumeric;
+    adjacent?: boolean;
+    comparing?: string[];
+    fromValue?: any;
+    from?: any;
+    to?: any;
+}
+export declare function deleteInternal(target: Table | HashedTable | FieldSymbol, options?: IDeleteInternalOptions): Promise<void>;

package/build/src/statements/describe.d.ts

@@ -0,0 +1,13 @@
+import { Table } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export interface IDescribeOptions {
+    field: any;
+    type?: ICharacter;
+    length?: INumeric;
+    decimals?: INumeric;
+    lines?: INumeric;
+    table?: Table;
+    mode?: "BYTE" | "CHARACTER";
+}
+export declare function describe(input: IDescribeOptions): void;

package/build/src/statements/find.d.ts

@@ -0,0 +1,17 @@
+import { ABAPObject, Structure, Table } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export interface IFindOptions {
+    find?: ICharacter | string;
+    first?: boolean;
+    regex?: string | ICharacter | ABAPObject;
+    offset?: INumeric;
+    sectionOffset?: INumeric;
+    byteMode?: boolean;
+    length?: INumeric;
+    count?: INumeric;
+    results?: Table | Structure;
+    ignoringCase?: boolean;
+    submatches?: ICharacter[];
+}
+export declare function find(input: ICharacter | Table, options: IFindOptions): void;

package/build/src/statements/get_bit.d.ts

@@ -0,0 +1,4 @@
+import { Hex, XString } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export declare function getBit(number: INumeric, hex: XString | Hex, output: ICharacter): void;

package/build/src/statements/get_locale.d.ts

@@ -0,0 +1,2 @@
+import { ICharacter } from "../types/_character";
+export declare function getLocale(target: ICharacter): void;

package/build/src/statements/get_parameter.d.ts

@@ -0,0 +1,2 @@
+import { ICharacter } from "../types/_character";
+export declare function getParameter(_source: ICharacter, _target: ICharacter): void;

package/build/src/statements/get_run_time.d.ts

@@ -0,0 +1,2 @@
+import { INumeric } from "../types/_numeric";
+export declare function getRunTime(value: INumeric): void;

package/build/src/statements/get_time.d.ts

@@ -0,0 +1,9 @@
+import { Structure } from "../types";
+import { ICharacter } from "../types/_character";
+type options = {
+    field?: ICharacter;
+    stamp?: ICharacter;
+    sy?: Structure;
+};
+export declare function getTime(options?: options): void;
+export {};

package/build/src/statements/index.d.ts

@@ -0,0 +1,106 @@
+import { append } from "./append";
+import { assert } from "./assert";
+import { assign } from "./assign";
+import { clear } from "./clear";
+import { commit } from "./commit";
+import { concatenate } from "./concatenate";
+import { condense } from "./condense";
+import { convert } from "./convert";
+import { createData } from "./create_data";
+import { deleteInternal } from "./delete_internal";
+import { describe } from "./describe";
+import { find } from "./find";
+import { collect } from "./collect";
+import { overlay } from "./overlay";
+import { cast } from "./cast";
+import { getBit } from "./get_bit";
+import { readReport } from "./read_report";
+import { raiseEvent } from "./raise_event";
+import { receive } from "./receive";
+import { getLocale } from "./get_locale";
+import { getParameter } from "./get_parameter";
+import { setLocale } from "./set_locale";
+import { getRunTime } from "./get_run_time";
+import { getTime } from "./get_time";
+import { IInsertDatabaseOptions } from "./insert_database";
+import { insertInternal } from "./insert_internal";
+import { IDeleteDatabaseOptions } from "./delete_database";
+import { loop } from "./loop";
+import { IMessageOptions } from "./message";
+import { IModifyDatabaseOptions } from "./modify_database";
+import { modifyInternal } from "./modify_internal";
+import { moveCorresponding } from "./move_corresponding";
+import { readTable } from "./read_table";
+import { replace } from "./replace";
+import { rollback } from "./rollback";
+import { setBit } from "./set_bit";
+import { shift } from "./shift";
+import { sort } from "./sort";
+import { wait } from "./wait";
+import { setHandler } from "./set_handler";
+import { split } from "./split";
+import { translate } from "./translate";
+import { callTransaction } from "./call_transaction";
+import { IUpdateDatabaseOptions } from "./update_database";
+import { IWriteOptions } from "./write";
+import { Context } from "../context";
+import { ICharacter } from "../types/_character";
+import { FieldSymbol, Structure, Table } from "../types";
+import { INumeric } from "../types/_numeric";
+import { ICallFunctionOptions } from "./call_function";
+import { SelectDatabaseOptions, SelectRuntimeOptions } from "../db/db";
+export declare class Statements {
+    append: typeof append;
+    assert: typeof assert;
+    assign: typeof assign;
+    cast: typeof cast;
+    clear: typeof clear;
+    collect: typeof collect;
+    commit: typeof commit;
+    concatenate: typeof concatenate;
+    condense: typeof condense;
+    convert: typeof convert;
+    createData: typeof createData;
+    deleteInternal: typeof deleteInternal;
+    describe: typeof describe;
+    find: typeof find;
+    getBit: typeof getBit;
+    readReport: typeof readReport;
+    getLocale: typeof getLocale;
+    getParameter: typeof getParameter;
+    getRunTime: typeof getRunTime;
+    getTime: typeof getTime;
+    insertInternal: typeof insertInternal;
+    loop: typeof loop;
+    modifyInternal: typeof modifyInternal;
+    moveCorresponding: typeof moveCorresponding;
+    overlay: typeof overlay;
+    raiseEvent: typeof raiseEvent;
+    readTable: typeof readTable;
+    replace: typeof replace;
+    rollback: typeof rollback;
+    setBit: typeof setBit;
+    setHandler: typeof setHandler;
+    setLocale: typeof setLocale;
+    shift: typeof shift;
+    sort: typeof sort;
+    split: typeof split;
+    translate: typeof translate;
+    wait: typeof wait;
+    receive: typeof receive;
+    callTransaction: typeof callTransaction;
+    private readonly context;
+    private readonly traceTotals;
+    constructor(context: Context);
+    private _trace;
+    private _traceAsync;
+    _setTrace(min?: number, totals?: boolean): void;
+    deleteDatabase(table: string | ICharacter, options: IDeleteDatabaseOptions): Promise<void>;
+    insertDatabase(table: string | ICharacter, options: IInsertDatabaseOptions): Promise<number | undefined>;
+    message(options: IMessageOptions): Promise<void>;
+    modifyDatabase(table: string | ICharacter, options: IModifyDatabaseOptions): Promise<void>;
+    select(target: Structure | Table | FieldSymbol, select: SelectDatabaseOptions, runtimeOptions?: SelectRuntimeOptions): Promise<void>;
+    updateDatabase(table: string | ICharacter, options: IUpdateDatabaseOptions): Promise<number>;
+    callFunction(options: ICallFunctionOptions): Promise<void>;
+    write(source: INumeric | ICharacter | FieldSymbol | string | number, options?: IWriteOptions): void;
+}

package/build/src/statements/insert_database.d.ts

@@ -0,0 +1,13 @@
+import { Context } from "../context";
+import { Structure, Table } from "../types";
+import { ICharacter } from "../types/_character";
+export declare function toValue(value: any): any;
+export interface IInsertDatabaseOptions {
+    values?: Structure;
+    table?: Table;
+}
+export declare class InsertDatabase {
+    private readonly context;
+    constructor(context: Context);
+    insertDatabase(table: string | ICharacter, options: IInsertDatabaseOptions): Promise<number | undefined>;
+}