@ugo-studio/jspp 0.1.2 → 0.1.4

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

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "types.hpp"
+#include "values/symbol.hpp"
+#include "any_value.hpp"
+
+namespace jspp
+{
+    namespace SymbolPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsSymbol *self)
+        {
+            // --- toString() method ---
+            if (key == "toString" )
+            {
+                return AnyValue::make_function([self](const AnyValue &thisVal, const std::vector<AnyValue> &) -> AnyValue
+                                               { return AnyValue::make_string(self->to_std_string()); },
+                                               key);
+            }
+
+            // --- description property ---
+            if (key == "description")
+            {
+                return AnyValue::make_accessor_descriptor(
+                    [self](const AnyValue &thisVal, const std::vector<AnyValue> &) -> AnyValue
+                    {
+                        if (self->description.empty())
+                        {
+                            return AnyValue::make_undefined();
+                        }
+                        return AnyValue::make_string(self->description);
+                    },
+                    std::nullopt,
+                    false,
+                    true);
+            }
+
+            return std::nullopt;
+        }
+    }
+}

package/src/prelude/values/string.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "types.hpp"
+#include <string>
+#include <unordered_map>
+
+namespace jspp
+{
+    // Forward declaration of AnyValue
+    class AnyValue;
+
+    struct JsString
+    {
+        std::string value;
+
+        JsString() = default;
+        explicit JsString(const std::string &s) : value(s) {}
+
+        std::string to_std_string() const;
+        JsIterator<AnyValue> get_iterator();
+
+        AnyValue get_property(const std::string &key, const AnyValue &thisVal);
+        AnyValue get_property(uint32_t idx);
+    };
+}

package/src/prelude/values/symbol.hpp

@@ -0,0 +1,102 @@
+#pragma once
+
+#include "types.hpp"
+#include <atomic>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <memory>
+#include <optional>
+
+namespace jspp
+{
+    // Forward declaration of AnyValue
+    class AnyValue;
+
+    struct JsSymbol
+    {
+        std::string description;
+        std::string key; // Internal unique key used for AnyValue property maps
+
+        // --- Registries ---
+
+        // 1. Global Symbol Registry (for Symbol.for/keyFor)
+        static std::unordered_map<std::string, std::shared_ptr<JsSymbol>> &registry()
+        {
+            static std::unordered_map<std::string, std::shared_ptr<JsSymbol>> reg;
+            return reg;
+        }
+
+        // 2. All Internal Keys Registry (for robust Object.keys filtering)
+        // Keeps track of every key string ever generated by a JsSymbol to distinguish
+        // them from user strings that might coincidentally look like internal keys.
+        static std::unordered_set<std::string> &internal_keys_registry()
+        {
+            static std::unordered_set<std::string> keys;
+            return keys;
+        }
+
+        static bool is_internal_key(const std::string &k)
+        {
+            return internal_keys_registry().count(k) > 0;
+        }
+
+        // --- Constructors ---
+
+        // Standard Constructor (creates unique symbol)
+        JsSymbol(const std::string &desc) : description(desc)
+        {
+            static std::atomic<uint64_t> id_counter{0};
+            // Ensure unique internal key for property storage
+            key = "__Sym" + std::to_string(id_counter++) + "_" + desc;
+
+            // Register this key as a valid symbol key
+            internal_keys_registry().insert(key);
+        }
+
+        // Constructor for Well-Known Symbols (fixed keys)
+        JsSymbol(const std::string &desc, const std::string &fixed_key)
+            : description(desc), key(fixed_key)
+        {
+            // Register this key as a valid symbol key
+            internal_keys_registry().insert(key);
+        }
+
+        // --- Global Registry API ---
+
+        // Implements Symbol.for(key)
+        static std::shared_ptr<JsSymbol> for_global(const std::string &registryKey)
+        {
+            auto &reg = registry();
+            auto it = reg.find(registryKey);
+            if (it != reg.end())
+            {
+                return it->second;
+            }
+
+            // Create new symbol with description = registryKey
+            auto newSym = std::make_shared<JsSymbol>(registryKey);
+            reg[registryKey] = newSym;
+            return newSym;
+        }
+
+        // Implements Symbol.keyFor(sym)
+        static std::optional<std::string> key_for(const JsSymbol *sym)
+        {
+            auto &reg = registry();
+            for (const auto &pair : reg)
+            {
+                // Compare raw pointers
+                if (pair.second.get() == sym)
+                {
+                    return pair.first;
+                }
+            }
+            return std::nullopt;
+        }
+
+        // --- Methods ---
+        std::string to_std_string() const;
+        AnyValue get_property(const std::string &key, const AnyValue &thisVal);
+    };
+}

package/src/prelude/access.hpp

@@ -1,86 +0,0 @@
-#pragma once
-
-#include "types.hpp"
-#include "values/function.hpp"
-#include "error.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)
-                {
-                    keys.push_back(pair.first);
-                }
-            }
-            if (obj.is_function())
-            {
-                auto ptr = obj.as_function();
-                for (const auto &pair : ptr->props)
-                {
-                    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()->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, 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));
-    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");
-}