@ugo-studio/jspp 0.1.8 → 0.2.0

package/src/prelude/library/console.hpp

@@ -1,112 +1,112 @@
-#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([](const 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::AnyValue::make_undefined(); }, "log");
-auto warnFn = jspp::AnyValue::make_function([](const 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::AnyValue::make_undefined(); }, "warn");
-auto errorFn = jspp::AnyValue::make_function([](const 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::AnyValue::make_undefined(); }, "error");
-auto timeFn = jspp::AnyValue::make_function([](const 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::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
-{
-    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([](const 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::AnyValue::make_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>
+
+static std::map<std::string, std::chrono::steady_clock::time_point> timers = {};
+
+auto logFn = jspp::AnyValue::make_function([](const 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([](const 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([](const 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([](const 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([](const 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},
+});

package/src/prelude/library/error.hpp

@@ -18,7 +18,7 @@ inline auto errorConstructor = [](const jspp::AnyValue &thisVal, std::span<const
     if (target.is_object())
     {
         auto obj = target.as_object();
-        if (obj->proto && is_strictly_equal_to_primitive((*obj->proto), proto))
+        if (!obj->proto.is_null() && !obj->proto.is_undefined() && is_strictly_equal_to_primitive(obj->proto, proto))
         {
             is_construct_call = true;
         }
@@ -55,10 +55,10 @@ inline auto errorConstructor = [](const jspp::AnyValue &thisVal, std::span<const
 // Static Error.isError(val) implementation
 inline auto isErrorFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                       {
-    if (args.empty()) return jspp::AnyValue::make_boolean(false);
+    if (args.empty()) return jspp::Constants::FALSE;
     
     jspp::AnyValue val = args[0];
-    if (!val.is_object()) return jspp::AnyValue::make_boolean(false);
+    if (!val.is_object()) return jspp::Constants::FALSE;
     
     // Check if it inherits from Error.prototype
     // This is essentially 'instanceof Error'
@@ -67,14 +67,14 @@ inline auto isErrorFn = jspp::AnyValue::make_function([](const jspp::AnyValue &t
     // Walk prototype chain
     if (val.is_object()) {
         auto current = val.as_object()->proto;
-        while (current && !(*current).is_null()) {
-             if (is_strictly_equal_to_primitive((*current),proto)) return jspp::AnyValue::make_boolean(true);
-             if ((*current).is_object()) current = (*current).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::AnyValue::make_boolean(false); }, "isError");
+    return jspp::Constants::FALSE; }, "isError");
 
 // toString method for Error.prototype
 inline auto errorToStringFn = jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
@@ -110,4 +110,4 @@ struct ErrorInit
         // Define static Error.isError
         Error.define_data_property("isError", isErrorFn, true, false, true);
     }
-} errorInit;
+} errorInit;

package/src/prelude/library/math.hpp

@@ -111,7 +111,7 @@ struct MathInit {
 
         // Math.clz32(x)
         Math.define_data_property("clz32", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
-            uint32_t val = Operators_Private::ToInt32(args.empty() ? AnyValue::make_undefined() : args[0]);
+            uint32_t val = Operators_Private::ToInt32(args.empty() ? Constants::UNDEFINED : args[0]);
             if (val == 0) return AnyValue::make_number(32);
             return AnyValue::make_number(std::countl_zero(val));
         }, "clz32"));
@@ -173,8 +173,8 @@ struct MathInit {
 
         // Math.imul(x, y)
         Math.define_data_property("imul", AnyValue::make_function([](const AnyValue&, std::span<const AnyValue> args) -> AnyValue {
-            int32_t a = Operators_Private::ToInt32(args.empty() ? AnyValue::make_undefined() : args[0]);
-            int32_t b = Operators_Private::ToInt32(args.size() < 2 ? AnyValue::make_undefined() : args[1]);
+            int32_t a = Operators_Private::ToInt32(args.empty() ? Constants::UNDEFINED : args[0]);
+            int32_t b = Operators_Private::ToInt32(args.size() < 2 ? Constants::UNDEFINED : args[1]);
             return AnyValue::make_number(a * b);
         }, "imul"));
 

package/src/prelude/library/object.hpp

@@ -74,9 +74,6 @@ struct ObjectInit
             auto target = args[0];
             if (target.is_null() || target.is_undefined()) throw jspp::Exception::make_exception("Cannot convert undefined or null to object", "TypeError");
 
-            // In JS, Object.assign modifies target in place if it's an object. 
-            // If it's a primitive, it wraps it (but our primitives are tricky, let's assume objects for now).
-            
             for (size_t i = 1; i < args.size(); ++i) {
                 auto source = args[i];
                 if (source.is_null() || source.is_undefined()) continue;
@@ -92,15 +89,14 @@ struct ObjectInit
         // Object.is(value1, value2)
         Object.define_data_property("is", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
                                                                         {
-            jspp::AnyValue v1 = args.size() > 0 ? args[0] : jspp::AnyValue::make_undefined();
-            jspp::AnyValue v2 = args.size() > 1 ? args[1] : jspp::AnyValue::make_undefined();
+            jspp::AnyValue v1 = args.size() > 0 ? args[0] : jspp::Constants::UNDEFINED;
+            jspp::AnyValue v2 = args.size() > 1 ? args[1] : jspp::Constants::UNDEFINED;
             
             if (v1.is_number() && v2.is_number()) {
                 double d1 = v1.as_double();
                 double d2 = v2.as_double();
                 if (std::isnan(d1) && std::isnan(d2)) return jspp::Constants::TRUE;
                 if (d1 == 0 && d2 == 0) {
-                    // check signs
                     return jspp::AnyValue::make_boolean(std::signbit(d1) == std::signbit(d2));
                 }
                 return jspp::AnyValue::make_boolean(d1 == d2);
@@ -113,25 +109,18 @@ struct ObjectInit
                                                                                     {
              if (args.empty()) throw jspp::Exception::make_exception("Object.getPrototypeOf called on non-object", "TypeError");
              auto obj = args[0];
-             // In ES6+, primitives are coerced to objects.
-             // We'll focus on Objects/Arrays/Functions for now.
              
              if (obj.is_object()) {
-                 auto p = obj.as_object()->proto;
-                 return p ? *p : jspp::AnyValue::make_null();
+                 return obj.as_object()->proto;
              }
              if (obj.is_array()) {
-                 auto p = obj.as_array()->proto;
-                 return p ? *p : jspp::AnyValue::make_null();
+                 return obj.as_array()->proto;
              }
              if (obj.is_function()) {
-                 auto p = obj.as_function()->proto;
-                 return p ? *p : jspp::AnyValue::make_null();
+                 return obj.as_function()->proto;
              }
              
-             // For primitives, they use their prototype from the global constructors usually
-             // e.g. Number.prototype. For now return null or implement if needed.
-             return jspp::AnyValue::make_null(); }, "getPrototypeOf"));
+             return jspp::Constants::Null; }, "getPrototypeOf"));
 
         // Object.setPrototypeOf(obj, proto)
         Object.define_data_property("setPrototypeOf", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
@@ -145,11 +134,11 @@ struct ObjectInit
              }
              
              if (obj.is_object()) {
-                 obj.as_object()->proto = std::make_shared<jspp::AnyValue>(proto);
+                 obj.as_object()->proto = proto;
              } else if (obj.is_array()) {
-                 obj.as_array()->proto = std::make_shared<jspp::AnyValue>(proto);
+                 obj.as_array()->proto = proto;
              } else if (obj.is_function()) {
-                 obj.as_function()->proto = std::make_shared<jspp::AnyValue>(proto);
+                 obj.as_function()->proto = proto;
              }
              
              return obj; }, "setPrototypeOf"));
@@ -202,8 +191,8 @@ struct ObjectInit
                  auto value = descObj.get_own_property("value");
                  obj.define_data_property(prop, value, writable, enumerable, configurable);
              } else {
-                 jspp::AnyValue getter = jspp::AnyValue::make_undefined();
-                 jspp::AnyValue setter = jspp::AnyValue::make_undefined();
+                 jspp::AnyValue getter = jspp::Constants::UNDEFINED;
+                 jspp::AnyValue setter = jspp::Constants::UNDEFINED;
                  
                  if (hasGet) getter = descObj.get_own_property("get");
                  if (hasSet) setter = descObj.get_own_property("set");
@@ -236,7 +225,6 @@ struct ObjectInit
                         o_ptr->storage.push_back(desc);
                     }
                  }
-                 // TODO: Handle Array/Function/others
              }
              
              return obj; }, "defineProperty"));
@@ -285,4 +273,4 @@ struct ObjectInit
              }
              return jspp::Constants::FALSE; }, "hasOwnProperty"));
     }
