@ugo-studio/jspp 0.2.9 → 0.3.1

package/src/prelude/library/console.cpp

@@ -0,0 +1,125 @@
+#include "jspp.hpp"
+#include "library/console.hpp"
+#include <chrono>
+#include <map>
+
+static std::map<std::string, std::chrono::steady_clock::time_point> timers = {};
+
+namespace jspp {
+    jspp::AnyValue logFn;
+    jspp::AnyValue warnFn;
+    jspp::AnyValue errorFn;
+    jspp::AnyValue timeFn;
+    jspp::AnyValue timeEndFn;
+    jspp::AnyValue console;
+
+    static auto format_duration = [](double ms) -> std::string
+    {
+        std::ostringstream ss;
+        if (ms < 1000.0)
+        {
+            ss << std::fixed << std::setprecision(4) << ms << "ms";
+            return ss.str();
+        }
+        double total_s = ms / 1000.0;
+        if (ms < 60000.0)
+        {
+            ss << std::fixed << std::setprecision(4) << total_s << "s";
+            return ss.str();
+        }
+        if (ms < 3600000.0)
+        {
+            int minutes = static_cast<int>(ms / 60000.0);
+            double seconds = (ms - minutes * 60000.0) / 1000.0;
+            ss << minutes << "m " << std::fixed << std::setprecision(4) << seconds << "s";
+            return ss.str();
+        }
+        int hours = static_cast<int>(ms / 3600000.0);
+        int minutes = static_cast<int>((ms - hours * 3600000.0) / 60000.0);
+        double seconds = (ms - hours * 3600000.0 - minutes * 60000.0) / 1000.0;
+        ss << hours << "h " << minutes << "m " << std::fixed << std::setprecision(4) << seconds << "s";
+        return ss.str();
+    };
+
+    void init_console() {
+        if (!console.is_undefined()) return;
+
+        logFn = jspp::AnyValue::make_function(
+            std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
+            {
+                for (size_t i = 0; i < args.size(); ++i)
+                {
+                    std::cout << jspp::LogAnyValue::to_log_string(args[i]);
+                    if (i < args.size() - 1)
+                        std::cout << " ";
+                }
+                std::cout << "\n" << std::flush;
+                return jspp::Constants::UNDEFINED;
+            }), "log");
+
+        warnFn = jspp::AnyValue::make_function(
+            std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
+            {
+                std::cerr << "\033[33m";
+                for (size_t i = 0; i < args.size(); ++i)
+                {
+                    std::cout << jspp::LogAnyValue::to_log_string(args[i]);
+                    if (i < args.size() - 1)
+                        std::cout << " ";
+                }
+                std::cerr << "\033[0m" << "\n" << std::flush;
+                return jspp::Constants::UNDEFINED;
+            }), "warn");
+
+        errorFn = jspp::AnyValue::make_function(
+            std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
+            {
+                std::cerr << "\033[31m";
+                for (size_t i = 0; i < args.size(); ++i)
+                {
+                    std::cout << jspp::LogAnyValue::to_log_string(args[i]);
+                    if (i < args.size() - 1)
+                        std::cout << " ";
+                }
+                std::cerr << "\033[0m" << "\n" << std::flush;
+                return jspp::Constants::UNDEFINED;
+            }), "error");
+
+        timeFn = jspp::AnyValue::make_function(
+            std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
+            {
+                auto start = std::chrono::steady_clock::now();
+                auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";
+                timers[key_str] = start;
+                return jspp::Constants::UNDEFINED;
+            }), "time");
+
+        timeEndFn = jspp::AnyValue::make_function(
+            std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
+            {
+                auto end = std::chrono::steady_clock::now();
+                auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";
+                auto it = timers.find(key_str);
+                if (it != timers.end())
+                {
+                    std::chrono::duration<double, std::milli> duration = end - it->second;
+                    double ms = duration.count();
+                    std::cout << "\033[90m" << "[" << format_duration(ms) << "] " << "\033[0m" << key_str << "\n";
+                    timers.erase(it);
+                }
+                else
+                {
+                    std::cout << "Timer '" << key_str << "' does not exist.\n";
+                }
+                return jspp::Constants::UNDEFINED;
+            }), "timeEnd");
+
+        console = jspp::AnyValue::make_object({
+            {"log", logFn},
+            {"warn", warnFn},
+            {"error", errorFn},
+            {"time", timeFn},
+            {"timeEnd", timeEndFn},
+        });
+    }
+}

