the following two examples give different outputs, it should not

output = 100 * noun + verb.
output = ( 100 * noun ) + verb.

keep interfaces for constants

types+methods should still be ignored

https://sourcemaps.info/spec.html

https://www.bugsnag.com/blog/source-maps

Code at https://github.com/larshp/abapGit/blob/master/src/zlib/ is quite nice, as its just logic, no real dependencies, and it has real unit tests

https://github.com/larshp/abapGit/blob/master/src/zlib/zcl_abapgit_zlib_convert.clas.abap

https://github.com/larshp/abapGit/blob/master/src/zlib/zcl_abapgit_zlib_huffman.clas.abap

https://github.com/larshp/abapGit/blob/master/src/zlib/zcl_abapgit_zlib_stream.clas.abap

something is missing, or I dont know how it should work 😄

Probably easier now than later.
Proposal: async and promise everything

Out of curiosity, how come you came up with this project?
What does it do, simply a transform like: ABAP => Java => Output?

I began to learn ABAP recently and reluctantly, and found this project quite amazing. But ABAP is not a popular language.
Why you are willing to work on this project?

currently its not possible to have an ABAP variable called if

as IF is a javascript keyword

remove this restriction by automatically renaming all identifiers that clash with JS

workaround: add local variable

initialize database

simulate TADIR?

cl_aunit_prog_info=>get_program_info

https://www.sqlite.org/index.html
https://caniuse.com/#search=web%20sql
https://cdnjs.com/libraries/sql.js
https://cdnjs.com/libraries/alasql
https://github.com/nolanlawson/node-websql

but I dont want some stupid large dependency

lines is a ddic string_table,

    DATA(lines) = get_lines( input ).

    LOOP AT lines INTO DATA(lv_line).

lv_line becomes a table, should be typed like the table row,

    let lines = new abap.types.Table(new abap.types.String());
    let lv_line = new abap.types.Table(new abap.types.String());

workaround: don't inline lv_line

probably a bug in abaplint

😄

DATA lv_int TYPE i.
lv_int = 5 / 2.
ASSERT lv_int = 3.
lv_int = 100 / 99.
ASSERT lv_int = 1.

LOOP AT inputtab INTO DATA(string2) WHERE table_line <> string1.

