@ugo-studio/jspp 0.3.0 → 0.3.1

package/src/prelude/library/performance.cpp

@@ -0,0 +1,21 @@
+#include "jspp.hpp"
+#include "library/performance.hpp"
+#include <chrono>
+
+namespace jspp
+{
+
+    AnyValue performance = jspp::AnyValue::make_object({
+        {"now",
+         jspp::AnyValue::make_function(
+             [startTime = std::chrono::steady_clock::now()](jspp::AnyValue, std::span<const jspp::AnyValue>)
+             {
+                 std::chrono::duration<double, std::milli> duration =
+                     std::chrono::steady_clock::now() - startTime;
+
+                 return jspp::AnyValue::make_number(duration.count());
+             },
+             "now")},
+    });
+
+} // namespace jspp

package/src/prelude/library/performance.hpp

@@ -1,25 +1,10 @@
 #pragma once
 
-#include <chrono>
 #include "types.hpp"
-#include "values/non_values.hpp"
-#include "values/object.hpp"
-#include "values/function.hpp"
-#include "utils/operators.hpp"
+#include "any_value.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()](jspp::AnyValue, std::span<const jspp::AnyValue>)
-         {
-             // We calculate the diff against the captured startTime
-             std::chrono::duration<double, std::milli> duration =
-                 std::chrono::steady_clock::now() - startTime;
+namespace jspp {
+    extern AnyValue performance;
+}
 
-             return jspp::AnyValue::make_number(duration.count());
-         },
-         "now")},
-});
+using jspp::performance;

package/src/prelude/library/process.cpp

@@ -0,0 +1,38 @@
+#include "jspp.hpp"
+#include "library/process.hpp"
+
+#ifdef _WIN32
+#define JSPP_PLATFORM "win32"
+#else
+#define JSPP_PLATFORM "linux"
+#endif
+
+namespace jspp {
+
+AnyValue process = jspp::AnyValue::make_object({
+    {"argv", jspp::AnyValue::make_array(std::vector<jspp::AnyValue>{})},
+    {"env", jspp::AnyValue::make_object({})},
+    {"platform", jspp::AnyValue::make_string(JSPP_PLATFORM)},
+    {"exit", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
+        int code = 0;
+        if (!args.empty() && args[0].is_number()) {
+            code = static_cast<int>(args[0].as_double());
+        }
+        std::exit(code);
+        return jspp::Constants::UNDEFINED;
+    }, "exit")}
+});
+
+void setup_process_argv(int argc, char** argv) {
+    std::vector<jspp::AnyValue> args;
+    if (argc > 0) {
+        args.push_back(jspp::AnyValue::make_string(argv[0]));
+        args.push_back(jspp::AnyValue::make_string("index.js"));
+        for (int i = 1; i < argc; ++i) {
+            args.push_back(jspp::AnyValue::make_string(argv[i]));
+        }
+    }
+    process.set_own_property("argv", jspp::AnyValue::make_array(std::move(args)));
+}
+
+} // namespace jspp

package/src/prelude/library/process.hpp

@@ -3,37 +3,9 @@
 #include "types.hpp"
 #include "any_value.hpp"
 
-#ifdef _WIN32
-#define JSPP_PLATFORM "win32"
-#else
-#define JSPP_PLATFORM "linux"
-#endif
-
-inline auto process = jspp::AnyValue::make_object({
-    {"argv", jspp::AnyValue::make_array(std::vector<jspp::AnyValue>{})},
-    {"env", jspp::AnyValue::make_object({})},
-    {"platform", jspp::AnyValue::make_string(JSPP_PLATFORM)},
-    {"exit", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
-        int code = 0;
-        if (!args.empty() && args[0].is_number()) {
-            code = static_cast<int>(args[0].as_double());
-        }
-        std::exit(code);
-        return jspp::Constants::UNDEFINED;
-    }, "exit")}
-});
-
 namespace jspp {
-    inline void setup_process_argv(int argc, char** argv) {
-        std::vector<jspp::AnyValue> args;
-        if (argc > 0) {
-            args.push_back(jspp::AnyValue::make_string(argv[0]));
-            args.push_back(jspp::AnyValue::make_string("index.js"));
-            for (int i = 1; i < argc; ++i) {
-                args.push_back(jspp::AnyValue::make_string(argv[i]));
-            }
-        }
-        process.set_own_property("argv", jspp::AnyValue::make_array(std::move(args)));
-    }
+    extern AnyValue process;
+    void setup_process_argv(int argc, char** argv);
 }
 