package/src/prelude/library/console.hpp

@@ -1,112 +1,24 @@
-#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 "exception.hpp"
-#include "utils/log_any_value/log_any_value.hpp"
-
-#include <cmath>
-#include <sstream>
-#include <iomanip>
-
-static std::map<std::string, std::chrono::steady_clock::time_point> timers = {};
-
-auto logFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
-                                           {
-                                               for (size_t i = 0; i < args.size(); ++i)
-                                               {
-                                                   std::cout << jspp::LogAnyValue::to_log_string(args[i]);
-                                                   if (i < args.size() - 1)
-                                                       std::cout << " ";
-                                               }
-                                               std::cout << "\n" << std::flush;
-                                               return jspp::Constants::UNDEFINED; }, "log");
-auto warnFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
-                                            {
-                                                std::cerr << "\033[33m";
-                                                for (size_t i = 0; i < args.size(); ++i)
-                                                {
-                                                    std::cout << jspp::LogAnyValue::to_log_string(args[i]);
-                                                    if (i < args.size() - 1)
-                                                        std::cout << " ";
-                                                }
-                                                std::cerr << "\033[0m" << "\n" << std::flush; // reset
-                                                return jspp::Constants::UNDEFINED; }, "warn");
-auto errorFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
-                                             {
-                                                 std::cerr << "\033[31m";
-                                                 for (size_t i = 0; i < args.size(); ++i)
-                                                 {
-                                                     std::cout << jspp::LogAnyValue::to_log_string(args[i]);
-                                                     if (i < args.size() - 1)
-                                                         std::cout << " ";
-                                                 }
-                                                 std::cerr << "\033[0m" << "\n" << std::flush; // reset
-                                                 return jspp::Constants::UNDEFINED; }, "error");
-auto timeFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const 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::Constants::UNDEFINED; }, "time");
-
-// helper to format duration in ms -> ms/s/m/h with nice precision
-static auto format_duration = [](double ms) -> std::string
-{
-    std::ostringstream ss;
-    if (ms < 1000.0)
-    {
-        ss << std::fixed << std::setprecision(4) << ms << "ms";
-        return ss.str();
-    }
-    double total_s = ms / 1000.0;
-    if (ms < 60000.0)
-    { // less than a minute -> show seconds
-        ss << std::fixed << std::setprecision(4) << total_s << "s";
-        return ss.str();
-    }
-    if (ms < 3600000.0)
-    { // less than an hour -> show minutes + seconds
-        int minutes = static_cast<int>(ms / 60000.0);
-        double seconds = (ms - minutes * 60000.0) / 1000.0;
-        ss << minutes << "m " << std::fixed << std::setprecision(4) << seconds << "s";
-        return ss.str();
-    }
-    // hours, minutes, seconds
-    int hours = static_cast<int>(ms / 3600000.0);
-    int minutes = static_cast<int>((ms - hours * 3600000.0) / 60000.0);
-    double seconds = (ms - hours * 3600000.0 - minutes * 60000.0) / 1000.0;
-    ss << hours << "h " << minutes << "m " << std::fixed << std::setprecision(4) << seconds << "s";
-    return ss.str();
-};
-
-auto timeEndFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args)
-                                               {
-                                                   auto end = std::chrono::steady_clock::now(); // capture immediately
-                                                   auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";
-                                                   auto it = timers.find(key_str);
-                                                   if (it != timers.end())
-                                                   {
-                                                       std::chrono::duration<double, std::milli> duration = end - it->second;
-                                                       double ms = duration.count();
-                                                       std::string formatted = format_duration(ms);
-                                                       std::cout << "\033[90m" << "[" << format_duration(ms) << "] " << "\033[0m" << key_str << "\n";
-                                                       timers.erase(it); // remove the timer after ending it
-                                                   }
-                                                   else
-                                                   {
-                                                       std::cout << "Timer '" << key_str << "' does not exist." << "\n";
-                                                   }
-                                                   return jspp::Constants::UNDEFINED; }, "timeEnd");
-
-inline auto console = jspp::AnyValue::make_object({
-    {"log", logFn},
-    {"warn", warnFn},
-    {"error", errorFn},
-    {"time", timeFn},
-    {"timeEnd", timeEndFn},
-});
+#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 "exception.hpp"
+#include "utils/log_any_value/log_any_value.hpp"
+
+#include <cmath>
+#include <sstream>
+#include <iomanip>
+
+namespace jspp {
+    extern AnyValue logFn;
+    extern AnyValue warnFn;
+    extern AnyValue errorFn;
+    extern AnyValue timeFn;
+    extern AnyValue timeEndFn;
+    extern AnyValue console; 
+    void init_console();
+}

