@ugo-studio/jspp 0.3.0 → 0.3.1

package/src/prelude/values/prototypes/async_iterator.hpp

@@ -1,61 +1,19 @@
-#pragma once
-
-#include "types.hpp"
-#include "values/async_iterator.hpp"
-#include "any_value.hpp"
-#include "exception.hpp"
-#include "utils/operators.hpp"
-
-namespace jspp
-{
-    namespace AsyncIteratorPrototypes
-    {
-        inline AnyValue &get_toString_fn()
-        {
-            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
-                                                         { return AnyValue::make_string(thisVal.as_async_iterator()->to_std_string()); },
-                                                         "toString");
-            return fn;
-        }
-
-        inline AnyValue &get_asyncIterator_fn()
-        {
-            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
-                                                         { return thisVal; },
-                                                         "Symbol.asyncIterator");
-            return fn;
-        }
-
-        inline AnyValue &get_next_fn()
-        {
-            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
-                                                         {
-                                                             AnyValue val = args.empty() ? Constants::UNDEFINED : args[0];
-                                                             auto res = thisVal.as_async_iterator()->next(val);
-                                                             return AnyValue::make_promise(res); },
-                                                         "next");
-            return fn;
-        }
-
-        inline std::optional<AnyValue> get(const std::string &key)
-        {
-            // --- toString() method ---
-            if (key == "toString" || key == WellKnownSymbols::toStringTag->key)
-            {
-                return get_toString_fn();
-            }
-            // --- [Symbol.asyncIterator]() method ---
-            if (key == WellKnownSymbols::asyncIterator->key)
-            {
-                return get_asyncIterator_fn();
-            }
-            // --- next() method ---
-            if (key == "next")
-            {
-                return get_next_fn();
-            }
-
-            return std::nullopt;
-        }
-    }
-}
+#pragma once
+
+#include "types.hpp"
+#include <optional>
+
+namespace jspp
+{
+    class AnyValue;
+
+    namespace AsyncIteratorPrototypes
+    {
+        AnyValue &get_toString_fn();
+        AnyValue &get_asyncIterator_fn();
+        AnyValue &get_next_fn();
+
+        std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const AnyValue &key);
+    }
+}

package/src/prelude/values/prototypes/function.hpp

@@ -1,56 +1,17 @@
 #pragma once
 
 #include "types.hpp"
-#include "values/function.hpp"
-#include "any_value.hpp"
-#include "exception.hpp"
-#include "utils/operators.hpp"
+#include <optional>
 
 namespace jspp
 {
+    class AnyValue;
+
     namespace FunctionPrototypes
     {
-        inline AnyValue &get_toString_fn()
-        {
-            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> _) -> AnyValue
-                                                         { return AnyValue::make_string(thisVal.as_function()->to_std_string()); },
-                                                         "toString");
-            return fn;
-        }
-
-        inline AnyValue &get_call_fn()
-        {
-            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
-                                                         {
-                                                             AnyValue thisArg = Constants::UNDEFINED;
-                                                             std::span<const AnyValue> fnArgs;
-
-                                                             if (!args.empty())
-                                                             {
-                                                                 thisArg = args[0];
-                                                                 fnArgs = args.subspan(1);
-                                                             }
-
-                                                             return thisVal.call(thisArg, fnArgs); },
-                                                         "call");
-            return fn;
-        }
-
-        inline std::optional<AnyValue> get(const std::string &key)
-        {
-            // --- toString() method ---
-            if (key == "toString" || key == WellKnownSymbols::toStringTag->key)
-            {
-                return get_toString_fn();
-            }
-
-            // --- call() method ---
-            if (key == "call")
-            {
-                return get_call_fn();
-            }
-
-            return std::nullopt;
-        }
+        AnyValue &get_toString_fn();
+        AnyValue &get_call_fn();
+        std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const AnyValue &key);
     }
 }

package/src/prelude/values/prototypes/iterator.hpp

@@ -1,201 +1,25 @@
 #pragma once
 
 #include "types.hpp"