+using jspp::process;

package/src/prelude/library/promise.cpp

@@ -0,0 +1,131 @@
+#include "jspp.hpp"
+#include "library/promise.hpp"
+
+namespace jspp
+{
+    jspp::AnyValue Promise = jspp::AnyValue::make_function(
+        std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue thisVal, std::span<const 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(
+            std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([state](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+        {
+            jspp::JsPromise p; p.state = state;
+            p.resolve(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
+            return jspp::Constants::UNDEFINED; 
+        }), "resolve");
+
+        // reject function
+        auto rejectFn = jspp::AnyValue::make_function(
+            std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([state](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+        {
+            jspp::JsPromise p; p.state = state;
+            p.reject(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
+            return jspp::Constants::UNDEFINED; 
+        }), "reject");
+
+        try
+        {
+            const jspp::AnyValue executorArgs[] = {resolveFn, rejectFn};
+            executor->call(jspp::Constants::UNDEFINED, std::span<const jspp::AnyValue>(executorArgs, 2));
+        }
+        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.define_data_property("resolve", jspp::AnyValue::make_function(
+                                                        std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                                                                     {
+                jspp::JsPromise p;
+                p.resolve(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
+                return jspp::AnyValue::make_promise(p); }),
+                                                        "resolve"));
+
+            Promise.define_data_property("reject", jspp::AnyValue::make_function(
+                                                       std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                                                                    {
+                jspp::JsPromise p;
+                p.reject(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
+                return jspp::AnyValue::make_promise(p); }),
+                                                       "reject"));
+
+            Promise.define_data_property("all", jspp::AnyValue::make_function(
+                                                    std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                                                                 {
+                 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 = static_cast<size_t>(arr->length);
+                 if (len == 0) {
+                     jspp::JsPromise p; p.resolve(jspp::AnyValue::make_array(std::vector<jspp::AnyValue>()));
+                     return jspp::AnyValue::make_promise(p);
+                 }
+
+                 jspp::JsPromise masterPromise;
+                 auto masterState = masterPromise.state;
+                 
+                 auto results = std::make_shared<std::vector<jspp::AnyValue>>(len, jspp::Constants::UNDEFINED);
+                 auto count = std::make_shared<size_t>(len);
+                 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(std::move(*results))); 
+                          }
+                     };
+                     
+                     auto handleReject = [masterState, rejected](jspp::AnyValue reason) {
+                          if (*rejected) return;
+                          *rejected = true;
+                          jspp::JsPromise p; p.state = masterState;
+                          masterState->status = jspp::PromiseStatus::Rejected;
+                          p.reject(reason);
+                     };
+
+                     if (item.is_promise()) {
+                         item.as_promise()->then(handleResult, handleReject);
+                     } else {
+                         handleResult(item);
+                     }
+                 }
+                 
+                 return jspp::AnyValue::make_promise(masterPromise); }),
+                                                    "all"));
+        }
+    };
+    void init_promise()
+    {
+        static PromiseInit promiseInit;
+    }
+}

package/src/prelude/library/promise.hpp

@@ -1,123 +1,12 @@
 #pragma once
 
 #include "types.hpp"
-#include "values/promise.hpp"
 #include "any_value.hpp"
-#include "exception.hpp"
 
