@ugo-studio/jspp 0.1.2 → 0.1.4

package/src/prelude/library/console.hpp

@@ -1,57 +1,57 @@
 #pragma once
 
-#include "chrono"
+#include <chrono>
 #include "types.hpp"
 #include "values/non_values.hpp"
 #include "values/object.hpp"
 #include "values/function.hpp"
-#include "operators.hpp"
-#include "log_string.hpp"
+#include "utils/operators.hpp"
+#include "utils/log_any_value/log_any_value.hpp"
 
 #include <cmath>
 #include <sstream>
 #include <iomanip>
 
-static std::unordered_map<std::string, std::chrono::steady_clock::time_point> timers = {};
+static std::map<std::string, std::chrono::steady_clock::time_point> timers = {};
 
-auto logFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
+auto logFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
                                            {
                                                for (size_t i = 0; i < args.size(); ++i)
                                                {
-                                                   std::cout << jspp::LogString::to_log_string(args[i]);
+                                                   std::cout << jspp::LogAnyValue::to_log_string(args[i]);
                                                    if (i < args.size() - 1)
                                                        std::cout << " ";
                                                }
-                                               std::cout << "\n";
-                                               return jspp::AnyValue::make_undefined(); }, "");
-auto warnFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
+                                               std::cout << "\n" << std::flush;
+                                               return jspp::AnyValue::make_undefined(); }, "log");
+auto warnFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
                                             {
                                                 std::cerr << "\033[33m";
                                                 for (size_t i = 0; i < args.size(); ++i)
                                                 {
-                                                    std::cout << jspp::LogString::to_log_string(args[i]);
+                                                    std::cout << jspp::LogAnyValue::to_log_string(args[i]);
                                                     if (i < args.size() - 1)
                                                         std::cout << " ";
                                                 }
-                                                std::cerr << "\033[0m" << "\n"; // reset
-                                                return jspp::AnyValue::make_undefined(); }, "");
-auto errorFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
+                                                std::cerr << "\033[0m" << "\n" << std::flush; // reset
+                                                return jspp::AnyValue::make_undefined(); }, "warn");
+auto errorFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
                                              {
                                                  std::cerr << "\033[31m";
                                                  for (size_t i = 0; i < args.size(); ++i)
                                                  {
-                                                     std::cout << jspp::LogString::to_log_string(args[i]);
+                                                     std::cout << jspp::LogAnyValue::to_log_string(args[i]);
                                                      if (i < args.size() - 1)
                                                          std::cout << " ";
                                                  }
-                                                 std::cerr << "\033[0m" << "\n"; // reset
-                                                 return jspp::AnyValue::make_undefined(); }, "");
-auto timeFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
+                                                 std::cerr << "\033[0m" << "\n" << std::flush; // reset
+                                                 return jspp::AnyValue::make_undefined(); }, "error");
+auto timeFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
                                             {
                                                 auto start = std::chrono::steady_clock::now(); // capture immediately
                                                 auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";
                                                 timers[key_str] = start;
-                                                return jspp::AnyValue::make_undefined(); }, "");
+                                                return jspp::AnyValue::make_undefined(); }, "time");
 
 // helper to format duration in ms -> ms/s/m/h with nice precision
 static auto format_duration = [](double ms) -> std::string
@@ -83,7 +83,7 @@ static auto format_duration = [](double ms) -> std::string
     return ss.str();
 };
 
