@ugo-studio/jspp 0.1.4 → 0.1.5

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

@@ -4,24 +4,66 @@
 #include "values/object.hpp"
 #include "any_value.hpp"
 
+namespace jspp {
+    JsObject::JsObject() : shape(Shape::empty_shape()), proto(nullptr) {}
+
+    JsObject::JsObject(std::initializer_list<std::pair<std::string, AnyValue>> p, std::shared_ptr<AnyValue> pr) : proto(pr) {
+        shape = Shape::empty_shape();
+        storage.reserve(p.size());
+        for (const auto& pair : p) {
+            shape = shape->transition(pair.first);
+            storage.push_back(pair.second);
+        }
+    }
+
+    JsObject::JsObject(const std::map<std::string, AnyValue> &p, std::shared_ptr<AnyValue> pr) : proto(pr) {
+        shape = Shape::empty_shape();
+        storage.reserve(p.size());
+        for (const auto& pair : p) {
+            shape = shape->transition(pair.first);
+            storage.push_back(pair.second);
+        }
+    }
+}
+
 std::string jspp::JsObject::to_std_string() const
 {
     return "[Object Object]";
 }
 
+bool jspp::JsObject::has_property(const std::string &key) const
+{
+    if (deleted_keys.count(key)) return false;
+
+    if (shape->get_offset(key).has_value())
+        return true;
+    if (proto && !(*proto).is_null() && !(*proto).is_undefined())
+    {
+        if ((*proto).has_property(key))
+            return true;
+    }
+    if (ObjectPrototypes::get(key, const_cast<JsObject *>(this)).has_value())
+        return true;
+    return false;
+}
+
 jspp::AnyValue jspp::JsObject::get_property(const std::string &key, const AnyValue &thisVal)
 {
-    auto it = props.find(key);
-    if (it == props.end())
+    if (deleted_keys.count(key)) return AnyValue::make_undefined();
+
+    auto offset = shape->get_offset(key);
+    if (!offset.has_value())
     {
         // check prototype chain
         if (proto && !(*proto).is_null() && !(*proto).is_undefined())
         {
-            return (*proto).get_property_with_receiver(key, thisVal);
+            if ((*proto).has_property(key))
+            {
+                return (*proto).get_property_with_receiver(key, thisVal);
+            }
         }
 
         // check built-in prototype methods (Object.prototype)
-        // ideally these should be on the root prototype object, but for now we keep this fallback
         auto proto_it = ObjectPrototypes::get(key, this);
         if (proto_it.has_value())
         {
@@ -30,7 +72,7 @@ jspp::AnyValue jspp::JsObject::get_property(const std::string &key, const AnyVal
         // not found
         return AnyValue::make_undefined();
     }
-    return AnyValue::resolve_property_for_read(it->second, thisVal, key);
+    return AnyValue::resolve_property_for_read(storage[offset.value()], thisVal, key);
 }
 
 jspp::AnyValue jspp::JsObject::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal)
@@ -51,14 +93,17 @@ jspp::AnyValue jspp::JsObject::set_property(const std::string &key, const AnyVal
     }
 
     // set own property
-    auto it = props.find(key);
-    if (it != props.end())
+    if (deleted_keys.count(key)) deleted_keys.erase(key);
+
+    auto offset = shape->get_offset(key);
+    if (offset.has_value())
     {
-        return AnyValue::resolve_property_for_write(it->second, thisVal, value, key);
+        return AnyValue::resolve_property_for_write(storage[offset.value()], thisVal, value, key);
     }
     else
     {
-        props[key] = value;
+        shape = shape->transition(key);
+        storage.push_back(value);
         return value;
     }
 }

package/src/prelude/values/helpers/promise.hpp

@@ -24,13 +24,13 @@ namespace jspp {
              auto weak_state = std::weak_ptr<PromiseState>(state);
              
              p->then(
-                 [weak_state](AnyValue v) {
+                 [weak_state](const AnyValue& v) {
                      if (auto s = weak_state.lock()) {
                          JsPromise localP; localP.state = s;
                          localP.resolve(v); 
                      }
                  },
-                 [weak_state](AnyValue r) {
+                 [weak_state](const AnyValue& r) {
                      if (auto s = weak_state.lock()) {
                          JsPromise localP; localP.state = s;
                          localP.reject(r);
@@ -71,7 +71,7 @@ namespace jspp {
         }
     }
 
-    inline void JsPromise::then(std::function<void(AnyValue)> onFulfilled, std::function<void(AnyValue)> onRejected) {
+    inline void JsPromise::then(std::function<void(const AnyValue&)> onFulfilled, std::function<void(const AnyValue&)> onRejected) {
         if (state->status == PromiseStatus::Fulfilled) {
             if (onFulfilled) {
                 AnyValue val = *(state->result);

package/src/prelude/values/iterator.hpp

@@ -89,7 +89,7 @@ namespace jspp
 
         std::string to_std_string() const;
         NextResult next(const T &val = T());
-        std::vector<std::optional<T>> to_vector();
+        std::vector<T> to_vector();
         AnyValue get_property(const std::string &key, const AnyValue &thisVal);
         AnyValue set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal);
     };

package/src/prelude/values/object.hpp

@@ -1,6 +1,9 @@
 #pragma once
 
 #include "types.hpp"
+#include "shape.hpp"
+#include <vector>
+#include <unordered_set>
 
 namespace jspp
 {
@@ -9,13 +12,17 @@ namespace jspp
 
     struct JsObject
     {
-        std::map<std::string, AnyValue> props;
+        std::shared_ptr<Shape> shape;
+        std::vector<AnyValue> storage;
         std::shared_ptr<AnyValue> proto;
+        std::unordered_set<std::string> deleted_keys;
 
-        JsObject() : proto(nullptr) {}
-        explicit JsObject(const std::map<std::string, AnyValue> &p, std::shared_ptr<AnyValue> pr = nullptr) : props(p), proto(pr) {}
+        JsObject();
+        JsObject(std::initializer_list<std::pair<std::string, AnyValue>> p, std::shared_ptr<AnyValue> pr = nullptr);
+        JsObject(const std::map<std::string, AnyValue> &p, std::shared_ptr<AnyValue> pr = nullptr);
 
         std::string to_std_string() const;
+        bool has_property(const std::string &key) const;
         AnyValue get_property(const std::string &key, const AnyValue &thisVal);
         AnyValue set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal);
     };

package/src/prelude/values/promise.hpp

@@ -20,8 +20,8 @@ namespace jspp
     {
         PromiseStatus status = PromiseStatus::Pending;
         std::shared_ptr<AnyValue> result; // Value if fulfilled, reason if rejected
-        std::vector<std::function<void(AnyValue)>> onFulfilled;
-        std::vector<std::function<void(AnyValue)>> onRejected;
+        std::vector<std::function<void(const AnyValue&)>> onFulfilled;
+        std::vector<std::function<void(const AnyValue&)>> onRejected;
         
         PromiseState(); // Defined in helpers
     };
@@ -40,7 +40,7 @@ namespace jspp
         // --- Promise Logic ---
         void resolve(const AnyValue& value);
         void reject(const AnyValue& reason);
-        void then(std::function<void(AnyValue)> onFulfilled, std::function<void(AnyValue)> onRejected = nullptr);
+        void then(std::function<void(const AnyValue&)> onFulfilled, std::function<void(const AnyValue&)> onRejected = nullptr);
         
         // --- Methods ---
         std::string to_std_string() const;