package/src/prelude/library/error.cpp

@@ -0,0 +1,100 @@
+#include "jspp.hpp"
+#include "library/error.hpp"
+
+namespace jspp
+{
+    jspp::AnyValue Error;
+
+    auto errorConstructor = [](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+    {
+        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.is_null() && !obj->proto.is_undefined() && is_strictly_equal_to_primitive(obj->proto, proto))
+            {
+                is_construct_call = true;
+            }
+        }
+
+        if (!is_construct_call)
+        {
+            target = jspp::AnyValue::make_object({}).set_prototype(proto);
+        }
+
+        std::string name = "Error";
+        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(name), true, false, true);
+        target.define_data_property("stack", jspp::AnyValue::make_string(name + ": " + 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;
+    };
+
+    jspp::AnyValue isErrorFn = 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()) return jspp::Constants::FALSE;
+        jspp::AnyValue val = args[0];
+        if (!val.is_object()) return jspp::Constants::FALSE;
+        jspp::AnyValue proto = Error.get_own_property("prototype");
+        if (val.is_object()) {
+            auto current = val.as_object()->proto;
+            while (!current.is_null()) {
+                 if (is_strictly_equal_to_primitive(current, proto)) return jspp::Constants::TRUE;
+                 if (current.is_object()) current = current.as_object()->proto;
+                 else break;
+            }
+        }
+        return jspp::Constants::FALSE; }),
+        "isError");
+
+    jspp::AnyValue errorToStringFn = jspp::AnyValue::make_function(
+        std::function<AnyValue(AnyValue, std::span<const AnyValue>)>([](jspp::AnyValue thisVal, std::span<const 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");
+
+    struct ErrorInit
+    {
+        ErrorInit()
+        {
+            Error = jspp::AnyValue::make_class(
+                std::function<AnyValue(AnyValue, std::span<const AnyValue>)>(errorConstructor), "Error");
+            auto proto = Error.get_own_property("prototype");
+            proto.define_data_property("toString", errorToStringFn, true, false, true);
+            proto.define_data_property(jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::toStringTag), errorToStringFn, true, false, true);
+            Error.define_data_property("isError", isErrorFn, true, false, true);
+        }
+    };
+    void init_error()
+    {
+        static ErrorInit errorInit;
+    }
+}

package/src/prelude/library/error.hpp

@@ -1,113 +1,13 @@
-#pragma once
-
-#include "types.hpp"
-#include "any_value.hpp"
-
-// Declare Error variable
-inline jspp::AnyValue Error;
-
-// Constructor logic
-inline auto errorConstructor = [](jspp::AnyValue thisVal, std::span<const 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.is_null() && !obj->proto.is_undefined() && is_strictly_equal_to_primitive(obj->proto, proto))
-        {
-            is_construct_call = true;
-        }
-    }
-
-    if (!is_construct_call)
-    {
-        target = jspp::AnyValue::make_object_with_proto({}, proto);
-    }
-
-    std::string name = "Error";
-    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(name), true, false, true);
-    target.define_data_property("stack", jspp::AnyValue::make_string(name + ": " + 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([](jspp::AnyValue, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
-                                                      {
-    if (args.empty()) return jspp::Constants::FALSE;
-    
-    jspp::AnyValue val = args[0];
-    if (!val.is_object()) return jspp::Constants::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.is_null()) {
-             if (is_strictly_equal_to_primitive(current, proto)) return jspp::Constants::TRUE;
-             if (current.is_object()) current = current.as_object()->proto;
-             else break;
-        }
-    }
-    
-    return jspp::Constants::FALSE; }, "isError");
-
-// toString method for Error.prototype
-inline auto errorToStringFn = jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const 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);
-        proto.define_data_property(jspp::WellKnownSymbols::toStringTag->key, errorToStringFn, true, false, true);
-
-        // Define static Error.isError
-        Error.define_data_property("isError", isErrorFn, true, false, true);
-    }
-} errorInit;
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+
+namespace jspp {
+    extern AnyValue Error; 
+    void init_error();
+    extern AnyValue isErrorFn;
+    extern AnyValue errorToStringFn;
+}
+
+using jspp::Error;