-auto timeEndFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
+auto timeEndFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args)
                                                {
                                                    auto end = std::chrono::steady_clock::now(); // capture immediately
                                                    auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";
@@ -100,7 +100,7 @@ auto timeEndFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyVal
                                                    {
                                                        std::cout << "Timer '" << key_str << "' does not exist." << "\n";
                                                    }
-                                                   return jspp::AnyValue::make_undefined(); }, "");
+                                                   return jspp::AnyValue::make_undefined(); }, "timeEnd");
 
 inline auto console = jspp::AnyValue::make_object({
     {"log", logFn},

package/src/prelude/library/error.hpp

@@ -0,0 +1,111 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+
+// Declare Error variable
+inline jspp::AnyValue Error;
+
+// Constructor logic
+inline auto errorConstructor = [](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args) -> jspp::AnyValue
+{
+    // Access global Error to get prototype
+    jspp::AnyValue proto = Error.get_own_property("prototype");
+
+    jspp::AnyValue target = thisVal;
+    bool is_construct_call = false;
+
+    if (target.is_object())
+    {
+        auto obj = target.as_object();
+        if (obj->proto && (*obj->proto).is_strictly_equal_to_primitive(proto))
+        {
+            is_construct_call = true;
+        }
+    }
+
+    if (!is_construct_call)
+    {
+        target = jspp::AnyValue::make_object_with_proto({}, proto);
+    }
+
+    std::string message = "";
+    if (!args.empty() && !args[0].is_undefined())
+    {
+        message = args[0].to_std_string();
+    }
+
+    target.define_data_property("message", jspp::AnyValue::make_string(message), true, false, true);
+    target.define_data_property("name", jspp::AnyValue::make_string("Error"), true, false, true);
+    target.define_data_property("stack", jspp::AnyValue::make_string("Error: " + message + "\n    at <unknown>"), true, false, true);
+
+    if (args.size() > 1 && args[1].is_object())
+    {
+        jspp::AnyValue cause = args[1].get_own_property("cause");
+        if (!cause.is_undefined())
+        {
+            target.define_data_property("cause", cause, true, false, true);
+        }
+    }
+
+    return target;
+};
+
+// Static Error.isError(val) implementation
+inline auto isErrorFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args) -> jspp::AnyValue
+                                                      {
+    if (args.empty()) return jspp::AnyValue::make_boolean(false);
+    
+    jspp::AnyValue val = args[0];
+    if (!val.is_object()) return jspp::AnyValue::make_boolean(false);
+    
+    // Check if it inherits from Error.prototype
+    // This is essentially 'instanceof Error'
+    jspp::AnyValue proto = Error.get_own_property("prototype");
+    
+    // Walk prototype chain
+    if (val.is_object()) {
+        auto current = val.as_object()->proto;
+        while (current && !(*current).is_null()) {
+             if ((*current).is_strictly_equal_to_primitive(proto)) return jspp::AnyValue::make_boolean(true);
+             if ((*current).is_object()) current = (*current).as_object()->proto;
+             else break;
+        }
+    }
+    
+    return jspp::AnyValue::make_boolean(false); }, "isError");
+
+// toString method for Error.prototype
+inline auto errorToStringFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &args) -> jspp::AnyValue
+                                                            {
+    std::string name = "Error";
+    std::string msg = "";
+    
+    jspp::AnyValue n = thisVal.get_own_property("name");
+    if (!n.is_undefined()) name = n.to_std_string();
+    
+    jspp::AnyValue m = thisVal.get_own_property("message");
+    if (!m.is_undefined()) msg = m.to_std_string();
+    
+    if (name.empty() && msg.empty()) return jspp::AnyValue::make_string("Error");
+    if (name.empty()) return jspp::AnyValue::make_string(msg);
+    if (msg.empty()) return jspp::AnyValue::make_string(name);
+    
+    return jspp::AnyValue::make_string(name + ": " + msg); }, "toString");
+
+// Initialize Error class and its prototype
+struct ErrorInit
+{
+    ErrorInit()
+    {
+        // Initialize Error class
+        Error = jspp::AnyValue::make_class(errorConstructor, "Error");
+
+        // Define Error.prototype.toString
+        auto proto = Error.get_own_property("prototype");
+        proto.define_data_property("toString", errorToStringFn, true, false, true);
+
+        // Define static Error.isError
+        Error.define_data_property("isError", isErrorFn,true ,false,true);
+    }
+} errorInit;

package/src/prelude/library/global.hpp

@@ -1,10 +1,21 @@
 #pragma once
 
 #include "types.hpp"
-#include "object.hpp"
-#include "console.hpp"
+#include "values/non_values.hpp"
+#include "values/object.hpp"
+#include "values/function.hpp"
+#include "utils/operators.hpp"
 
