Ts support

[Sinfolke]

Would be good if the compiler support the default ts syntax with console class etc... And the advanced syntax on user requirements. For example implement a regular console class and do not require main function.

Console class:

#include <iostream>
#include <string>

class Console {
public:
    // Constructor
    Console(std::ostream& outStream, std::ostream& errStream = std::cerr, bool ignoreErrors = false)
        : stdoutStream(outStream), stderrStream(errStream), ignoreErrors(ignoreErrors) {}
    template <typename... Args>
    void log(const Args&... args) {
        logInternal(stdoutStream, args...);
    }
    template <typename... Args>
    void error(const Args&... args) {
        if (!ignoreErrors) {
            logInternal(stderrStream, args...);
        }
    }
    void error(std::string message, const long long int& code){
     if (!ignoreErrors) {
       // Replace all occurrences of %d with error code
       size_t found = message.find("%d");
        while (found != std::string::npos) {
             message.replace(found, 2, std::to_string(code));
             found = message.find("%d", found + 1);
         }
       logInternal(stderrStream, message);
     }
    }
    // Assert condition and display message if false
    template <typename... Args>
    void assert(bool condition, Args& ... args) {
        if (!condition) {
            logInternal(stderrStream, "Assertion failed: ", args...);
        }
    }
   void clear() {
      #ifdef _WIN32
          system("cls");
      #else
          system("clear");
      #endif
   }

private:
    std::ostream& stdoutStream;
    std::ostream& stderrStream;
    bool ignoreErrors;
    struct Color {
        const std::string white = "\033[1;37m";
        const std::string yellow = "\033[1;33m";
        const std::string red = "\033[1;31m";
    };
    template <typename T, typename... Args>
    void logInternal(std::ostream& stream, const T& value, const Args&... args) {
        const std::string type = typeid(value).name();
        if (type == "bool" || type == "int" /*and other regular types*/) {
            stream << colors.yellow << value << colors.white;
        } else if (std::is_same<std::string, decltype(value)>::value) {
             // a regular string value 
             stream << value;
        } else {
             // not regular value (Array etc...)
             stream << "<" + type + ">";
        }
        stream << "\n";
        logInternal(stream, args...);
    }

    void logInternal(std::ostream&) {}
  };
}


// instance the console
Console console(std::cout);

Now the user can use console features and not 'print'. This means that the ts checker will not argue with code and you can compiler code that was not made for tsc.exe

function main() {
    // user can declare optional console instance.
    // following documentation this way:
    const output = fs.createWriteStream('./stdout.log');
    const errorOutput = fs.createWriteStream('./stderr.log');
    const anotherConsole = new Console(output, errorOutput, false)
    console.log("Hello, ", "world!");
    console.error("An error occurred.");

    anotherConsole.log("The message of another console");
    return 0;
}

I don't know whether you can add c++ code. But i can write more if you need.

Since the main function is simply the whole ts file, compiler can simply raise top functions and classes and automatically surround remaining code into main function. For example (as c++ but could be another language for your compiler):

   function hello() {
       console.log("Hello, world!");
   }
   class aClass {
    // class body...
   }
   // declare a variable
   const a = 0;
   console.log("outing hello...");
   hello();
   console.log("exiting...");

result:

  void hello() {
      std::cout << "Hello, world!" << "\n";
  }
  class aClass {
      // class body...
  }
  const auto a = 0;
  int main() {
     std::cout << "outing hello..." << "\n";
     hello();
     std::cout << "exiting..." << "\n";
  }

[ASDAlexander77]

because of C++ naming, easy would be to create C wrapper

extern "C" console_log(const char* msg)
{
  std::cout << msg << "\n";
}

then in TypeScript

declare function console_log(msg: string);

class console
{
    static const log = (msg:string) => console_log(msg);
}

function main1()
{
  console.log("Hello World");
}

[Sinfolke]

I haven't wholly understood what does this do but what i've understood:
Using the extern "C" we can write a library for C code. Maybe C don't have class feature so the class console is declared in the ts code.

I should instead of class write separate functions separating _ name of method and 'console'. Then the compiler will use result library in C code of ts file. The class console will automatically be generated providing log features.

[ASDAlexander77]

yes, so C compiler is generating OBJ file and TSC is generating OBJ file, but how 1 object file knows about other functions from other object file? yes, you need to provide "declare function" for it, thus TS Obj file will not about C external function. so when you provide 2 OBJs files to the "linker" linker will resolve names.