-inline auto Promise = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const 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](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                                                       {
-        jspp::JsPromise p; p.state = state;
-        p.resolve(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
-        return jspp::Constants::UNDEFINED; }, "resolve");
-
-                                                        // reject function
-                                                        auto rejectFn = jspp::AnyValue::make_function([state](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                                                      {
-        jspp::JsPromise p; p.state = state;
-        p.reject(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
-        return jspp::Constants::UNDEFINED; }, "reject");
-
-                                                        try
-                                                        {
-                                                            const jspp::AnyValue executorArgs[] = {resolveFn, rejectFn};
-                                                            executor->call(jspp::Constants::UNDEFINED, std::span<const jspp::AnyValue>(executorArgs, 2));
-                                                        }
-                                                        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
+namespace jspp
 {
-    PromiseInit()
-    {
-        // Promise.resolve(value)
-        Promise.define_data_property("resolve", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                              {
-            jspp::JsPromise p;
-            p.resolve(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
-            return jspp::AnyValue::make_promise(p); }, "resolve"));
-
-        // Promise.reject(reason)
-        Promise.define_data_property("reject", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                             {
-            jspp::JsPromise p;
-            p.reject(args.empty() ? jspp::Constants::UNDEFINED : args[0]);
-            return jspp::AnyValue::make_promise(p); }, "reject"));
-
-        // Promise.all(iterable)
-        Promise.define_data_property("all", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                          {
-             // 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 = static_cast<size_t>(arr->length);
-             if (len == 0) {
-                 jspp::JsPromise p; p.resolve(jspp::AnyValue::make_array(std::vector<jspp::AnyValue>()));
-                 return jspp::AnyValue::make_promise(p);
-             }
-
-             jspp::JsPromise masterPromise;
-             auto masterState = masterPromise.state;
-             
-             auto results = std::make_shared<std::vector<jspp::AnyValue>>(len, jspp::Constants::UNDEFINED);
-             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(std::move(*results))); 
-                      }
-                 };
-                 
-                 auto handleReject = [masterState, rejected](jspp::AnyValue reason) {
-                      if (*rejected) return;
-                      *rejected = true;
-                      jspp::JsPromise p; p.state = masterState;
-                      masterState->status =jspp::PromiseStatus::Rejected; // ensure master state updated
-                      p.reject(reason);
-                 };
+    extern AnyValue Promise;
+    void init_promise();
+}
 
-                 if (item.is_promise()) {
-                     item.as_promise()->then(handleResult, handleReject);
-                 } else {
-                     handleResult(item);
-                 }
-             }
-             
-             return jspp::AnyValue::make_promise(masterPromise); }, "all"));
-    }
-} promiseInit;
+using jspp::Promise;

package/src/prelude/library/symbol.cpp

@@ -0,0 +1,56 @@
+#include "jspp.hpp"
+#include "library/symbol.hpp"
+
+namespace jspp
+{
+
+    AnyValue Symbol = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                    {
+    std::string description = "";
+    if (!args.empty() && !args[0].is_undefined()) {
+        description = args[0].to_std_string();
+    }
+    return jspp::AnyValue::make_symbol(description); }, "Symbol", false);
+
+    struct SymbolInit
+    {
+        SymbolInit()
+        {
+            // Static methods
+            Symbol.define_data_property("for", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                             {
+             std::string key = "";
+             if (!args.empty()) key = args[0].to_std_string();
+             return jspp::AnyValue::from_symbol(jspp::JsSymbol::for_global(key)); }, "for"));
+
+            Symbol.define_data_property("keyFor", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                                {
+             if (args.empty() || !args[0].is_symbol()) throw jspp::Exception::make_exception("Symbol.keyFor requires a symbol", "TypeError");
+             auto sym = args[0].as_symbol();
+             auto key = jspp::JsSymbol::key_for(sym);
+             if (key.has_value()) return jspp::AnyValue::make_string(key.value());
+             return jspp::Constants::UNDEFINED; }, "keyFor"));
+
+            // Well-known symbols
+            Symbol.define_data_property("iterator", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::iterator), false, false, false);
+            Symbol.define_data_property("asyncIterator", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::asyncIterator), false, false, false);
+            Symbol.define_data_property("hasInstance", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::hasInstance), false, false, false);
+            Symbol.define_data_property("isConcatSpreadable", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::isConcatSpreadable), false, false, false);
+            Symbol.define_data_property("match", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::match), false, false, false);
+            Symbol.define_data_property("matchAll", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::matchAll), false, false, false);
+            Symbol.define_data_property("replace", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::replace), false, false, false);
+            Symbol.define_data_property("search", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::search), false, false, false);
+            Symbol.define_data_property("species", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::species), false, false, false);
+            Symbol.define_data_property("split", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::split), false, false, false);
+            Symbol.define_data_property("toPrimitive", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::toPrimitive), false, false, false);
+            Symbol.define_data_property("toStringTag", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::toStringTag), false, false, false);
+            Symbol.define_data_property("unscopables", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::unscopables), false, false, false);
+        }
+    };
+
+    void init_symbol()
+    {
+        static SymbolInit symbolInit;
+    }
+
+} // namespace jspp