-inline auto global = jspp::Object::make_object({
+#include "library/promise.hpp"
+#include "library/timer.hpp"
+
+inline auto global = jspp::AnyValue::make_object({
     {"console", console},
+    {"performance", performance},
+    {"Error", Error},
+    {"Promise", Promise},
+    {"setTimeout", setTimeout},
+    {"clearTimeout", clearTimeout},
+    {"setInterval", setInterval},
+    {"clearInterval", clearInterval},
 });
-inline auto globalThis = global;

package/src/prelude/library/performance.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <chrono>
+#include "types.hpp"
+#include "values/non_values.hpp"
+#include "values/object.hpp"
+#include "values/function.hpp"
+#include "utils/operators.hpp"
+
+inline auto performance = jspp::AnyValue::make_object({
+    {"now",
+     jspp::AnyValue::make_function(
+         // [C++14 Feature] Generalized Lambda Capture
+         // We initialize 'startTime' RIGHT HERE inside the [].
+         // It acts like a private variable stored inside this specific function.
+         [startTime = std::chrono::steady_clock::now()](const jspp::AnyValue &thisVal, const std::vector<jspp::AnyValue> &)
+         {
+             // We calculate the diff against the captured startTime
+             std::chrono::duration<double, std::milli> duration =
+                 std::chrono::steady_clock::now() - startTime;
+
+             return jspp::AnyValue::make_number(duration.count());
+         },
+         "now")},
+});

package/src/prelude/library/promise.hpp

@@ -0,0 +1,121 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/promise.hpp"
+#include "any_value.hpp"
+#include "exception.hpp"
+
+inline auto Promise = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+    if (args.empty() || !args[0].is_function()) {
+        throw jspp::Exception::make_exception("Promise resolver undefined is not a function", "TypeError");
+    }
+    auto executor = args[0].as_function();
+
+    jspp::JsPromise promise;
+    auto state = promise.state; // Share state
+
+    // resolve function
+    auto resolveFn = jspp::AnyValue::make_function([state](const jspp::AnyValue&, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+        jspp::JsPromise p; p.state = state;
+        p.resolve(args.empty() ? jspp::AnyValue::make_undefined() : args[0]);
+        return jspp::AnyValue::make_undefined();
+    }, "resolve");
+
+    // reject function
+    auto rejectFn = jspp::AnyValue::make_function([state](const jspp::AnyValue&, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+        jspp::JsPromise p; p.state = state;
+        p.reject(args.empty() ? jspp::AnyValue::make_undefined() : args[0]);
+        return jspp::AnyValue::make_undefined();
+    }, "reject");
+
+    try {
+        executor->call(jspp::AnyValue::make_undefined(), {resolveFn, rejectFn});
+    } catch (const jspp::Exception& e) {
+        promise.reject(*e.data);
+    } catch (...) {
+        promise.reject(jspp::AnyValue::make_string("Unknown error during Promise execution"));
+    }
+
+    return jspp::AnyValue::make_promise(promise);
+
+}, "Promise");
+
+struct PromiseInit {
+    PromiseInit() {
+        // Promise.resolve(value)
+        Promise.define_data_property("resolve", jspp::AnyValue::make_function([](const jspp::AnyValue&, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+            jspp::JsPromise p;
+            p.resolve(args.empty() ? jspp::AnyValue::make_undefined() : args[0]);
+            return jspp::AnyValue::make_promise(p);
+        }, "resolve"));
+
+        // Promise.reject(reason)
+        Promise.define_data_property("reject", jspp::AnyValue::make_function([](const jspp::AnyValue&, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+            jspp::JsPromise p;
+            p.reject(args.empty() ? jspp::AnyValue::make_undefined() : args[0]);
+            return jspp::AnyValue::make_promise(p);
+        }, "reject"));
+        
+        // Promise.all(iterable)
+        Promise.define_data_property("all", jspp::AnyValue::make_function([](const jspp::AnyValue&, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+             // Basic implementation for arrays
+             if (args.empty() || !args[0].is_array()) {
+                  // If not array, reject? Or treat as non-iterable?
+                  // Should throw TypeError if not iterable. For now assume array.
+                  // If empty array, return resolved empty array.
+                  // TODO: Strict iterable check
+             }
+             
+             // Handle non-array iterable or empty args
+             if (args.empty() || !args[0].is_array()) {
+                 jspp::JsPromise p; p.reject(jspp::AnyValue::make_string("Promise.all argument must be an array"));
+                 return jspp::AnyValue::make_promise(p);
+             }
+
+             auto arr = args[0].as_array();
+             size_t len = arr->length;
+             if (len == 0) {
+                 jspp::JsPromise p; p.resolve(jspp::AnyValue::make_array({}));
+                 return jspp::AnyValue::make_promise(p);
+             }
+
+             jspp::JsPromise masterPromise;
+             auto masterState = masterPromise.state;
+             
+             auto results = std::make_shared<std::vector<std::optional<jspp::AnyValue>>>(len);
+             auto count = std::make_shared<size_t>(len);
+             
+             // Check if already rejected to avoid further processing
+             auto rejected = std::make_shared<bool>(false);
+
+             for (size_t i = 0; i < len; ++i) {
+                 jspp::AnyValue item = arr->get_property(static_cast<uint32_t>(i));
+                 
+                 auto handleResult = [masterState, results, count, i, rejected](jspp::AnyValue res) {
+                      if (*rejected) return;
+                      (*results)[i] = res;
+                      (*count)--;
+                      if (*count == 0) {
+                          jspp::JsPromise p; p.state = masterState;
+                          p.resolve(jspp::AnyValue::make_array(*results)); 
+                      }
+                 };
+                 
+                 auto handleReject = [masterState, rejected](jspp::AnyValue reason) {
+                      if (*rejected) return;
+                      *rejected = true;
+                      jspp::JsPromise p; p.state = masterState;
+                      p.reject(reason);
+                 };
+
+                 if (item.is_promise()) {
+                     item.as_promise()->then(handleResult, handleReject);
+                 } else {
+                     handleResult(item);
+                 }
+             }
+             
+             return jspp::AnyValue::make_promise(masterPromise);
+        }, "all"));
+    }
+} promiseInit;

