@ugo-studio/jspp 0.1.4 → 0.1.6

package/src/prelude/library/timer.hpp

@@ -7,7 +7,7 @@
 #include "exception.hpp"
 
 // setTimeout(callback, delay, ...args)
-inline auto setTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+inline auto setTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
     if (args.empty() || !args[0].is_function()) {
         throw jspp::Exception::make_exception("Callback must be a function", "TypeError");
     }
@@ -26,7 +26,7 @@ inline auto setTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue&
 
     auto task = [callback, callArgs]() {
          try {
-             callback.as_function()->call(jspp::AnyValue::make_undefined(), callArgs);
+             callback.call(jspp::Constants::UNDEFINED, std::span<const jspp::AnyValue>(callArgs));
          } catch (const jspp::Exception& e) {
              std::cerr << "Uncaught exception in setTimeout: " << e.what() << "\n";
          } catch (const std::exception& e) {
@@ -41,7 +41,7 @@ inline auto setTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue&
 }, "setTimeout");
 
 // clearTimeout(id)
-inline auto clearTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+inline auto clearTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
     if (!args.empty() && args[0].is_number()) {
         size_t id = static_cast<size_t>(args[0].as_double());
         jspp::Scheduler::instance().clear_timer(id);
@@ -50,7 +50,7 @@ inline auto clearTimeout = jspp::AnyValue::make_function([](const jspp::AnyValue
 }, "clearTimeout");
 
 // setInterval(callback, delay, ...args)
-inline auto setInterval = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+inline auto setInterval = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
     if (args.empty() || !args[0].is_function()) {
         throw jspp::Exception::make_exception("Callback must be a function", "TypeError");
     }
@@ -68,7 +68,7 @@ inline auto setInterval = jspp::AnyValue::make_function([](const jspp::AnyValue&
 
     auto task = [callback, callArgs]() {
          try {
-             callback.as_function()->call(jspp::AnyValue::make_undefined(), callArgs);
+             callback.call(jspp::Constants::UNDEFINED, std::span<const jspp::AnyValue>(callArgs));
          } catch (const jspp::Exception& e) {
              std::cerr << "Uncaught exception in setInterval: " << e.what() << "\n";
          } catch (const std::exception& e) {
@@ -83,7 +83,7 @@ inline auto setInterval = jspp::AnyValue::make_function([](const jspp::AnyValue&
 }, "setInterval");
 
 // clearInterval(id)
-inline auto clearInterval = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+inline auto clearInterval = jspp::AnyValue::make_function([](const jspp::AnyValue& thisVal, std::span<const jspp::AnyValue> args) -> jspp::AnyValue {
     if (!args.empty() && args[0].is_number()) {
         size_t id = static_cast<size_t>(args[0].as_double());
         jspp::Scheduler::instance().clear_timer(id);

package/src/prelude/types.hpp

@@ -14,6 +14,7 @@
 #include <set>
 #include <cmath>
 #include <optional>
+#include <span>
 
 // JSPP standard library
 namespace jspp
@@ -32,6 +33,9 @@ namespace jspp
     template <typename T>
     class JsIterator; // can set property
 
+    template <typename T>
+    class JsAsyncIterator; // can set property
+
     // Object property configuration forward declarations
     struct DataDescriptor;
     struct AccessorDescriptor;
@@ -42,7 +46,53 @@ namespace jspp
     // Dynamic AnyValue
     class AnyValue;
 
+    // Awaiter for AnyValue
+    struct AnyValueAwaiter;
+
+    // Truthiness checker
+    const bool is_truthy(const double &val) noexcept;
+    const bool is_truthy(const std::string &val) noexcept;
+    const bool is_truthy(const AnyValue &val) noexcept;
+
+    // Basic equality operators
+    inline const bool is_strictly_equal_to_primitive(const AnyValue &lhs, const double &rhs) noexcept;
+    inline const bool is_strictly_equal_to_primitive(const double &lhs, const AnyValue &rhs) noexcept;
+    inline const bool is_strictly_equal_to_primitive(const double &lhs, const double &rhs) noexcept;
+    inline const bool is_strictly_equal_to_primitive(const AnyValue &lhs, const AnyValue &rhs) noexcept;
+
+    inline const bool is_equal_to_primitive(const AnyValue &lhs, const double &rhs) noexcept;
+    inline const bool is_equal_to_primitive(const double &lhs, const AnyValue &rhs) noexcept;
+    inline const bool is_equal_to_primitive(const double &lhs, const double &rhs) noexcept;
+    inline const bool is_equal_to_primitive(const AnyValue &lhs, const AnyValue &rhs) noexcept;
+
+    inline const AnyValue is_strictly_equal_to(const AnyValue &lhs, const double &rhs) noexcept;
+    inline const AnyValue is_strictly_equal_to(const double &lhs, const AnyValue &rhs) noexcept;
+    inline const AnyValue is_strictly_equal_to(const double &lhs, const double &rhs) noexcept;
+    inline const AnyValue is_strictly_equal_to(const AnyValue &lhs, const AnyValue &rhs) noexcept;
+
+    inline const AnyValue is_equal_to(const AnyValue &lhs, const double &rhs) noexcept;
+    inline const AnyValue is_equal_to(const double &lhs, const AnyValue &rhs) noexcept;
+    inline const AnyValue is_equal_to(const double &lhs, const double &rhs) noexcept;
+    inline const AnyValue is_equal_to(const AnyValue &lhs, const AnyValue &rhs) noexcept;
+
+    inline const AnyValue not_strictly_equal_to(const AnyValue &lhs, const double &rhs) noexcept;
+    inline const AnyValue not_strictly_equal_to(const double &lhs, const AnyValue &rhs) noexcept;
+    inline const AnyValue not_strictly_equal_to(const double &lhs, const double &rhs) noexcept;
+    inline const AnyValue not_strictly_equal_to(const AnyValue &lhs, const AnyValue &rhs) noexcept;
+
+    inline const AnyValue not_equal_to(const AnyValue &lhs, const double &rhs) noexcept;
+    inline const AnyValue not_equal_to(const double &lhs, const AnyValue &rhs) noexcept;
+    inline const AnyValue not_equal_to(const AnyValue &lhs, const AnyValue &rhs) noexcept;
+
+    // Bitwise operators
+    inline AnyValue unsigned_right_shift(const AnyValue &lhs, const AnyValue &rhs);
+    inline AnyValue unsigned_right_shift(const AnyValue &lhs, const double &rhs);
+    inline AnyValue unsigned_right_shift(const double &lhs, const AnyValue &rhs);
+
     // Arithemetic operators
+
+    inline AnyValue pow(const double &lhs, const double &rhs);
+    inline AnyValue pow(const AnyValue &lhs, const double &rhs);
     inline AnyValue pow(const AnyValue &lhs, const AnyValue &rhs);
 
     // AnyValue prototypes
@@ -54,6 +104,10 @@ namespace jspp
     {
         inline std::optional<AnyValue> get(const std::string &key, JsString *self);
     }
+    namespace NumberPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, double self);
+    }
     namespace ArrayPrototypes
     {
         inline std::optional<AnyValue> get(const std::string &key, JsArray *self);

package/src/prelude/utils/access.hpp

@@ -64,9 +64,12 @@ namespace jspp
             return var;
         }
 
-        inline AnyValue typeof(const AnyValue &val)
+        inline const AnyValue type_of(const std::optional<AnyValue> &val = std::nullopt)
         {
-            switch (val.get_type())
+            if (!val.has_value())
+                return AnyValue::make_string("undefined");
+
+            switch (val.value().get_type())
             {
             case JsType::Undefined:
                 return AnyValue::make_string("undefined");
@@ -83,17 +86,17 @@ namespace jspp
             case JsType::Function:
                 return AnyValue::make_string("function");
             case JsType::Object:
+                return AnyValue::make_string("object");
             case JsType::Array:
+                return AnyValue::make_string("object");
             case JsType::Iterator:
                 return AnyValue::make_string("object");
+            case JsType::AsyncIterator:
+                return AnyValue::make_string("object");
             default:
                 return AnyValue::make_string("undefined");
             }
         }
-        inline AnyValue typeof() // for undeclared variables
-        {
-            return AnyValue::make_string("undefined");
-        }
 
         // Helper function to get enumerable own property keys/values of an object
         inline std::vector<std::string> get_object_keys(const AnyValue &obj)
@@ -103,10 +106,35 @@ namespace jspp
             if (obj.is_object())
             {
                 auto ptr = obj.as_object();
-                for (const auto &pair : ptr->props)
+                // Use shape's property_names for stable iteration order
+                for (const auto &key : ptr->shape->property_names)
                 {
-                    if (!JsSymbol::is_internal_key(pair.first))
-                        keys.push_back(pair.first);
+                    if (ptr->deleted_keys.count(key))
+                        continue;
+
+                    if (JsSymbol::is_internal_key(key))
+                        continue;
+
+                    auto offset_opt = ptr->shape->get_offset(key);
+                    if (!offset_opt.has_value())
+                        continue;
+
+                    const auto &val = ptr->storage[offset_opt.value()];
+
+                    if (val.is_data_descriptor())
+                    {
+                        if (val.as_data_descriptor()->enumerable)
+                            keys.push_back(key);
+                    }
+                    else if (val.is_accessor_descriptor())
+                    {
+                        if (val.as_accessor_descriptor()->enumerable)
+                            keys.push_back(key);
+                    }
+                    else
+                    {
+                        keys.push_back(key);
+                    }
                 }
             }
             if (obj.is_function())
@@ -143,6 +171,7 @@ namespace jspp
 
             return keys;
         }
+
         inline AnyValue get_object_value_iterator(const AnyValue &obj, const std::string &name)
         {
             if (obj.is_iterator())
@@ -153,7 +182,7 @@ namespace jspp
             auto gen_fn = obj.get_own_property(WellKnownSymbols::iterator->key);
             if (gen_fn.is_function())
             {
-                auto iter = gen_fn.as_function()->call(gen_fn, {});
+                auto iter = gen_fn.call(obj, {}, WellKnownSymbols::iterator->key);
                 if (iter.is_iterator())
                 {
                     return iter;
@@ -170,5 +199,180 @@ namespace jspp
 
             throw jspp::Exception::make_exception(name + " is not iterable", "TypeError");
         }
+
+        inline AnyValue get_async_object_value_iterator(const AnyValue &obj, const std::string &name)
+        {
+            if (obj.is_async_iterator())
+                return obj;
+
+            // 1. Try Symbol.asyncIterator
+            auto method = obj.get_own_property(WellKnownSymbols::asyncIterator->key);
+            if (method.is_function())
+            {
+                auto iter = method.call(obj, {}, WellKnownSymbols::asyncIterator->key);
+                if (iter.is_object() || iter.is_async_iterator() || iter.is_iterator())
+                    return iter;
+            }
+
+            // 2. Try Symbol.iterator (sync fallback)
+            auto syncMethod = obj.get_own_property(WellKnownSymbols::iterator->key);
+            if (syncMethod.is_function())
+            {
+                auto iter = syncMethod.call(obj, {}, WellKnownSymbols::iterator->key);
+                if (iter.is_object() || iter.is_iterator())
+                    return iter;
+            }
+
+            throw jspp::Exception::make_exception(name + " is not async iterable", "TypeError");
+        }
+
+        inline AnyValue in(const AnyValue &lhs, const AnyValue &rhs)
+        {
+            if (!rhs.is_object() && !rhs.is_array() && !rhs.is_function() && !rhs.is_promise() && !rhs.is_iterator())
+            {
+                throw jspp::Exception::make_exception("Cannot use 'in' operator to search for '" + lhs.to_std_string() + "' in " + rhs.to_std_string(), "TypeError");
+            }
+            return AnyValue::make_boolean(rhs.has_property(lhs.to_std_string()));
+        }
+
+        inline AnyValue instance_of(const AnyValue &lhs, const AnyValue &rhs)
+        {
+            if (!rhs.is_function())
+            {
+                throw jspp::Exception::make_exception("Right-hand side of 'instanceof' is not callable", "TypeError");
+            }
+            if (!lhs.is_object() && !lhs.is_array() && !lhs.is_function() && !lhs.is_promise() && !lhs.is_iterator() && !lhs.is_async_iterator())
+            {
+                return Constants::FALSE;
+            }
+            AnyValue targetProto = rhs.get_own_property("prototype");
+            if (!targetProto.is_object() && !targetProto.is_array() && !targetProto.is_function())
+            {
+                throw jspp::Exception::make_exception("Function has non-object prototype in instanceof check", "TypeError");
+            }
+            // Walk prototype chain of lhs
+            AnyValue current = lhs;
+
+            while (true)
+            {
+                AnyValue proto;
+                if (current.is_object())
+                {
+                    auto p = current.as_object()->proto;
+                    if (p)
+                        proto = *p;
+                    else
+                        break;
+                }
+                else if (current.is_array())
+                {
+                    auto p = current.as_array()->proto;
+                    if (p)
+                        proto = *p;
+                    else
+                        break;
+                }
+                else if (current.is_function())
+                {
+                    auto p = current.as_function()->proto;
+                    if (p)
+                        proto = *p;
+                    else
+                        break;
+                }
+                else if (current.is_promise())
+                {
+                    // Promises don't store explicit proto yet in our impl
+                    break;
+                }
+                else if (current.is_async_iterator())
+                {
+                    // AsyncIterators don't store explicit proto yet in our impl
+                    break;
+                }
+                else
+                {
+                    break;
+                }
+                if (proto.is_null() || proto.is_undefined())
+                    break;
+                if (is_strictly_equal_to_primitive(proto, targetProto))
+                    return Constants::TRUE;
+                current = proto;
+            }
+            return Constants::FALSE;
+        }
+
+        inline AnyValue delete_property(const AnyValue &obj, const AnyValue &key)
+        {
+            if (obj.is_object())
+            {
+                auto ptr = obj.as_object();
+                std::string key_str = key.to_std_string();
+                if (ptr->shape->get_offset(key_str).has_value())
+                {
+                    ptr->deleted_keys.insert(key_str);
+                }
+                return Constants::TRUE;
+            }
+            if (obj.is_array())
+            {
+                auto ptr = obj.as_array();
+                std::string key_str = key.to_std_string();
+                if (JsArray::is_array_index(key_str))
+                {
+                    uint32_t idx = static_cast<uint32_t>(std::stoull(key_str));
+                    if (idx < ptr->dense.size())
+                    {
+                        ptr->dense[idx] = Constants::UNINITIALIZED;
+                    }
+                    else
+                    {
+                        ptr->sparse.erase(idx);
+                    }
+                }
+                else
+                {
+                    ptr->props.erase(key_str);
+                }
+                return Constants::TRUE;
+            }
+            if (obj.is_function())
+            {
+                auto ptr = obj.as_function();
+                ptr->props.erase(key.to_std_string());
+                return Constants::TRUE;
+            }
+            return Constants::TRUE;
+        }
+
+        inline AnyValue optional_get_property(const AnyValue &obj, const std::string &key)
+        {
+            if (obj.is_null() || obj.is_undefined())
+                return Constants::UNDEFINED;
+            return obj.get_own_property(key);
+        }
+
+        inline AnyValue optional_get_element(const AnyValue &obj, const AnyValue &key)
+        {
+            if (obj.is_null() || obj.is_undefined())
+                return Constants::UNDEFINED;
+            return obj.get_own_property(key);
+        }
+
+        inline AnyValue optional_get_element(const AnyValue &obj, const double &key)
+        {
+            if (obj.is_null() || obj.is_undefined())
+                return Constants::UNDEFINED;
+            return obj.get_own_property(static_cast<uint32_t>(key));
+        }
+
+        inline AnyValue optional_call(const AnyValue &fn, const AnyValue &thisVal, std::span<const AnyValue> args, const std::optional<std::string> &name = std::nullopt)
+        {
+            if (fn.is_null() || fn.is_undefined())
+                return Constants::UNDEFINED;
+            return fn.call(thisVal, args, name);
+        }
+
     }
-}
+}

package/src/prelude/utils/assignment_operators.hpp

@@ -0,0 +1,99 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "utils/operators.hpp"
+
+namespace jspp {
+
+    // --- FRIEND IMPLEMENTATIONS ---
+
+    inline AnyValue &operator+=(AnyValue &lhs, const AnyValue &rhs) {
+        lhs = lhs + rhs;
+        return lhs;
+    }
+
+    inline AnyValue &operator-=(AnyValue &lhs, const AnyValue &rhs) {
+        lhs = lhs - rhs;
+        return lhs;
+    }
+
+    inline AnyValue &operator*=(AnyValue &lhs, const AnyValue &rhs) {
+        lhs = lhs * rhs;
+        return lhs;
+    }
+
+    inline AnyValue &operator/=(AnyValue &lhs, const AnyValue &rhs) {
+        lhs = lhs / rhs;
+        return lhs;
+    }
+
+    inline AnyValue &operator%=(AnyValue &lhs, const AnyValue &rhs) {
+        lhs = lhs % rhs;
+        return lhs;
+    }
+
+    inline AnyValue &operator++(AnyValue &val) {
+        val = val + 1.0;
+        return val;
+    }
+
+    inline AnyValue operator++(AnyValue &val, int) {
+        AnyValue temp = val;
+        val = val + 1.0;
+        return temp;
+    }
+
+    inline AnyValue &operator--(AnyValue &val) {
+        val = val - 1.0;
+        return val;
+    }
+
+    inline AnyValue operator--(AnyValue &val, int) {
+        AnyValue temp = val;
+        val = val - 1.0;
+        return temp;
+    }
+
+    // --- OVERLOADS FOR PRIMITIVES ---
+
+    inline AnyValue &operator+=(AnyValue &lhs, const double &rhs) {
+        lhs = lhs + rhs;
+        return lhs;
+    }
+    inline AnyValue &operator+=(AnyValue &lhs, const int &rhs) {
+        return lhs += static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator-=(AnyValue &lhs, const double &rhs) {
+        lhs = lhs - rhs;
+        return lhs;
+    }
+    inline AnyValue &operator-=(AnyValue &lhs, const int &rhs) {
+        return lhs -= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator*=(AnyValue &lhs, const double &rhs) {
+        lhs = lhs * rhs;
+        return lhs;
+    }
+    inline AnyValue &operator*=(AnyValue &lhs, const int &rhs) {
+        return lhs *= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator/=(AnyValue &lhs, const double &rhs) {
+        lhs = lhs / rhs;
+        return lhs;
+    }
+    inline AnyValue &operator/=(AnyValue &lhs, const int &rhs) {
+        return lhs /= static_cast<double>(rhs);
+    }
+
+    inline AnyValue &operator%=(AnyValue &lhs, const double &rhs) {
+        lhs = lhs % rhs;
+        return lhs;
+    }
+    inline AnyValue &operator%=(AnyValue &lhs, const int &rhs) {
+        return lhs %= static_cast<double>(rhs);
+    }
+}

package/src/prelude/utils/log_any_value/array.hpp

@@ -45,7 +45,7 @@ namespace jspp
             {
                 for (size_t i = 0; i < item_count; ++i)
                 {
-                    std::optional<AnyValue> itemVal;
+                    AnyValue itemVal = AnyValue::make_uninitialized();
                     if (i < arr->dense.size())
                     {
                         itemVal = arr->dense[i];
@@ -58,7 +58,7 @@ namespace jspp
                             itemVal = it->second;
                         }
                     }
-                    if (itemVal.has_value() && !is_simple_value(itemVal.value()))
+                    if (!itemVal.is_uninitialized() && !is_simple_value(itemVal))
                     {
                         use_horizontal_layout = false;
                         break;
@@ -74,7 +74,7 @@ namespace jspp
 
                 for (size_t i = 0; i < item_count; ++i)
                 {
-                    std::optional<AnyValue> itemVal;
+                    AnyValue itemVal = AnyValue::make_uninitialized();
                     if (i < arr->dense.size())
                     {
                         itemVal = arr->dense[i];
@@ -88,7 +88,7 @@ namespace jspp
                         }
                     }
 
-                    if (itemVal.has_value())
+                    if (!itemVal.is_uninitialized())
                     {
                         if (empty_count > 0)
                         {
@@ -100,7 +100,7 @@ namespace jspp
                         }
                         if (needs_comma)
                             ss << Color::BRIGHT_BLACK << ", " << Color::RESET;
-                        ss << to_log_string(itemVal.value(), visited, depth + 1);
+                        ss << to_log_string(itemVal, visited, depth + 1);
                         needs_comma = true;
                     }
                     else
@@ -154,7 +154,7 @@ namespace jspp
 
             for (size_t i = 0; i < items_to_show; ++i)
             {
-                std::optional<AnyValue> itemVal;
+                AnyValue itemVal = AnyValue::make_uninitialized();
                 if (i < arr->dense.size())
                 {
                     itemVal = arr->dense[i];
@@ -168,7 +168,7 @@ namespace jspp
                     }
                 }
 
-                if (itemVal.has_value())
+                if (!itemVal.is_uninitialized())
                 {
                     if (empty_count > 0)
                     {
@@ -182,7 +182,7 @@ namespace jspp
                     if (first_item_printed)
                         ss << Color::BRIGHT_BLACK << ",\n"
                            << Color::RESET;
-                    ss << next_indent << to_log_string(itemVal.value(), visited, depth + 1);
+                    ss << next_indent << to_log_string(itemVal, visited, depth + 1);
                     first_item_printed = true;
                 }
                 else

package/src/prelude/utils/log_any_value/function.hpp

@@ -20,17 +20,19 @@ namespace jspp
                     if (fn->proto->is_function())
                     {
                         auto parent = fn->proto->as_function();
-                        if (!parent->name.empty())
+                        std::string name = parent->name.value_or("");
+                        if (!name.empty())
                         {
-                            extends_part = " extends " + parent->name;
+                            extends_part = " extends " + name;
                         }
                     }
                 }
-                return Color::CYAN + std::string("[class ") + (fn->name.empty() ? "(anonymous)" : fn->name) + extends_part + "]" + Color::RESET;
+                std::string name = fn->name.value_or("");
+                return Color::CYAN + std::string("[class ") + (name.empty() ? "(anonymous)" : name) + extends_part + "]" + Color::RESET;
             }
 
             auto type_part = fn->is_generator ? "GeneratorFunction" : "Function";
-            auto name_part = fn->name.size() > 0 ? ": " + fn->name : " (anonymous)";
+            auto name_part = fn->name.has_value() ? ": " + fn->name.value() : " (anonymous)";
             return Color::CYAN + "[" + type_part + name_part + "]" + Color::RESET;
         }
     }