-#include "values/iterator.hpp"
-#include "any_value.hpp"
-#include "exception.hpp"
-#include "utils/operators.hpp"
+#include <optional>
 
 namespace jspp
 {
+    class AnyValue;
+
     namespace IteratorPrototypes
     {
-        inline AnyValue &get_toString_fn()
-        {
-            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
-                                                         { return AnyValue::make_string(thisVal.as_iterator()->to_std_string()); },
-                                                         "toString");
-            return fn;
-        }
-
-        inline AnyValue &get_iterator_fn()
-        {
-            static AnyValue fn = AnyValue::make_generator([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
-                                                          { return thisVal; },
-                                                          "Symbol.iterator");
-            return fn;
-        }
-
-        inline AnyValue &get_next_fn()
-        {
-            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
-                                                         {
-                                                             AnyValue val = args.empty() ? Constants::UNDEFINED : args[0];
-                                                             auto res = thisVal.as_iterator()->next(val);
-                                                             return AnyValue::make_object({{"value", res.value.value_or(Constants::UNDEFINED)}, {"done", AnyValue::make_boolean(res.done)}}); },
-                                                         "next");
-            return fn;
-        }
-
-        inline AnyValue &get_return_fn()
-        {
-            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
-                                                         {
-                                                             AnyValue val = args.empty() ? Constants::UNDEFINED : args[0];
-                                                             auto res = thisVal.as_iterator()->return_(val);
-                                                             return AnyValue::make_object({{"value", res.value.value_or(Constants::UNDEFINED)}, {"done", AnyValue::make_boolean(res.done)}}); },
-                                                         "return");
-            return fn;
-        }
-
-        inline AnyValue &get_throw_fn()
-        {
-            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
-                                                         {
-                                                             AnyValue err = args.empty() ? Constants::UNDEFINED : args[0];
-                                                             auto res = thisVal.as_iterator()->throw_(err);
-                                                             return AnyValue::make_object({{"value", res.value.value_or(Constants::UNDEFINED)}, {"done", AnyValue::make_boolean(res.done)}}); },
-                                                         "throw");
-            return fn;
-        }
-
-        inline AnyValue &get_toArray_fn()
-        {
-            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
-                                                         { return AnyValue::make_array(thisVal.as_iterator()->to_vector()); },
-                                                         "drop");
-            return fn;
-        }
-
-        inline AnyValue &get_drop_fn()
-        {
-            static AnyValue fn = AnyValue::make_generator([](AnyValue thisVal, std::vector<AnyValue> args) -> JsIterator<AnyValue>
-                                                          { 
-                                                            auto self = thisVal.as_iterator();
-                                                            size_t skip_count = 0;
-                                                            if (!args.empty()) {
-                                                                skip_count = static_cast<size_t>(args[0].as_double());
-                                                            }
-                                                            size_t skipped = 0;
-                                                            while (true)
-                                                            {
-                                                                auto next_res = self->next();
-                                                                if (next_res.done) { break; }
-                                                                if (skipped < skip_count)
-                                                                {
-                                                                    skipped++;
-                                                                    continue;
-                                                                }
-                                                                co_yield next_res.value.value_or(Constants::UNDEFINED);
-                                                            }
-                                                            co_return jspp::Constants::UNDEFINED; },
-                                                          "drop");
-            return fn;
-        }
-
-        inline AnyValue &get_take_fn()
-        {
-            static AnyValue fn = AnyValue::make_generator([](AnyValue thisVal, std::vector<AnyValue> args) -> JsIterator<AnyValue>
-                                                          { 
-                                                            auto self = thisVal.as_iterator();
-                                                            size_t take_count = 0;
-                                                            if (!args.empty()) {
-                                                                take_count = static_cast<size_t>(args[0].as_double());
-                                                            }
-                                                            size_t taken = 0;
-                                                            while (true)
-                                                            {
-                                                                auto next_res = self->next();
-                                                                if (next_res.done) { break; }
-                                                                if (taken < take_count)
-                                                                {
-                                                                    taken++;
-                                                                    co_yield next_res.value.value_or(Constants::UNDEFINED);
-                                                                }
-                                                                if (taken >= take_count) 
-                                                                { 
-                                                                    // Call the iterator's return() method for early cleanup of resources
-                                                                    self->return_();
-                                                                    break; 
-                                                                }
-                                                            }
-                                                            co_return jspp::Constants::UNDEFINED; },
-                                                          "take");
-            return fn;
-        }
-
-        inline AnyValue &get_some_fn()
-        {
-            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
-                                                         { 
-                                                            auto self = thisVal.as_iterator();
-                                                            if (args.empty() || !args[0].is_function()) throw Exception::make_exception("callback is not a function", "TypeError");
-                                                            auto callback = args[0].as_function();
-                                                            while (true)
-                                                            {
-                                                                auto next_res = self->next();
-                                                                if (next_res.done) { break; }
-                                                                if (is_truthy(callback->call(thisVal, std::span<const AnyValue>((const jspp::AnyValue[]){next_res.value.value_or(Constants::UNDEFINED)}, 1))))
-                                                                {
-                                                                    // Call the iterator's return() method for early cleanup of resources
-                                                                    self->return_();
-                                                                    return Constants::TRUE;
-                                                                }
-                                                            }
-                                                            return jspp::Constants::FALSE; },
-                                                         "some");
-            return fn;
-        }
-
-        inline std::optional<AnyValue> get(const std::string &key)
-        {
-            // --- toString() method ---
-            if (key == "toString" || key == WellKnownSymbols::toStringTag->key)
-            {
-                return get_toString_fn();
-            }
-            // --- [Symbol.iterator]() method ---
-            if (key == WellKnownSymbols::iterator->key)
-            {
-                return get_iterator_fn();
-            }
-            // --- next() method ---
-            if (key == "next")
-            {
-                return get_next_fn();
-            }
-            // --- return() method ---
-            if (key == "return")
-            {
-                return get_return_fn();
-            }
-            // --- throw() method ---
-            if (key == "throw")
-            {
-                return get_throw_fn();
-            }
-            // --- toArray() method ---
-            if (key == "toArray")
-            {
-                return get_toArray_fn();
-            }
-            // --- drop() method ---
-            if (key == "drop")
-            {
-                return get_drop_fn();
-            }
-            // --- take() method ---
-            if (key == "take")
-            {
-                return get_take_fn();
-            }
-            // --- some() method ---
-            if (key == "some")
-            {
-                return get_some_fn();
-            }
-
-            return std::nullopt;
-        }
+        AnyValue &get_toString_fn();
+        AnyValue &get_iterator_fn();
+        AnyValue &get_next_fn();
+        AnyValue &get_return_fn();
+        AnyValue &get_throw_fn();
+        AnyValue &get_toArray_fn();
+        AnyValue &get_drop_fn();
+        AnyValue &get_take_fn();
+        AnyValue &get_some_fn();
+
+        std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const AnyValue &key);
     }
 }

