@abaplint/runtime 2.7.57 → 2.7.59

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

@@ -1,7 +1,8 @@
 import { Context } from "../context";
 export interface ICallFunctionOptions {
     name: string;
-    destination: string;
+    destination?: string;
+    calling?: (INPUT: any) => any;
     exporting?: any;
     importing?: any;
     tables?: any;

package/build/src/statements/call_function.js

@@ -1,35 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CallFunction = void 0;
+const types_1 = require("../types");
+const receive_1 = require("./receive");
 class CallFunction {
     constructor(context) {
         this.context = context;
     }
     // note: this is only called if DESTINIATION is supplied
     async callFunction(options) {
-        if (options.destination.trim() === "") {
-            const param = {
+        const param = {
+            exporting: options.exporting,
+            importing: options.importing,
+            tables: options.tables,
+            changing: options.changing,
+            exceptions: options.exceptions,
+        };
+        options.name = options.name.trimEnd();
+        if (options.destination) {
+            if (options.destination.trim() === "") {
+                // @ts-ignore
+                await abap.FunctionModules[options.name](param);
+                return;
+            }
+            const dest = this.context.RFCDestinations[options.destination];
+            if (dest === undefined) {
+                throw new Error(`RFC destination ${options.destination} does not exist`);
+            }
+            await dest.call(options.name, {
                 exporting: options.exporting,
                 importing: options.importing,
                 tables: options.tables,
                 changing: options.changing,
                 exceptions: options.exceptions,
-            };
+            });
+        }
+        else if (options.calling) {
             // @ts-ignore
             await abap.FunctionModules[options.name](param);
-            return;
+            // save importing + tables + changing + exception for RECEIVE RESULTS
+            (0, receive_1._receiveSetResult)(param);
+            // call the callback, async
+            options.calling({ p_task: new types_1.Character(8).set("OPENABAP") });
         }
-        const dest = this.context.RFCDestinations[options.destination];
-        if (dest === undefined) {
-            throw new Error(`RFC destination ${options.destination} does not exist`);
+        else {
+            throw new Error("runtime: callFunction, unexpected input");
         }
-        await dest.call(options.name, {
-            exporting: options.exporting,
-            importing: options.importing,
-            tables: options.tables,
-            changing: options.changing,
-            exceptions: options.exceptions,
-        });
     }
 }
 exports.CallFunction = CallFunction;

package/build/src/statements/convert.js

@@ -16,6 +16,9 @@ function convert(source, target) {
         else {
             date = source.date.get();
         }
+        if (date.trimEnd() === "") {
+            date = "00000000";
+        }
     }
     let time = "";
     if (source.time) {

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

@@ -16,6 +16,7 @@ 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";
@@ -35,6 +36,7 @@ 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";
@@ -83,6 +85,8 @@ export declare class Statements {
     sort: typeof sort;
     split: typeof split;
     translate: typeof translate;
+    wait: typeof wait;
+    receive: typeof receive;
     private readonly context;
     private readonly traceTotals;
     constructor(context: Context);

package/build/src/statements/index.js

@@ -19,6 +19,7 @@ const cast_1 = require("./cast");
 const get_bit_1 = require("./get_bit");
 const read_report_1 = require("./read_report");
 const raise_event_1 = require("./raise_event");
+const receive_1 = require("./receive");
 const get_locale_1 = require("./get_locale");
 const get_parameter_1 = require("./get_parameter");
 const set_locale_1 = require("./set_locale");
@@ -39,6 +40,7 @@ const select_1 = require("./select");
 const set_bit_1 = require("./set_bit");
 const shift_1 = require("./shift");
 const sort_1 = require("./sort");
+const wait_1 = require("./wait");
 const set_handler_1 = require("./set_handler");
 const split_1 = require("./split");
 const translate_1 = require("./translate");
@@ -86,6 +88,8 @@ class Statements {
         this.sort = sort_1.sort;
         this.split = split_1.split;
         this.translate = translate_1.translate;
+        this.wait = wait_1.wait;
+        this.receive = receive_1.receive;
         this.context = context;
         this.traceTotals = {};
     }

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

@@ -0,0 +1,9 @@
+export interface IReceiveOptions {
+    exporting?: any;
+    importing?: any;
+    tables?: any;
+    changing?: any;
+    exceptions?: any;
+}
+export declare function _receiveSetResult(options: IReceiveOptions): void;
+export declare function receive(options: IReceiveOptions): void;

package/build/src/statements/receive.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.receive = exports._receiveSetResult = void 0;
+let cache = undefined;
+function _receiveSetResult(options) {
+    cache = options;
+}
+exports._receiveSetResult = _receiveSetResult;
+function receive(options) {
+    if (cache === undefined) {
+        throw new Error("runtime receive(), no results");
+    }
+    for (const a in cache.importing || []) {
+        const aval = cache.importing[a];
+        const bval = options.importing[a];
+        if (bval === undefined) {
+            continue;
+        }
+        bval.set(aval);
+    }
+    for (const a in cache.tables || []) {
+        const aval = cache.tables[a];
+        const bval = options.tables[a];
+        if (bval === undefined) {
+            continue;
+        }
+        bval.set(aval);
+    }
+    for (const a in cache.changing || []) {
+        const aval = cache.changing[a];
+        const bval = options.changing[a];
+        if (bval === undefined) {
+            continue;
+        }
+        bval.set(aval);
+    }
+    cache = undefined;
+}
+exports.receive = receive;
+//# sourceMappingURL=receive.js.map

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

@@ -0,0 +1,5 @@
+import { INumeric } from "../types/_numeric";
+export declare function wait(options: {
+    cond: () => any;
+    seconds?: INumeric;
+}): Promise<void>;

package/build/src/statements/wait.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wait = void 0;
+async function wait(options) {
+    await new Promise(r => setTimeout(r, 50));
+    while (true) {
+        if (options.cond() === true) {
+            break;
+        }
+        await new Promise(r => setTimeout(r, 500));
+        console.log("WAIT waiting another round");
+    }
+}
+exports.wait = wait;
+//# sourceMappingURL=wait.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/runtime",
-  "version": "2.7.57",
+  "version": "2.7.59",
   "description": "Transpiler - Runtime",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",