@ugo-studio/jspp 0.1.3 → 0.1.5

package/src/prelude/library/array.hpp

@@ -0,0 +1,190 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/operators.hpp"
+#include "utils/access.hpp"
+
+inline auto Array = jspp::AnyValue::make_class([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                               {
+    if (args.size() == 1 && args[0].is_number()) {
+        double len = args[0].as_double();
+        if (len < 0 || len > 4294967295.0) { // Max uint32
+             throw jspp::Exception::make_exception("Invalid array length", "RangeError");
+        }
+        auto arr = jspp::AnyValue::make_array(std::vector<jspp::AnyValue>());
+        arr.as_array()->length = static_cast<uint64_t>(len);
+        arr.as_array()->dense.resize(static_cast<size_t>(len), jspp::AnyValue::make_uninitialized());
+        return arr;
+    }
+    std::vector<jspp::AnyValue> elements;
+    for(const auto& arg : args) {
+        elements.push_back(arg);
+    }
+    return jspp::AnyValue::make_array(std::move(elements)); }, "Array");
+
+struct ArrayInit
+{
+    ArrayInit()
+    {
+        // Set Array.prototype.proto to Object.prototype
+        // Array.get_own_property("prototype").set_prototype(::Object.get_own_property("prototype"));
+
+        // Array.isArray(value)
+        Array.define_data_property("isArray", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                            {
+            if (args.empty()) return jspp::Constants::FALSE;
+            return jspp::AnyValue::make_boolean(args[0].is_array()); }, "isArray"));
+
+        // Array.of(...elements)
+        Array.define_data_property("of", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                       {
+            std::vector<jspp::AnyValue> elements;
+            for(const auto& arg : args) {
+                elements.push_back(arg);
+            }
+            return jspp::AnyValue::make_array(std::move(elements)); }, "of"));
+
+        // Array.from(arrayLike, mapFn?, thisArg?)
+        Array.define_data_property("from", jspp::AnyValue::make_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                         {
+            if (args.empty() || args[0].is_null() || args[0].is_undefined()) {
+                throw jspp::Exception::make_exception("Array.from requires an array-like object", "TypeError");
+            }
+
+            const auto& items = args[0];
+            const auto& mapFn = (args.size() > 1 && args[1].is_function()) ? args[1] : jspp::Constants::UNDEFINED;
+            const auto& thisArg = (args.size() > 2) ? args[2] : jspp::Constants::UNDEFINED;
+
+            std::vector<jspp::AnyValue> result;
+
+            // Check if iterable
+            // Simple check: does it have [Symbol.iterator]?
+            auto iteratorSym = jspp::WellKnownSymbols::iterator;
+            if (items.has_property(iteratorSym->key)) {
+                auto iter = jspp::Access::get_object_value_iterator(items, "Array.from source");
+                auto nextFn = iter.get_own_property("next");
+                
+                size_t k = 0;
+                while (true) {
+                    auto nextRes = nextFn.call(iter, std::span<const jspp::AnyValue>{}, "next");
+                    if (jspp::is_truthy(nextRes.get_own_property("done"))) break;
+                    
+                    auto val = nextRes.get_own_property("value");
+                    if (mapFn.is_function()) {
+                        jspp::AnyValue kVal = jspp::AnyValue::make_number(k);
+                        const jspp::AnyValue mapArgs[] = {val, kVal};
+                        val = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
+                    }
+                    result.push_back(val);
+                    k++;
+                }
+            } else {
+                // Array-like (length property)
+                auto lenVal = items.get_property_with_receiver("length", items);
+                size_t len = static_cast<size_t>(jspp::Operators_Private::ToUint32(lenVal));
+                
+                for (size_t k = 0; k < len; ++k) {
+                    auto kVal = items.get_property_with_receiver(std::to_string(k), items);
+                    if (mapFn.is_function()) {
+                        jspp::AnyValue kNum = jspp::AnyValue::make_number(k);
+                        const jspp::AnyValue mapArgs[] = {kVal, kNum};
+                        kVal = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
+                    }
+                    result.push_back(kVal);
+                }
+            }
+            
+            return jspp::AnyValue::make_array(std::move(result)); }, "from"));
+
+        // Array.fromAsync(iterableOrArrayLike, mapFn?, thisArg?)
+        Array.define_data_property("fromAsync", jspp::AnyValue::make_async_function([](const jspp::AnyValue &, std::span<const jspp::AnyValue> args) -> jspp::JsPromise
+                                                                                    {
+            if (args.empty() || args[0].is_null() || args[0].is_undefined()) {
+                throw jspp::Exception::make_exception("Array.fromAsync requires an iterable or array-like object", "TypeError");
+            }
+
+            const auto& items = args[0];
+            const auto& mapFn = (args.size() > 1 && args[1].is_function()) ? args[1] : jspp::Constants::UNDEFINED;
+            const auto& thisArg = (args.size() > 2) ? args[2] : jspp::Constants::UNDEFINED;
+
+            std::vector<jspp::AnyValue> result;
+            
+            bool isAsync = false;
+            jspp::AnyValue iter;
+            jspp::AnyValue nextFn;
+
+            if (items.has_property(jspp::WellKnownSymbols::asyncIterator->key)) {
+                auto method = items.get_property_with_receiver(jspp::WellKnownSymbols::asyncIterator->key, items);
+                if (method.is_function()) {
+                    iter = method.call(items, {});
+                    nextFn = iter.get_own_property("next");
+                    isAsync = true;
+                }
+            } 
+            
+            if (!isAsync && items.has_property(jspp::WellKnownSymbols::iterator->key)) {
+                auto method = items.get_property_with_receiver(jspp::WellKnownSymbols::iterator->key, items);
+                if (method.is_function()) {
+                    iter = method.call(items, {});
+                    nextFn = iter.get_own_property("next");
+                }
+            }
+
+            if (!iter.is_undefined()) {
+                size_t k = 0;
+                while (true) {
+                    auto nextRes = nextFn.call(iter, {});
+                    
+                    if (nextRes.is_promise()) {
+                        nextRes = co_await nextRes;
+                    }
+                    
+                    if (jspp::is_truthy(nextRes.get_own_property("done"))) break;
+                    
+                    auto val = nextRes.get_own_property("value");
+                    
+                    if (mapFn.is_function()) {
+                        jspp::AnyValue kVal = jspp::AnyValue::make_number(k);
+                        const jspp::AnyValue mapArgs[] = {val, kVal};
+                        auto mapRes = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
+                        if (mapRes.is_promise()) {
+                            val = co_await mapRes;
+                        } else {
+                            val = mapRes;
+                        }
+                    }
+                    result.push_back(val);
+                    k++;
+                }
+            } else {
+                auto lenVal = items.get_property_with_receiver("length", items);
+                size_t len = static_cast<size_t>(jspp::Operators_Private::ToUint32(lenVal));
+                
+                for (size_t k = 0; k < len; ++k) {
+                    auto kVal = items.get_property_with_receiver(std::to_string(k), items);
+                    if (kVal.is_promise()) {
+                        kVal = co_await kVal;
+                    }
+
+                    if (mapFn.is_function()) {
+                        jspp::AnyValue kNum = jspp::AnyValue::make_number(k);
+                        const jspp::AnyValue mapArgs[] = {kVal, kNum};
+                        auto mapRes = mapFn.call(thisArg, std::span<const jspp::AnyValue>(mapArgs, 2));
+                        if (mapRes.is_promise()) {
+                            kVal = co_await mapRes;
+                        } else {
+                            kVal = mapRes;
+                        }
+                    }
+                    result.push_back(kVal);
+                }
+            }
+
+            co_return jspp::AnyValue::make_array(std::move(result)); }, "fromAsync"));
+
+        // Array[Symbol.species]
+        Array.define_getter(jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::species), jspp::AnyValue::make_function([](const jspp::AnyValue &thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue
+                                                                                                                        { return thisVal; }, "get [Symbol.species]"));
+    }
+} arrayInit;