package/src/prelude/library/symbol.hpp

@@ -1,52 +1,11 @@
 #pragma once
 
 #include "types.hpp"
-#include "utils/well_known_symbols.hpp"
-#include "values/object.hpp"
 #include "any_value.hpp"
 
-// Define Symbol as a function
-inline auto Symbol = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                   {
-    std::string description = "";
-    if (!args.empty() && !args[0].is_undefined()) {
-        description = args[0].to_std_string();
-    }
-    return jspp::AnyValue::make_symbol(description); }, "Symbol", false);
+namespace jspp {
+    extern AnyValue Symbol;
+    void init_symbol();
+}
 
-// Initialize Symbol properties
-struct SymbolInit
-{
-    SymbolInit()
-    {
-        // Static methods
-        Symbol.define_data_property("for", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                         {
-             std::string key = "";
-             if (!args.empty()) key = args[0].to_std_string();
-             return jspp::AnyValue::from_symbol(jspp::JsSymbol::for_global(key)); }, "for"));
-
-        Symbol.define_data_property("keyFor", jspp::AnyValue::make_function([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                                            {
-             if (args.empty() || !args[0].is_symbol()) throw jspp::Exception::make_exception("Symbol.keyFor requires a symbol", "TypeError");
-             auto sym = args[0].as_symbol();
-             auto key = jspp::JsSymbol::key_for(sym);
-             if (key.has_value()) return jspp::AnyValue::make_string(key.value());
-             return jspp::Constants::UNDEFINED; }, "keyFor"));
-
-        // Well-known symbols
-        Symbol.define_data_property("iterator", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::iterator), false, false, false);
-        Symbol.define_data_property("asyncIterator", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::asyncIterator), false, false, false);
-        Symbol.define_data_property("hasInstance", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::hasInstance), false, false, false);
-        Symbol.define_data_property("isConcatSpreadable", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::isConcatSpreadable), false, false, false);
-        Symbol.define_data_property("match", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::match), false, false, false);
-        Symbol.define_data_property("matchAll", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::matchAll), false, false, false);
-        Symbol.define_data_property("replace", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::replace), false, false, false);
-        Symbol.define_data_property("search", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::search), false, false, false);
-        Symbol.define_data_property("species", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::species), false, false, false);
-        Symbol.define_data_property("split", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::split), false, false, false);
-        Symbol.define_data_property("toPrimitive", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::toPrimitive), false, false, false);
-        Symbol.define_data_property("toStringTag", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::toStringTag), false, false, false);
-        Symbol.define_data_property("unscopables", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::unscopables), false, false, false);
-    }
-} symbolInit;
+using jspp::Symbol;

package/src/prelude/library/timer.cpp

@@ -0,0 +1,88 @@
+#include "jspp.hpp"
+#include "library/timer.hpp"
+
+namespace jspp
+{
+
+    AnyValue setTimeout = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const 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.call(jspp::Constants::UNDEFINED, std::span<const jspp::AnyValue>(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");
+
+    AnyValue clearTimeout = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const 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::Constants::UNDEFINED; }, "clearTimeout");
+
+    AnyValue setInterval = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const 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.call(jspp::Constants::UNDEFINED, std::span<const jspp::AnyValue>(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");
+
+    AnyValue clearInterval = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const 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::Constants::UNDEFINED; }, "clearInterval");
+
+} // namespace jspp