package/src/prelude/library/symbol.hpp

@@ -1,8 +1,64 @@
 #pragma once
 
 #include "types.hpp"
-#include "object.hpp"
-#include "well_known_symbols.hpp"
+#include "utils/well_known_symbols.hpp"
 
-inline auto Symbol = jspp::Object::make_object({{"iterator", jspp::Object::make_string(jspp::WellKnownSymbols::iterator)},
-                                                {"toString", jspp::Object::make_string(jspp::WellKnownSymbols::toString)}});
+#include "values/object.hpp"
+#include "any_value.hpp"
+
+inline auto Symbol = jspp::AnyValue::make_object({
+    {"iterator", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::iterator)},
+});
+
+// #pragma once
+
+// #include "types.hpp"
+// #include "utils/well_known_symbols.hpp"
+// #include "values/object.hpp"
+// #include "any_value.hpp"
+
+// // We define the Symbol constructor function
+// inline auto symbolConstructor = [](const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+//     std::string desc = "";
+//     if (!args.empty() && !args[0].is_undefined()) {
+//         desc = args[0].to_std_string();
+//     }
+//     return jspp::AnyValue::make_symbol(desc);
+// };
+
+// inline auto Symbol = jspp::AnyValue::make_function(symbolConstructor, "Symbol");
+
+// // Implementation of Symbol.for(key)
+// inline auto forFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+//     std::string key = "";
+//     if (!args.empty()) {
+//         key = args[0].to_std_string();
+//     }
+//     auto symPtr = jspp::JsSymbol::for_global(key);
+//     return jspp::AnyValue::from_symbol(symPtr);
+// }, "for");
+
+// // Implementation of Symbol.keyFor(sym)
+// inline auto keyForFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+//     if (args.empty() || !args[0].is_symbol()) {
+//         throw jspp::Exception::make_exception("Symbol.keyFor requires a symbol argument", "TypeError");
+//     }
+
+//     jspp::JsSymbol* sym = args[0].as_symbol();
+//     auto result = jspp::JsSymbol::key_for(sym);
+
+//     if (result.has_value()) {
+//         return jspp::AnyValue::make_string(result.value());
+//     } else {
+//         return jspp::AnyValue::make_undefined();
+//     }
+// }, "keyFor");
+
+// // Attach static properties/methods to the Symbol object
+// struct SymbolInit {
+//     SymbolInit() {
+//         Symbol.set_own_property("iterator", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::iterator));
+//         Symbol.set_own_property("for", forFn);
+//         Symbol.set_own_property("keyFor", keyForFn);
+//     }
+// } symbolInit;

