@ugo-studio/jspp 0.1.3 → 0.1.5

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

@@ -3,6 +3,7 @@
 #include "types.hpp"
 #include "values/symbol.hpp"
 #include "any_value.hpp"
+#include "utils/well_known_symbols.hpp"
 
 namespace jspp
 {
@@ -11,21 +12,39 @@ namespace jspp
         inline std::optional<AnyValue> get(const std::string &key, JsSymbol *self)
         {
             // --- toString() method ---
-            if (key == "toString" || key == WellKnownSymbols::toString->key)
+            if (key == "toString" || key == WellKnownSymbols::toStringTag->key)
             {
-                return AnyValue::make_function([self](const std::vector<AnyValue> &) -> AnyValue
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
                                                { return AnyValue::make_string(self->to_std_string()); },
                                                key);
             }
 
+            // --- valueOf() method ---
+            if (key == "valueOf")
+            {
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                               { return thisVal; },
+                                               key);
+            }
+
+            // --- [Symbol.toPrimitive] ---
+            if (key == WellKnownSymbols::toPrimitive->key)
+            {
+                return AnyValue::make_function([self](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                               { return thisVal; },
+                                               "[Symbol.toPrimitive]");
+            }
+
             // --- description property ---
             if (key == "description")
             {
                 return AnyValue::make_accessor_descriptor(
-                    [self](const std::vector<AnyValue> &) -> AnyValue
+                    [self](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
                     {
                         if (self->description.empty())
+                        {
                             return AnyValue::make_undefined();
+                        }
                         return AnyValue::make_string(self->description);
                     },
                     std::nullopt,

package/src/prelude/values/shape.hpp

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include <memory>
+#include <optional>
+#include <span>
+
+namespace jspp {
+
+class Shape {
+public:
+    // Map property name -> storage index
+    std::unordered_map<std::string, uint32_t> property_offsets;
+    // Map property name -> next Shape (transitions)
+    std::unordered_map<std::string, std::shared_ptr<Shape>> transitions;
+    
+    // For fast enumeration (Object.keys)
+    std::vector<std::string> property_names; 
+
+    // Singleton empty shape
+    static std::shared_ptr<Shape> empty_shape() {
+        static auto shape = std::make_shared<Shape>();
+        return shape;
+    }
+
+    std::optional<uint32_t> get_offset(const std::string& name) const {
+        auto it = property_offsets.find(name);
+        if (it != property_offsets.end()) return it->second;
+        return std::nullopt;
+    }
+
+    std::shared_ptr<Shape> transition(const std::string& name) {
+        auto it = transitions.find(name);
+        if (it != transitions.end()) return it->second;
+
+        // Create new shape
+        auto new_shape = std::make_shared<Shape>();
+        new_shape->property_offsets = this->property_offsets;
+        new_shape->property_names = this->property_names;
+        
+        uint32_t new_offset = static_cast<uint32_t>(new_shape->property_offsets.size());
+        new_shape->property_offsets[name] = new_offset;
+        new_shape->property_names.push_back(name);
+
+        transitions[name] = new_shape;
+        return new_shape;
+    }
+};
+
+}

package/src/prelude/values/string.hpp

@@ -19,7 +19,7 @@ namespace jspp
         std::string to_std_string() const;
         JsIterator<AnyValue> get_iterator();
 
-        AnyValue get_property(const std::string &key);
+        AnyValue get_property(const std::string &key, const AnyValue &thisVal);
         AnyValue get_property(uint32_t idx);
     };
 }

package/src/prelude/values/symbol.hpp

@@ -97,6 +97,6 @@ namespace jspp
 
         // --- Methods ---
         std::string to_std_string() const;
-        AnyValue get_property(const std::string &key);
+        AnyValue get_property(const std::string &key, const AnyValue &thisVal);
     };
 }

package/src/prelude/access.hpp

@@ -1,91 +0,0 @@
-#pragma once
-
-#include "types.hpp"
-#include "well_known_symbols.hpp"
-#include "values/function.hpp"
-#include "values/symbol.hpp"
-#include "error.hpp"
-#include "any_value.hpp"
-#include <ranges>
-
-namespace jspp
-{
-    namespace Access
-    {
-        // Helper function to check for TDZ and deref variables
-        inline const AnyValue &deref(const std::shared_ptr<AnyValue> &var, const std::string &name)
-        {
-            if ((*var).is_uninitialized()) [[unlikely]]
-            {
-                RuntimeError::throw_uninitialized_reference_error(name);
-            }
-            return *var;
-        }
-        inline AnyValue &deref(std::shared_ptr<AnyValue> &var, const std::string &name)
-        {
-            if ((*var).is_uninitialized()) [[unlikely]]
-            {
-                RuntimeError::throw_uninitialized_reference_error(name);
-            }
-            return *var;
-        }
-        inline const AnyValue &deref(const std::unique_ptr<AnyValue> &var, const std::string &name)
-        {
-            if ((*var).is_uninitialized()) [[unlikely]]
-            {
-                RuntimeError::throw_uninitialized_reference_error(name);
-            }
-            return *var;
-        }
-        inline AnyValue &deref(std::unique_ptr<AnyValue> &var, const std::string &name)
-        {
-            if ((*var).is_uninitialized()) [[unlikely]]
-            {
-                RuntimeError::throw_uninitialized_reference_error(name);
-            }
-            return *var;
-        }
-
-        inline std::vector<std::string> get_object_keys(const AnyValue &obj)
-        {
-            std::vector<std::string> keys;
-
-            if (obj.is_object())
-            {
-                auto ptr = obj.as_object();
-                for (const auto &pair : ptr->props)
-                {
-                    if (!JsSymbol::is_internal_key(pair.first))
-                        keys.push_back(pair.first);
-                }
-            }
-            if (obj.is_function())
-            {
-                auto ptr = obj.as_function();
-                for (const auto &pair : ptr->props)
-                {
-                    if (!JsSymbol::is_internal_key(pair.first))
-                        keys.push_back(pair.first);
-                }
-            }
-            if (obj.is_array())
-            {
-                auto len = obj.as_array()->length;
-                for (auto i = 0; i < len; ++i)
-                {
-                    keys.push_back(std::to_string(i));
-                }
-            }
-            if (obj.is_string())
-            {
-                auto len = obj.as_string()->value.length();
-                for (auto i = 0; i < len; ++i)
-                {
-                    keys.push_back(std::to_string(i));
-                }
-            }
-
-            return keys;
-        }
-    }
-}

package/src/prelude/error.hpp

@@ -1,31 +0,0 @@
-
-#pragma once
-
-#include "types.hpp"
-
-namespace jspp
-{
-    class AnyValue;
-
-    struct RuntimeError : std::exception
-    {
-        std::shared_ptr<AnyValue> data;
-
-        explicit RuntimeError(std::shared_ptr<AnyValue> d)
-            : data(std::move(d)) {}
-        explicit RuntimeError(const AnyValue &value)
-            : data(std::make_shared<AnyValue>(value)) {}
-        explicit RuntimeError(AnyValue &&value)
-            : data(std::make_shared<AnyValue>(std::move(value))) {}
-
-        const char *what() const noexcept override;
-        static RuntimeError make_error(const std::string &message, const std::string &name);
-        static AnyValue error_to_value(const std::exception &ex);
-
-        // --- THROWERS
-        static AnyValue throw_unresolved_reference_error(const std::string &var_name);
-        static AnyValue throw_uninitialized_reference_error(const std::string &var_name);
-        static AnyValue throw_immutable_assignment_error();
-        static AnyValue throw_invalid_return_statement_error();
-    };
-}

package/src/prelude/error_helpers.hpp

@@ -1,59 +0,0 @@
-#pragma once
-
-#include "types.hpp"
-#include "error.hpp"
-#include "any_value.hpp"
-
-const char *jspp::RuntimeError::what() const noexcept
-{
-    return data->to_std_string().c_str();
-}
-
-jspp::RuntimeError jspp::RuntimeError::make_error(const std::string &message, const std::string &name = "Error")
-{
-    auto errorObj = std::make_shared<AnyValue>(AnyValue::make_object({{"message", AnyValue::make_string(message)}, {"name", AnyValue::make_string(name)}}));
-    (*errorObj).set_own_property(WellKnownSymbols::toString->key, AnyValue::make_function([errorObj](const std::vector<AnyValue> &) -> AnyValue
-                                                                                          {
-                                                                                  AnyValue name = (*errorObj).get_own_property("name");
-                                                                                  AnyValue message = (*errorObj).get_own_property("message");
-                                                                                  std::string str = "";
-                                                                                  if (name.is_string())
-                                                                                      str = name.to_std_string();
-                                                                                  else
-                                                                                      str = "Error";
-                                                                                  str += ": ";
-                                                                                  if (message.is_string())
-                                                                                      str += message.to_std_string();
-                                                                                  return AnyValue::make_string(str); },
-                                                                                          WellKnownSymbols::toString->key));
-    return RuntimeError(errorObj);
-}
-jspp::AnyValue jspp::RuntimeError::error_to_value(const std::exception &ex)
-{
-    if (const jspp::RuntimeError *err = dynamic_cast<const jspp::RuntimeError *>(&ex))
-    {
-        return (*err->data);
-    }
-    else
-    {
-        return AnyValue::make_string(ex.what());
-    }
-}
-
-// --- THROWERS
-jspp::AnyValue jspp::RuntimeError::throw_unresolved_reference_error(const std::string &var_name)
-{
-    throw RuntimeError::make_error(var_name + " is not defined", "ReferenceError");
-}
-jspp::AnyValue jspp::RuntimeError::throw_uninitialized_reference_error(const std::string &var_name)
-{
-    throw RuntimeError::make_error("Cannot access '" + var_name + "' before initialization", "ReferenceError");
-}
-jspp::AnyValue jspp::RuntimeError::throw_immutable_assignment_error()
-{
-    throw RuntimeError::make_error("Assignment to constant variable.", "TypeError");
-}
-jspp::AnyValue jspp::RuntimeError::throw_invalid_return_statement_error()
-{
-    throw RuntimeError::make_error("Return statements are only valid inside functions.", "SyntaxError");
-}