is transpiled to:

    for (let unique3 of inputtab.array()) {
      string1.set(unique3);

so the "WHERE" part is ignored here

plus call stack

plus continue with next test after failed test

https://chromium.googlesource.com/chromium/src/+/refs/tags/66.0.3359.15/docs/testing/json_test_results_format.md
https://testanything.org
https://github.com/marketplace/actions/publish-unit-test-results
https://www.ibm.com/support/knowledgecenter/en/SSQ2R2_14.1.0/com.ibm.rsar.analysis.codereview.cobol.doc/topics/cac_useresults_junit.html
https://help.catchsoftware.com/display/ET/JUnit+Format

https://github.com/lukejpreston/xunit-viewer

https://github.com/allure-framework/allure2

https://github.com/marketplace/actions/allure-report-with-history

https://github.com/allure-framework/allure-js

ExecutableItem

https://xunit.net/docs/format-xml-v2

you need to install latest allure commandline https://docs.qameta.io/allure/2.0/#_installing_a_commandline , then simply generate the report using $ allure generate /path/to/directory/with/xunit/results command

https://github.com/AleksiyVoynov/demo/tree/master/plugins/xunit-xml-plugin/src/test/resources/xunitdata

if the transparent table exists

snip, see below

lv_iterations = ev_size DIV lv_length.

IF foo NOT BETWEEN 5 AND 10.
is transpiled to:
if (abap.compare.between(foo, constant_5, constant_10)) {

Adding parantheses helps...
IF NOT ( foo BETWEEN 5 AND 10 ).
transpiles to:
if (!(abap.compare.between(foo, constant_5, constant_10))) {

When transpiling as part of a build, it is essential to know whether the input could be transpiled "properly".

workaround: just loop everything

  it("READ TABLE WITH KEY", async () => {
    const code = `
TYPES: BEGIN OF ty_structure,
         field TYPE i,
       END OF ty_structure.

DATA tab TYPE STANDARD TABLE OF ty_structure WITH DEFAULT KEY.
DATA line LIKE LINE OF tab.

line-field = 2.
APPEND line TO tab.
line-field = 5.
APPEND line TO tab.
ASSERT lines( tab ) = 2.

CLEAR line.

READ TABLE tab INTO line WITH KEY field = 2.
ASSERT sy-subrc = 0.
ASSERT line-field = 2.

READ TABLE tab INTO line WITH KEY field = 123.
ASSERT sy-subrc = 4.`;
    const js = await run(code);
    const f = new Function("abap", js);
    f(abap);
  });

its difficult due to how node handles modules

can import be used instead of require in the transpiler?

SPLIT input AT |\n| INTO TABLE DATA(table).

if input is empty, then the table should also be empty

The following fails. Each class definition transpiles OK individually.

    CLASS zcl_ret DEFINITION.
      PUBLIC SECTION.
        DATA bar TYPE i.
        CLASS-METHODS
          foo
            IMPORTING
              iv_imp type string
            RETURNING
              VALUE(rv_ret) type string.
    ENDCLASS.
    CLASS zcl_ret IMPLEMENTATION.
      METHOD foo.
        rv_ret = 'X'.
      ENDMETHOD.
    ENDCLASS.
    CLASS zcl_ret2 DEFINITION.
      PUBLIC SECTION.
        DATA bar TYPE i.
        CLASS-METHODS
          blahblah
            IMPORTING
              iv_imp type string
            RETURNING
              VALUE(rv_ret) type string.
    ENDCLASS.
    CLASS zcl_ret2 IMPLEMENTATION.
      METHOD blahblah.
        rv_ret = iv_imp.
      ENDMETHOD.
    ENDCLASS.
    DATA foo TYPE REF TO zcl_ret2.
    CREATE OBJECT foo.
    WRITE foo->blahblah( iv_imp = 'Y' ).

https://github.com/abaplint/transpiler/blob/master/packages/runtime/src/statements/find.ts

abap is not case sensitive, but js is

The following ABAP snippet:

a = a * b + c * d.

is transpiled to the following JavaScript code:

a.set(a.multiply(b.add(c.multiply(d))));

If you set a, b, c, d to 2, 3, 4, 5, the result of the transpiled expression will be 2 * (3 + (4 * 5) = 46, due to the way the expression is constructed. The correct result would be 26.

This happens because the syntax tree abaplint creates for this expression looks like this:

    CLASS zcl_ret DEFINITION.
      PUBLIC SECTION.
        DATA bar TYPE i.
        CLASS-METHODS:
          run RETURNING VALUE(rv_ret) TYPE string.
    ENDCLASS.

    CLASS zcl_ret IMPLEMENTATION.
      METHOD run.
        rv_ret = 'X'.
      ENDMETHOD.
    ENDCLASS.

is transpiled to

class zcl_ret {
  constructor() {
    this.bar = new abap.types.Integer();
  }
  run() {
    let rv_ret = new abap.types.String();
    rv_ret.set('X');
    return rv_ret;
  }
}

But it should be transpiled to the following or similar.

class zcl_ret {
  constructor() {
    this.bar = new abap.types.Integer();
  }
  static run() {
    let rv_ret = new abap.types.String();
    rv_ret.set('X');
    return rv_ret;
  }
}

https://www.w3schools.com/js/js_reserved.asp

probably a new rule "forbidden_identifiers" in abaplint

        FIND REGEX ' (\d+) (\w+ \w+)' IN lv_line
          MATCH OFFSET DATA(lv_offset)
          MATCH LENGTH DATA(lv_length)
          SUBMATCHES DATA(lv_count) lv_color.

to
abap.statements.find(lv_line, {regex: ' (\\d+) (\\w+ \\w+)', offset: lv_offset, length: lv_length, submatches: [lv_offset,lv_length,lv_count,lv_color]});

https://github.com/open-abap/cloudflare-abap-template/blob/master/index.js#L9

so

const response = new handler.zcl_handler().zif_abap_serverless_v1$run({

can be

const response = new handler.zcl_handler().run({

DATA table TYPE STANDARD TABLE OF string.
DATA declared_line TYPE string.

" These works just fine:
LOOP AT table INTO declared_line.
LOOP AT table REFERENCE INTO declared_line.
LOOP AT table INTO DATA(inline_1).

" This one does not:
LOOP AT table REFERENCE INTO DATA(inline_2).

Workarounds are plenty.

see #9

note that the repo contains 2 packages

and the packages are scoped "@abaplint/sdfds"

In order to pass structures into a method (e. g. request of the serverless API), setting them is necessary.

    TYPES: BEGIN OF ty_http,
             headers TYPE ty_headers,
             body    TYPE string,
    END OF ty_http.

    METHODS:
      run
        IMPORTING
          method      TYPE string OPTIONAL
          path        TYPE string OPTIONAL
          query       TYPE string OPTIONAL
          request     TYPE ty_http OPTIONAL

Currently, the following transpiled code fails:

class zcl_handler {
  run(unique1) {
    ...
    let request = new abap.types.Structure({headers: new abap.types.Table(), body: new abap.types.String()});
    if (unique1 && unique1.request) {request.set(unique1.request);}

(node:19352) UnhandledPromiseRejectionWarning: TypeError: request.set is not a function

Which is understandable, since set is currently commented out

currently the parameter names must be mentioned when passing data to methods