package/src/prelude/library/function.cpp

@@ -0,0 +1,69 @@
+#include "jspp.hpp"
+#include "library/function.hpp"
+
+namespace jspp
+{
+
+    AnyValue Function = jspp::AnyValue::make_class([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                   { return jspp::Constants::UNDEFINED; }, "Function");
+
+    struct FunctionInit
+    {
+        FunctionInit()
+        {
+            auto proto = Function.get_own_property("prototype");
+
+            // Function.prototype.call
+            proto.define_data_property("call", jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                             {
+            if (!thisVal.is_function()) throw jspp::Exception::make_exception("Function.prototype.call called on non-function", "TypeError");
+            if (args.empty()) return thisVal.call(jspp::Constants::UNDEFINED, {});
+            auto receiver = args[0];
+            return thisVal.call(receiver, args.subspan(1)); }, "call"),
+                                       true, false, true);
+
+            // Function.prototype.apply
+            proto.define_data_property("apply", jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                              {
+            if (!thisVal.is_function()) throw jspp::Exception::make_exception("Function.prototype.apply called on non-function", "TypeError");
+            auto receiver = args.size() > 0 ? args[0] : jspp::Constants::UNDEFINED;
+            auto applyArgs = args.size() > 1 ? args[1] : jspp::Constants::UNDEFINED;
+            
+            if (applyArgs.is_null() || applyArgs.is_undefined()) return thisVal.call(receiver, {});
+            if (!applyArgs.is_array()) throw jspp::Exception::make_exception("CreateListFromArrayLike called on non-object", "TypeError");
+            
+            auto arr = applyArgs.as_array();
+            std::vector<jspp::AnyValue> vec;
+            for(uint64_t i = 0; i < arr->length; ++i) vec.push_back(arr->get_property(static_cast<uint32_t>(i)));
+            return thisVal.call(receiver, vec); }, "apply"),
+                                       true, false, true);
+
+            // Function.prototype.bind
+            proto.define_data_property("bind", jspp::AnyValue::make_function([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                             {
+            if (!thisVal.is_function()) throw jspp::Exception::make_exception("Function.prototype.bind called on non-function", "TypeError");
+            auto receiver = args.size() > 0 ? args[0] : jspp::Constants::UNDEFINED;
+            std::vector<jspp::AnyValue> boundArgs(args.begin() + (args.empty() ? 0 : 1), args.end());
+            
+            return jspp::AnyValue::make_function([thisVal, receiver, boundArgs](jspp::AnyValue, std::span<const jspp::AnyValue> callArgs) -> jspp::AnyValue {
+                std::vector<jspp::AnyValue> combinedArgs = boundArgs;
+                combinedArgs.insert(combinedArgs.end(), callArgs.begin(), callArgs.end());
+                return thisVal.call(receiver, combinedArgs);
+            }, thisVal.as_function()->name); }, "bind"),
+                                       true, false, true);
+
+            // Function.prototype.toString
+            auto toStringFn = jspp::FunctionPrototypes::get("toString");
+            if (toStringFn.has_value())
+            {
+                proto.define_data_property("toString", toStringFn.value(), true, false, true);
+            }
+        }
+    };
+
+    void init_function_lib()
+    {
+        static FunctionInit functionInit;
+    }
+
+} // namespace jspp

package/src/prelude/library/function.hpp

@@ -1,10 +1,11 @@
-#pragma once
-
-#include "types.hpp"
-#include "any_value.hpp"
-
-// Define Function constructor
-// In a full implementation, this would support 'new Function(args, body)'
-inline auto Function = jspp::AnyValue::make_class([](jspp::AnyValue thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
-    return jspp::Constants::UNDEFINED;
-}, "Function");
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+
+namespace jspp {
+    extern AnyValue Function;
+    void init_function_lib();
+}
+
+using jspp::Function;