@ugo-studio/jspp 0.1.0

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

@@ -0,0 +1,228 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/array.hpp"
+#include "any_value.hpp"
+#include "error.hpp"
+#include "operators.hpp"
+#include <algorithm>
+#include <vector>
+
+namespace jspp
+{
+    namespace ArrayPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsArray *self)
+        {
+
+            // --- toString() method ---
+            if (key == "toString")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               { return AnyValue::make_string(self->to_std_string()); },
+                                               key);
+            }
+
+            // --- length property ---
+            if (key == "length")
+            {
+                auto getter = [&self](const std::vector<AnyValue> &args) -> AnyValue
+                {
+                    return AnyValue::make_number(self->length);
+                };
+
+                auto setter = [&self](const std::vector<AnyValue> &args) -> AnyValue
+                {
+                    if (args.empty())
+                    {
+                        return AnyValue::make_undefined();
+                    }
+
+                    const auto &new_len_val = args[0];
+                    double new_len_double = Operators_Private::ToNumber(new_len_val);
+
+                    if (new_len_double < 0 || std::isnan(new_len_double) || std::isinf(new_len_double) || new_len_double != static_cast<uint64_t>(new_len_double))
+                    {
+                        throw RuntimeError::make_error("Invalid array length", "RangeError");
+                    }
+                    uint64_t new_len = static_cast<uint64_t>(new_len_double);
+
+                    // Truncate dense part
+                    if (new_len < self->dense.size())
+                    {
+                        self->dense.resize(new_len);
+                    }
+
+                    // Remove sparse elements beyond the new length
+                    for (auto it = self->sparse.begin(); it != self->sparse.end();)
+                    {
+                        if (it->first >= new_len)
+                        {
+                            it = self->sparse.erase(it);
+                        }
+                        else
+                        {
+                            ++it;
+                        }
+                    }
+
+                    self->length = new_len;
+                    return new_len_val;
+                };
+
+                return AnyValue::make_accessor_descriptor(getter,
+                                                          setter,
+                                                          false,
+                                                          false);
+            }
+
+            // --- push() method ---
+            if (key == "push")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                                                                                           for (const auto &arg : args)
+                                                                                           {
+                                                                                               self->set_property(static_cast<uint32_t>(self->length), arg);
+                                                                                           }
+                                                                                           return AnyValue::make_number(self->length); },
+                                               key);
+            }
+
+            // --- pop() method ---
+            if (key == "pop")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                                                                                           if (self->length == 0)
+                                                                                           {
+                                                                                               return AnyValue::make_undefined();
+                                                                                           }
+                                                                                           uint64_t last_idx = self->length - 1;
+                                                                                           AnyValue last_val = self->get_property(static_cast<uint32_t>(last_idx));
+
+                                                                                           // Remove from dense
+                                                                                           if (last_idx < self->dense.size())
+                                                                                           {
+                                                                                               self->dense.pop_back();
+                                                                                           }
+                                                                                           // Remove from sparse
+                                                                                           self->sparse.erase(static_cast<uint32_t>(last_idx));
+
+                                                                                           self->length--;
+                                                                                           return last_val; },
+                                               key);
+            }
+
+            // --- shift() method ---
+            if (key == "shift")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                                                                                           if (self->length == 0)
+                                                                                           {
+                                                                                               return AnyValue::make_undefined();
+                                                                                           }
+                                                                                           AnyValue first_val = self->get_property(0u);
+
+                                                                                           // Shift all elements to the left
+                                                                                           for (uint64_t i = 0; i < self->length - 1; ++i)
+                                                                                           {
+                                                                                               self->set_property(static_cast<uint32_t>(i), self->get_property(static_cast<uint32_t>(i + 1)));
+                                                                                           }
+
+                                                                                           // remove last element
+                                                                                           uint64_t last_idx = self->length - 1;
+                                                                                           if (last_idx < self->dense.size())
+                                                                                           {
+                                                                                               self->dense.pop_back();
+                                                                                           }
+                                                                                           self->sparse.erase(static_cast<uint32_t>(last_idx));
+
+                                                                                           self->length--;
+
+                                                                                           return first_val; },
+                                               key);
+            }
+
+            // --- unshift() method ---
+            if (key == "unshift")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                                                                                             size_t args_count = args.size();
+                                                                                             if (args_count == 0)
+                                                                                             {
+                                                                                                 return AnyValue::make_number(self->length);
+                                                                                             }
+
+                                                                                             // Shift existing elements to the right
+                                                                                             for (uint64_t i = self->length; i > 0; --i)
+                                                                                             {
+                                                                                                 self->set_property(static_cast<uint32_t>(i + args_count - 1), self->get_property(static_cast<uint32_t>(i - 1)));
+                                                                                             }
+
+                                                                                             // Insert new elements at the beginning
+                                                                                             for (size_t i = 0; i < args_count; ++i)
+                                                                                             {
+                                                                                                 self->set_property(static_cast<uint32_t>(i), args[i]);
+                                                                                             }
+
+                                                                                             return AnyValue::make_number(self->length); },
+                                               key);
+            }
+
+            // --- join() method ---
+            if (key == "join")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                                                                                           std::string sep = ",";
+                                                                                           if (!args.empty() && !args[0].is_undefined())
+                                                                                           {
+                                                                                               sep = args[0].to_std_string();
+                                                                                           }
+
+                                                                                           std::string result = "";
+                                                                                           for (uint64_t i = 0; i < self->length; ++i)
+                                                                                           {
+                                                                                               AnyValue item = self->get_property(static_cast<uint32_t>(i));
+                                                                                               if (!item.is_undefined() && !item.is_null())
+                                                                                               {
+                                                                                                   result += item.to_std_string();
+                                                                                               }
+                                                                                               if (i < self->length - 1)
+                                                                                               {
+                                                                                                   result += sep;
+                                                                                               }
+                                                                                           }
+                                                                                           return AnyValue::make_string(result); },
+                                               key);
+            }
+
+            // --- forEach() method ---
+            if (key == "forEach")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                                                                                           if (args.empty() || !args[0].is_function())
+                                                                                           {
+                                                                                               throw RuntimeError::make_error("callback is not a function", "TypeError");
+                                                                                           }
+                                                                                           auto callback = args[0].as_function();
+                                                                                           for (uint64_t i = 0; i < self->length; ++i)
+                                                                                           {
+                                                                                               AnyValue val = self->get_property(static_cast<uint32_t>(i));
+                                                                                               if (!val.is_undefined())
+                                                                                               { // forEach skips empty slots
+                                                                                                   callback->call({val, AnyValue::make_number(i)});
+                                                                                               }
+                                                                                           }
+                                                                                           return AnyValue::make_undefined(); },
+                                               key);
+            }
+
+            return std::nullopt;
+        }
+    }
+}

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