package/src/prelude/library/timer.hpp

@@ -0,0 +1,92 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "scheduler.hpp"
+#include "values/function.hpp"
+#include "exception.hpp"
+
+// setTimeout(callback, delay, ...args)
+inline auto setTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+    if (args.empty() || !args[0].is_function()) {
+        throw jspp::Exception::make_exception("Callback must be a function", "TypeError");
+    }
+    
+    auto callback = args[0];
+    double delay = 0;
+    if (args.size() > 1 && args[1].is_number()) {
+        delay = args[1].as_double();
+    }
+    
+    // Capture arguments
+    std::vector<jspp::AnyValue> callArgs;
+    for (size_t i = 2; i < args.size(); ++i) {
+        callArgs.push_back(args[i]);
+    }
+
+    auto task = [callback, callArgs]() {
+         try {
+             callback.as_function()->call(jspp::AnyValue::make_undefined(), callArgs);
+         } catch (const jspp::Exception& e) {
+             std::cerr << "Uncaught exception in setTimeout: " << e.what() << "\n";
+         } catch (const std::exception& e) {
+             std::cerr << "Uncaught exception in setTimeout: " << e.what() << "\n";
+         } catch (...) {
+             std::cerr << "Uncaught unknown exception in setTimeout\n";
+         }
+    };
+
+    size_t id = jspp::Scheduler::instance().set_timeout(task, static_cast<size_t>(delay));
+    return jspp::AnyValue::make_number(static_cast<double>(id));
+}, "setTimeout");
+
+// clearTimeout(id)
+inline auto clearTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+    if (!args.empty() && args[0].is_number()) {
+        size_t id = static_cast<size_t>(args[0].as_double());
+        jspp::Scheduler::instance().clear_timer(id);
+    }
+    return jspp::AnyValue::make_undefined();
+}, "clearTimeout");
+
+// setInterval(callback, delay, ...args)
+inline auto setInterval = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+    if (args.empty() || !args[0].is_function()) {
+        throw jspp::Exception::make_exception("Callback must be a function", "TypeError");
+    }
+    
+    auto callback = args[0];
+    double delay = 0;
+    if (args.size() > 1 && args[1].is_number()) {
+        delay = args[1].as_double();
+    }
+    
+    std::vector<jspp::AnyValue> callArgs;
+    for (size_t i = 2; i < args.size(); ++i) {
+        callArgs.push_back(args[i]);
+    }
+
+    auto task = [callback, callArgs]() {
+         try {
+             callback.as_function()->call(jspp::AnyValue::make_undefined(), callArgs);
+         } catch (const jspp::Exception& e) {
+             std::cerr << "Uncaught exception in setInterval: " << e.what() << "\n";
+         } catch (const std::exception& e) {
+             std::cerr << "Uncaught exception in setInterval: " << e.what() << "\n";
+         } catch (...) {
+             std::cerr << "Uncaught unknown exception in setInterval\n";
+         }
+    };
+
+    size_t id = jspp::Scheduler::instance().set_interval(task, static_cast<size_t>(delay));
+    return jspp::AnyValue::make_number(static_cast<double>(id));
+}, "setInterval");
+
+// clearInterval(id)
+inline auto clearInterval = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+    if (!args.empty() && args[0].is_number()) {
+        size_t id = static_cast<size_t>(args[0].as_double());
+        jspp::Scheduler::instance().clear_timer(id);
+    }
+    return jspp::AnyValue::make_undefined();
+}, "clearInterval");