@ugo-studio/jspp 0.1.1 → 0.1.3

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

@@ -0,0 +1,39 @@
+#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" || key == WellKnownSymbols::toString->key)
+            {
+                return AnyValue::make_function([self](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 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);
+        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);
+    };
+}

package/src/prelude/well_known_symbols.hpp

@@ -1,10 +1,14 @@
 #pragma once
 
+#include "values/symbol.hpp"
+#include <memory>
+
 namespace jspp
 {
     namespace WellKnownSymbols
     {
-        inline std::string iterator = std::string("Symbol(Symbol.iterator)");
-        inline std::string toString = std::string("Symbol(Symbol.toString)");
+        // We use a specific prefix "@@" for well-known symbols to distinguish them from user symbols
+        inline std::shared_ptr<JsSymbol> iterator = std::make_shared<JsSymbol>("Symbol.iterator", "@@iterator");
+        inline std::shared_ptr<JsSymbol> toString = std::make_shared<JsSymbol>("Symbol.toString", "@@toString");
     }
-}
+}

package/src/prelude/values/operators/function.hpp

@@ -1,34 +0,0 @@
-#pragma once
-
-#include "types.hpp"
-#include "values/function.hpp"
-#include "any_value.hpp"
-
-std::string jspp::JsFunction::to_std_string() const
-{
-    return "function " + name + "() { [native code] }";
-}
-
-jspp::AnyValue jspp::JsFunction::get_property(const std::string &key)
-{
-    auto it = props.find(key);
-    if (it != props.end())
-    {
-        return jspp::AnyValue::resolve_property_for_read(it->second);
-    }
-    return jspp::AnyValue::make_undefined();
-}
-
-jspp::AnyValue jspp::JsFunction::set_property(const std::string &key, const AnyValue &value)
-{
-    auto it = props.find(key);
-    if (it != props.end())
-    {
-        return jspp::AnyValue::resolve_property_for_write(it->second, value);
-    }
-    else
-    {
-        props[key] = value;
-        return value;
-    }
-}