-} objectInit;
+} objectInit;

package/src/prelude/library/promise.hpp

@@ -37,7 +37,7 @@ inline auto Promise = jspp::AnyValue::make_function([](const jspp::AnyValue &thi
                                                         }
                                                         catch (const jspp::Exception &e)
                                                         {
-                                                            promise.reject(*e.data);
+                                                            promise.reject(e.data);
                                                         }
                                                         catch (...)
                                                         {

package/src/prelude/library/symbol.hpp

@@ -32,7 +32,7 @@ struct SymbolInit
              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::AnyValue::make_undefined(); }, "keyFor"));
+             return jspp::Constants::UNDEFINED; }, "keyFor"));
 
         // Well-known symbols
         Symbol.define_data_property("iterator", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::iterator), false, false, false);

package/src/prelude/library/timer.hpp

@@ -46,7 +46,7 @@ inline auto clearTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue
         size_t id = static_cast<size_t>(args[0].as_double());
         jspp::Scheduler::instance().clear_timer(id);
     }
-    return jspp::AnyValue::make_undefined();
+    return jspp::Constants::UNDEFINED;
 }, "clearTimeout");
 
 // setInterval(callback, delay, ...args)
@@ -88,5 +88,5 @@ inline auto clearInterval = jspp::AnyValue::make_function([](const jspp::AnyValu
         size_t id = static_cast<size_t>(args[0].as_double());
         jspp::Scheduler::instance().clear_timer(id);
     }
-    return jspp::AnyValue::make_undefined();
-}, "clearInterval");
+    return jspp::Constants::UNDEFINED;
+}, "clearInterval");