package/src/prelude/library/console.hpp

@@ -5,8 +5,9 @@
 #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 "exception.hpp"
+#include "utils/log_any_value/log_any_value.hpp"
 
 #include <cmath>
 #include <sstream>
@@ -14,39 +15,39 @@
 
 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, std::span<const 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";
+                                               std::cout << "\n" << std::flush;
                                                return jspp::AnyValue::make_undefined(); }, "log");
-auto warnFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
+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::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
+                                                std::cerr << "\033[0m" << "\n" << std::flush; // reset
                                                 return jspp::AnyValue::make_undefined(); }, "warn");
-auto errorFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
+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::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
+                                                 std::cerr << "\033[0m" << "\n" << std::flush; // reset
                                                  return jspp::AnyValue::make_undefined(); }, "error");
-auto timeFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
+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";
@@ -83,7 +84,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, 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";

package/src/prelude/library/error.hpp

@@ -0,0 +1,113 @@
+#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, 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_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([](const jspp::AnyValue &thisVal, std::span<const 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 (is_strictly_equal_to_primitive((*current),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, 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;

package/src/prelude/library/function.hpp

@@ -0,0 +1,10 @@
+#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([](const jspp::AnyValue& thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
+    return jspp::Constants::UNDEFINED;
+}, "Function");

package/src/prelude/library/global.hpp

@@ -1,10 +1,41 @@
 #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"
+#include "library/math.hpp"
+
+inline auto global = jspp::AnyValue::make_object({
+    {"Symbol", Symbol},
+    {"process", process},
+    {"Function", Function},
     {"console", console},
+    {"performance", performance},
+    {"Error", Error},
+    {"Promise", Promise},
+    {"setTimeout", setTimeout},
+    {"clearTimeout", clearTimeout},
+    {"setInterval", setInterval},
+    {"clearInterval", clearInterval},
+    {"Math", Math},
+    {"Object", Object},
+    {"Array", Array},
 });
-inline auto globalThis = global;
+
+struct GlobalInit {
+    GlobalInit() {
+        auto objectProto = ::Object.get_own_property("prototype");
+        
+        // Tie built-in prototypes to Object.prototype
+        ::Array.get_own_property("prototype").set_prototype(objectProto);
+        ::Function.get_own_property("prototype").set_prototype(objectProto);
+        ::Error.get_own_property("prototype").set_prototype(objectProto);
+        ::Promise.get_own_property("prototype").set_prototype(objectProto);
+        ::Symbol.get_own_property("prototype").set_prototype(objectProto);
+    }
+} globalInit;