@@ -0,0 +1,357 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "operators.hpp"
+#include <optional>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <cctype>
+
+namespace jspp
+{
+    namespace StringPrototypes
+    {
+        // This function retrieves a prototype method for a given string instance.
+        // It captures the string instance to act as the 'this' context for the method.
+        inline std::optional<AnyValue> get(const std::string &key, const std::unique_ptr<std::string> &self)
+        {
+            // --- toString() & valueOf() ---
+            if (key == "toString" || key == "valueOf")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               { return AnyValue::make_string(*self); },
+                                               key);
+            }
+
+            // --- length property ---
+            if (key == "length")
+            {
+                return AnyValue::make_accessor_descriptor([&self](const std::vector<AnyValue>) -> AnyValue
+                                                          { return AnyValue::make_number(self->length()); },
+                                                          [&self](const std::vector<AnyValue>) -> AnyValue
+                                                          { return AnyValue::make_undefined(); },
+                                                          false,
+                                                          false);
+            }
+
+            // --- charAt(pos) ---
+            if (key == "charAt")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    double pos = args.empty() ? 0 : Operators_Private::ToNumber(args[0]);
+                    int index = static_cast<int>(pos);
+                    if (index < 0 || index >= self->length()) {
+                        return AnyValue::make_string("");
+                    }
+                    return AnyValue::make_string(std::string(1, (*self)[index])); },
+                                               key);
+            }
+
+            // --- concat(str1, str2, ...) ---
+            if (key == "concat")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    std::string result = *self;
+                    for (const auto& arg : args)
+                    {
+                        result += arg.to_std_string();
+                    }
+                    return AnyValue::make_string(result); },
+                                               key);
+            }
+
+            // --- endsWith(searchString, endPosition) ---
+            if (key == "endsWith")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    if(args.empty()) return AnyValue::make_boolean(false);
+                    std::string search = args[0].to_std_string();
+                    size_t end_pos = (args.size() > 1 && !args[1].is_undefined()) ? static_cast<size_t>(Operators_Private::ToNumber(args[1])) : self->length();
+                    
+                    if (end_pos > self->length()) end_pos = self->length();
+                    if (search.length() > end_pos) return AnyValue::make_boolean(false);
+
+                    return AnyValue::make_boolean(self->substr(end_pos - search.length(), search.length()) == search); },
+                                               key);
+            }
+
+            // --- includes(searchString, position) ---
+            if (key == "includes")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    if(args.empty()) return AnyValue::make_boolean(false);
+                    std::string search = args[0].to_std_string();
+                    size_t pos = (args.size() > 1) ? static_cast<size_t>(Operators_Private::ToNumber(args[1])) : 0;
+                    
+                    return AnyValue::make_boolean(self->find(search, pos) != std::string::npos); },
+                                               key);
+            }
+
+            // --- indexOf(searchString, position) ---
+            if (key == "indexOf")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    if (args.empty()) return AnyValue::make_number(-1);
+                    std::string search = args[0].to_std_string();
+                    size_t pos = (args.size() > 1) ? static_cast<size_t>(Operators_Private::ToNumber(args[1])) : 0;
+                    size_t result = self->find(search, pos);
+                    return result == std::string::npos ? AnyValue::make_number(-1) : AnyValue::make_number(result); },
+                                               key);
+            }
+
+            // --- lastIndexOf(searchString, position) ---
+            if (key == "lastIndexOf")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    if (args.empty()) return AnyValue::make_number(-1);
+                    std::string search = args[0].to_std_string();
+                    size_t pos = (args.size() > 1 && !args[1].is_undefined()) ? static_cast<size_t>(Operators_Private::ToNumber(args[1])) : std::string::npos;
+                    size_t result = self->rfind(search, pos);
+                    return result == std::string::npos ? AnyValue::make_number(-1) : AnyValue::make_number(result); },
+                                               key);
+            }
+
+            // --- padEnd(targetLength, padString) ---
+            if (key == "padEnd")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    size_t target_length = args.empty() ? 0 : static_cast<size_t>(Operators_Private::ToNumber(args[0]));
+                    if (self->length() >= target_length) return AnyValue::make_string(*self);
+                    std::string pad_string = (args.size() > 1 && !args[1].is_undefined() && !args[1].to_std_string().empty()) ? args[1].to_std_string() : " ";
+                    std::string result = *self;
+                    while (result.length() < target_length)
+                    {
+                        result += pad_string;
+                    }
+                    return AnyValue::make_string(result.substr(0, target_length)); },
+                                               key);
+            }
+
+            // --- padStart(targetLength, padString) ---
+            if (key == "padStart")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    size_t target_length = args.empty() ? 0 : static_cast<size_t>(Operators_Private::ToNumber(args[0]));
+                    if (self->length() >= target_length) return AnyValue::make_string(*self);
+                    std::string pad_string = (args.size() > 1 && !args[1].is_undefined() && !args[1].to_std_string().empty()) ? args[1].to_std_string() : " ";
+                    std::string padding;
+                    while (padding.length() < target_length - self->length())
+                    {
+                        padding += pad_string;
+                    }
+                    return AnyValue::make_string(padding.substr(0, target_length - self->length()) + *self); },
+                                               key);
+            }
+
+            // --- repeat(count) ---
+            if (key == "repeat")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    double count = args.empty() ? 0 : Operators_Private::ToNumber(args[0]);
+                    if (count < 0) {
+                        // In a real implementation, this should throw a RangeError.
+                        return AnyValue::make_string("");
+                    }
+                    std::string result = "";
+                    for (int i = 0; i < count; ++i)
+                    {
+                        result += *self;
+                    }
+                    return AnyValue::make_string(result); },
+                                               key);
+            }
+
+            // --- replace(substr, newSubstr) ---
+            if (key == "replace")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    if (args.size() < 2) return AnyValue::make_string(*self);
+                    std::string search = args[0].to_std_string();
+                    std::string replacement = args[1].to_std_string();
+                    std::string result = *self;
+                    size_t pos = result.find(search);
+                    if (pos != std::string::npos)
+                    {
+                        result.replace(pos, search.length(), replacement);
+                    }
+                    return AnyValue::make_string(result); },
+                                               key);
+            }
+
+            // --- replaceAll(substr, newSubstr) ---
+            if (key == "replaceAll")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    if (args.size() < 2) return AnyValue::make_string(*self);
+                    std::string search = args[0].to_std_string();
+                    if (search.empty()) return AnyValue::make_string(*self);
+                    std::string replacement = args[1].to_std_string();
+                    std::string result = *self;
+                    size_t pos = result.find(search);
+                    while (pos != std::string::npos)
+                    {
+                        result.replace(pos, search.length(), replacement);
+                        pos = result.find(search, pos + replacement.length());
+                    }
+                    return AnyValue::make_string(result); },
+                                               key);
+            }
+
+            // --- slice(beginIndex, endIndex) ---
+            if (key == "slice")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    int len = self->length();
+                    int start = args.empty() ? 0 : Operators_Private::ToInt32(args[0]);
+                    int end = (args.size() < 2 || args[1].is_undefined()) ? len : Operators_Private::ToInt32(args[1]);
+
+                    if (start < 0) start += len;
+                    if (end < 0) end += len;
+
+                    start = std::max(0, std::min(len, start));
+                    end = std::max(0, std::min(len, end));
+
+                    if (start >= end) return AnyValue::make_string("");
+                    return AnyValue::make_string(self->substr(start, end - start)); },
+                                               key);
+            }
+
+            // --- split(separator) ---
+            if (key == "split")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    std::string separator = (args.empty() || args[0].is_undefined()) ? "" : args[0].to_std_string();
+                    std::vector<std::optional<AnyValue>> result_vec;
+                    
+                    if (separator.empty()) {
+                        for (char c : (*self)) {
+                            result_vec.push_back(AnyValue::make_string(std::string(1, c)));
+                        }
+                    } else {
+                        std::string temp = (*self);
+                        size_t pos = 0;
+                        while ((pos = temp.find(separator)) != std::string::npos) {
+                            result_vec.push_back(AnyValue::make_string(temp.substr(0, pos)));
+                            temp.erase(0, pos + separator.length());
+                        }
+                        result_vec.push_back(AnyValue::make_string(temp));
+                    }
+                    return AnyValue::make_array(result_vec); },
+                                               key);
+            }
+
+            // --- startsWith(searchString, position) ---
+            if (key == "startsWith")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    if(args.empty()) return AnyValue::make_boolean(false);
+                    std::string search = args[0].to_std_string();
+                    size_t pos = (args.size() > 1) ? static_cast<size_t>(Operators_Private::ToNumber(args[1])) : 0;
+                    if (pos > self->length()) pos = self->length();
+
+                    return AnyValue::make_boolean(self->rfind(search, pos) == pos); },
+                                               key);
+            }
+
+            // --- substring(indexStart, indexEnd) ---
+            if (key == "substring")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    int len = self->length();
+                    int start = args.empty() ? 0 : Operators_Private::ToInt32(args[0]);
+                    int end = (args.size() < 2 || args[1].is_undefined()) ? len : Operators_Private::ToInt32(args[1]);
+
+                    start = std::max(0, start);
+                    end = std::max(0, end);
+                    
+                    if (start > end) std::swap(start, end);
+
+                    start = std::min(len, start);
+                    end = std::min(len, end);
+
+                    return AnyValue::make_string(self->substr(start, end - start)); },
+                                               key);
+            }
+
+            // --- toLowerCase() ---
+            if (key == "toLowerCase")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    std::string result = *self;
+                    std::transform(result.begin(), result.end(), result.begin(),
+                                   [](unsigned char c){ return std::tolower(c); });
+                    return AnyValue::make_string(result); },
+                                               key);
+            }
+
+            // --- toUpperCase() ---
+            if (key == "toUpperCase")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    std::string result = *self;
+                    std::transform(result.begin(), result.end(), result.begin(),
+                                   [](unsigned char c){ return std::toupper(c); });
+                    return AnyValue::make_string(result); },
+                                               key);
+            }
+
+            // --- trim() ---
+            if (key == "trim")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    const char* whitespace = " \t\n\r\f\v";
+                    std::string result = *self;
+                    result.erase(0, result.find_first_not_of(whitespace));
+                    result.erase(result.find_last_not_of(whitespace) + 1);
+                    return AnyValue::make_string(result); },
+                                               key);
+            }
+
+            // --- trimEnd() ---
+            if (key == "trimEnd")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    const char* whitespace = " \t\n\r\f\v";
+                    std::string result = *self;
+                    result.erase(result.find_last_not_of(whitespace) + 1);
+                    return AnyValue::make_string(result); },
+                                               key);
+            }
+
+            // --- trimStart() ---
+            if (key == "trimStart")
+            {
+                return AnyValue::make_function([&self](const std::vector<AnyValue> &args) -> AnyValue
+                                               {
+                    const char* whitespace = " \t\n\r\f\v";
+                    std::string result = *self;
+                    result.erase(0, result.find_first_not_of(whitespace));
+                    return AnyValue::make_string(result); },
+                                               key);
+            }
+
+            return std::nullopt;
+        }
+    }
+}

package/src/prelude/well_known_symbols.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+namespace jspp
+{
+    namespace WellKnownSymbols
+    {
+        inline std::string iterator = std::string("Symbol(Symbol.iterator)");
+        inline std::string toString = std::string("Symbol(Symbol.toString)");
+    }
+}