[Sinfolke]

I've also looked and turned out it is possible to use c++ classes in C. Example:
Console.hpp:

#include <iostream>
extern "C" {
typedef struct Console Console;

// Factory function
Console* console_constructor(std::ostream* outStream, std::ostream* errStream, bool ignoreErrors);
}

Console.cpp:

#include "Console.hpp"

struct Console {
    std::ostream* outStream;
    std::ostream* errStream;
    bool ignoreErrors;
    // ... log functions
};

Console* console_constructor(std::ostream* outStream, std::ostream* errStream, bool ignoreErrors) {
    Console* console = new Console;
    console->outStream = outStream;
    console->errStream = errStream;
    console->ignoreErrors = ignoreErrors;
    return console;
}

The final C code:

  #include "Console.hpp"
   Console* console = console_constructor(&std::cout, &std::cerr, false);

So we might not need to include something additional into ts code.

[Sinfolke]

I have made a pattern of console object. But the issue is that it is hard to declare console in ts if build it following documentation (with different streams etc.).

If try to wholy build the console in c++ code then the issue is when i need to create an object, where colorMode key must be either boolean or string. So it would require the tsc feature. Maybe create such object in ts and use in c++ code like library...

If create the class in ts using just library, then i don't know how to make stream there (cout, cerr).

Firstly i did feature wholy on c++ but when was need to use non-staric types i did like in your example.

Console.zip

[Sinfolke]

This is attempt to create at c++
(Console.zip)

But the issue with dynamic object. To wholly implement console as in regular js must be access to tsc features.

So for now i can create a library for structure only which will not support constructor and custom output. Since the custom console features are almost never used this would be enough for most ts code. (doing).

[Sinfolke]

Please, check if i'm doing the console correctly

Console.zip

[ASDAlexander77]

difficult to say, if it was me I would use https://github.com/microsoft/TypeScript/tree/main/src/lib as template of methods.

You need to create tests for your code and validate it against tests

[Sinfolke]

That code worked well on c++ but i guess there will be confusions with ts custom types and standard static. So it is better to write it on ts and compile as library.

There is also console implementation in standard node libraries: https://github.com/nodejs/node/tree/main/lib

So it is possible to transform entire console, just write in ts syntax. But i looked it is complex and the compiler might not compile.
For first you can try to use the c++ console (it works well in c++ and has 4 methods: log, assert, clear and count).But again i'm not now sure if those static types could be used for ts types).
Console.zip

I also had think about minimal console, which might have the main console features. The entire console is rarely used so the minimal console could be useful. Just it would lead to a bit faster code due remaining the only main features.
(Required: String function, unshift and splice array methods, NaN.isNaN()),
ConsoleTs.zip

But, you may don't do anything with this 😂. The purpose of this discussion that i think the native features of ts should be supported and would be better to make use some compiler flags or something else that would define whether code is for custom/native syntax. So if you think this is early to create build in classes and objects (some general syntax is remained not implemented) no need to do something with this all.

[ASDAlexander77]

yes, good to know, I agree I don't think it would be effortless to compile console.js in typescript. it will require some adjustments for sure

[ASDAlexander77]

So if you think this is early to create build in classes and objects (some general syntax is remained not implemented) no need to do something with this all.

not it is not early but I think we need to implement our code for JavaScript libs and I don't think we can just copy/paste code from "node"

[Sinfolke]

I think it would be easer to re write either than try to compile existing. And if cover seriously then a new branch must be created. This way the console is not the first object to implement because it is related with another one (util). I guess they must be provided as library and not as C code because to implement must be mixed C and ts. With library it would be easy for compiler to use because just include reference during compilation and include file described library. But another hand if the library is provided with native code, it is easy possible to optimise as possible more. For example, if a user did used in console the log and error methods only, the result object would have only those methods included.

However i guess this would require the most language features implemented.

[ASDAlexander77]

well, compiler is ready it can handle any scenario. but if to write "javascript lib" we should start not from console but from "array" implementation as current output is enough to have "console log"

[Sinfolke]

I have found out the Math object is the one of which does not require other js build in features. I have made it mixing ts and c++ with both ts and c docs depends will it be used as library or remain with source code

Math.zip

[Sinfolke]

Keep in mind it does also require 'Infinity" and '-Infinity' types

[ASDAlexander77]

can be used the following const Infinity = 1 / 0;

[Sinfolke]

With correct 'Infinity' constant support.
Math.zip