package/src/prelude/values/prototypes/number.hpp

@@ -1,210 +1,23 @@
-#pragma once
-
-#include "types.hpp"
-#include "any_value.hpp"
-#include "exception.hpp"
-#include "utils/operators.hpp"
-#include <string>
-#include <vector>
-#include <iomanip>
-#include <sstream>
-#include <cmath>
-#include <algorithm>
-
-namespace jspp
-{
-    namespace NumberPrototypes
-    {
-        // Helper for radix conversion
-        inline std::string number_to_radix_string(double value, int radix)
-        {
-            if (std::isnan(value))
-                return "NaN";
-            if (!std::isfinite(value))
-                return value > 0 ? "Infinity" : "-Infinity";
-
-            // For radix != 10, we only support integer part for now
-            // as implementing full float-to-radix is complex.
-            long long intPart = static_cast<long long>(value);
-
-            if (radix == 10)
-            {
-                return AnyValue::make_number(value).to_std_string();
-            }
-
-            bool negative = intPart < 0;
-            if (negative)
-                intPart = -intPart;
-
-            std::string chars = "0123456789abcdefghijklmnopqrstuvwxyz";
-            std::string res = "";
-
-            if (intPart == 0)
-                res = "0";
-            else
-            {
-                while (intPart > 0)
-                {
-                    res += chars[intPart % radix];
-                    intPart /= radix;
-                }
-            }
-            if (negative)
-                res += "-";
-            std::reverse(res.begin(), res.end());
-            return res;
-        }
-
-        inline AnyValue &get_toExponential_fn()
-        {
-            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
-                                                         {
-                                                             double self = thisVal.as_double();
-                                                             int digits = -1;
-                                                             if (!args.empty() && !args[0].is_undefined())
-                                                             {
-                                                                 digits = Operators_Private::ToInt32(args[0]);
-                                                                 if (digits < 0 || digits > 100)
-                                                                 {
-                                                                     throw Exception::make_exception("toExponential() digits argument must be between 0 and 100", "RangeError");
-                                                                 }
-                                                             }
-
-                                                             std::ostringstream ss;
-                                                             if (digits >= 0)
-                                                             {
-                                                                 ss << std::scientific << std::setprecision(digits) << self;
-                                                             }
-                                                             else
-                                                             {
-                                                                 ss << std::scientific << self;
-                                                             }
-
-                                                             std::string res = ss.str();
-                                                             return AnyValue::make_string(res); },
-                                                         "toExponential");
-            return fn;
-        }
-
-        inline AnyValue &get_toFixed_fn()
-        {
-            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
-                                                         {
-                                                             double self = thisVal.as_double();
-                                                             int digits = 0;
-                                                             if (!args.empty() && !args[0].is_undefined())
-                                                             {
-                                                                 digits = Operators_Private::ToInt32(args[0]);
-                                                             }
-                                                             if (digits < 0 || digits > 100)
-                                                             {
-                                                                 throw Exception::make_exception("toFixed() digits argument must be between 0 and 100", "RangeError");
-                                                             }
-
-                                                             std::ostringstream ss;
-                                                             ss << std::fixed << std::setprecision(digits) << self;
-                                                             return AnyValue::make_string(ss.str()); },
-                                                         "toFixed");
-            return fn;
-        }
-
-        inline AnyValue &get_toPrecision_fn()
-        {
-            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
-                                                         {
-                                                             double self = thisVal.as_double();
-                                                             if (args.empty() || args[0].is_undefined())
-                                                             {
-                                                                 return AnyValue::make_number(self).get_own_property("toString").call(AnyValue::make_number(self), {}, "toString");
-                                                             }
-                                                             int precision = Operators_Private::ToInt32(args[0]);
-                                                             if (precision < 1 || precision > 100)
-                                                             {
-                                                                 throw Exception::make_exception("toPrecision() precision argument must be between 1 and 100", "RangeError");
-                                                             }
-
-                                                             std::ostringstream ss;
-                                                             ss << std::setprecision(precision) << self;
-                                                             return AnyValue::make_string(ss.str()); },
-                                                         "toPrecision");
-            return fn;
-        }
-
-        inline AnyValue &get_toString_fn()
-        {
-            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
-                                                         {
-                                                             double self = thisVal.as_double();
-                                                             int radix = 10;
-                                                             if (!args.empty() && !args[0].is_undefined())
-                                                             {
-                                                                 radix = Operators_Private::ToInt32(args[0]);
-                                                             }
-                                                             if (radix < 2 || radix > 36)
-                                                             {
-                                                                 throw Exception::make_exception("toString() radix argument must be between 2 and 36", "RangeError");
-                                                             }
-
-                                                             return AnyValue::make_string(number_to_radix_string(self, radix)); },
-                                                         "toString");
-            return fn;
-        }
-
-        inline AnyValue &get_valueOf_fn()
-        {
-            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
-                                                         { return AnyValue::make_number(thisVal.as_double()); },
-                                                         "valueOf");
-            return fn;
-        }
-
-        inline AnyValue &get_toLocaleString_fn()
-        {
-            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
-                                                         { return AnyValue::make_string(AnyValue::make_number(thisVal.as_double()).to_std_string()); },
-                                                         "toLocaleString");
-            return fn;
-        }
-
-        inline std::optional<AnyValue> get(const std::string &key)
-        {
-            // --- toExponential(fractionDigits) ---
-            if (key == "toExponential")
-            {
-                return get_toExponential_fn();
-            }
-
-            // --- toFixed(digits) ---
-            if (key == "toFixed")
-            {
-                return get_toFixed_fn();
-            }
-
-            // --- toPrecision(precision) ---
-            if (key == "toPrecision")
-            {
-                return get_toPrecision_fn();
-            }
-
-            // --- toString(radix) ---
-            if (key == "toString")
-            {
-                return get_toString_fn();
-            }
-
-            // --- valueOf() ---
-            if (key == "valueOf")
-            {
-                return get_valueOf_fn();
-            }
-
-            // --- toLocaleString() ---
-            if (key == "toLocaleString")
-            {
-                return get_toLocaleString_fn();
-            }
-
-            return std::nullopt;
-        }
-    }
-}
+#pragma once
+
+#include "types.hpp"
+#include <optional>
+
+namespace jspp
+{
+    class AnyValue;
+
+    namespace NumberPrototypes
+    {
+        std::string number_to_radix_string(double value, int radix);
+        AnyValue &get_toExponential_fn();
+        AnyValue &get_toFixed_fn();
+        AnyValue &get_toPrecision_fn();
+        AnyValue &get_toString_fn();
+        AnyValue &get_valueOf_fn();
+        AnyValue &get_toLocaleString_fn();
+
+        std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const AnyValue &key);
+    }
+}

package/src/prelude/values/prototypes/object.hpp

@@ -1,32 +1,16 @@
 #pragma once
 
 #include "types.hpp"
-#include "values/object.hpp"
-#include "any_value.hpp"
-#include "exception.hpp"
-#include "utils/operators.hpp"
+#include <optional>
 
 namespace jspp
 {
+    class AnyValue;
+
     namespace ObjectPrototypes
     {
-        inline AnyValue& get_toString_fn()
-        {
-            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> _) -> AnyValue
-                                                         { return AnyValue::make_string(thisVal.to_std_string()); },
-                                                         "toString");
-            return fn;
-        }
-
-        inline std::optional<AnyValue> get(const std::string &key)
-        {
-            // --- toString() method ---
-            if (key == "toString" || key == WellKnownSymbols::toStringTag->key)
-            {
-                return get_toString_fn();
-            }
-
-            return std::nullopt;
-        }
+        AnyValue& get_toString_fn();
+        std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const AnyValue &key);
     }
-}
+}