@ugo-studio/jspp 0.3.1 → 0.3.2

package/src/prelude/values/number.cpp

@@ -1,51 +1,88 @@
 #include "jspp.hpp"
 #include "values/prototypes/number.hpp"
 
-namespace jspp {
-
-namespace NumberPrototypes {
-
-std::string number_to_radix_string(double value, int radix)
+namespace jspp
 {
-    if (std::isnan(value))
-        return "NaN";
-    if (!std::isfinite(value))
-        return value > 0 ? "Infinity" : "-Infinity";
 
-    long long intPart = static_cast<long long>(value);
+    // --- JsNumber Implementation ---
 
-    if (radix == 10)
+    namespace JsNumber
     {
-        return AnyValue::make_number(value).to_std_string();
-    }
-
-    bool negative = intPart < 0;
-    if (negative)
-        intPart = -intPart;
+        std::string to_std_string(double num)
+        {
+            if (std::isnan(num))
+                return "NaN";
+            if (std::abs(num) >= 1e21 || (std::abs(num) > 0 && std::abs(num) < 1e-6))
+            {
+                std::ostringstream oss;
+                oss << std::scientific << std::setprecision(4) << num;
+                return oss.str();
+            }
+            else
+            {
+                std::ostringstream oss;
+                oss << std::setprecision(6) << std::fixed << num;
+                std::string s = oss.str();
+                s.erase(s.find_last_not_of('0') + 1, std::string::npos);
+                if (!s.empty() && s.back() == '.')
+                    s.pop_back();
+                return s;
+            }
+        }
 
-    std::string chars = "0123456789abcdefghijklmnopqrstuvwxyz";
-    std::string res = "";
+        std::string to_std_string(const AnyValue &value)
+        {
+            return to_std_string(value.as_double());
+        }
 
-    if (intPart == 0)
-        res = "0";
-    else
-    {
-        while (intPart > 0)
+        std::string to_radix_string(double value, int radix)
         {
-            res += chars[intPart % radix];
-            intPart /= radix;
+            if (std::isnan(value))
+                return "NaN";
+            if (!std::isfinite(value))
+                return value > 0 ? "Infinity" : "-Infinity";
+
+            long long intPart = static_cast<long long>(value);
+
+            if (radix == 10)
+            {
+                return AnyValue::make_number(value).to_std_string();
+            }
+
+            bool negative = intPart < 0;
+            if (negative)
+                intPart = -intPart;
+
+            std::string chars = "0123456789abcdefghijklmnopqrstuvwxyz";
+            std::string res = "";
+
+            if (intPart == 0)
+                res = "0";
+            else
+            {
+                while (intPart > 0)
+                {
+                    res += chars[intPart % radix];
+                    intPart /= radix;
+                }
+            }
+            if (negative)
+                res += "-";
+            std::reverse(res.begin(), res.end());
+            return res;
         }
+
     }
-    if (negative)
-        res += "-";
-    std::reverse(res.begin(), res.end());
-    return res;
-}
 
-AnyValue &get_toExponential_fn()
-{
-    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
-                                                 {
+    // --- NumberPrototypes Implementation ---
+
+    namespace NumberPrototypes
+    {
+
+        AnyValue &get_toExponential_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                         {
                                                      double self = thisVal.as_double();
                                                      int digits = -1;
                                                      if (!args.empty() && !args[0].is_undefined())
@@ -69,14 +106,14 @@ AnyValue &get_toExponential_fn()
 
                                                      std::string res = ss.str();
                                                      return AnyValue::make_string(res); },
-                                                 "toExponential");
-    return fn;
-}
+                                                         "toExponential");
+            return fn;
+        }
 
-AnyValue &get_toFixed_fn()
-{
-    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
-                                                 {
+        AnyValue &get_toFixed_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                         {
                                                      double self = thisVal.as_double();
                                                      int digits = 0;
                                                      if (!args.empty() && !args[0].is_undefined())
@@ -91,14 +128,14 @@ AnyValue &get_toFixed_fn()
                                                      std::ostringstream ss;
                                                      ss << std::fixed << std::setprecision(digits) << self;
                                                      return AnyValue::make_string(ss.str()); },
-                                                 "toFixed");
-    return fn;
-}
+                                                         "toFixed");
+            return fn;
+        }
 
-AnyValue &get_toPrecision_fn()
-{
-    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
-                                                 {
+        AnyValue &get_toPrecision_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                         {
                                                      double self = thisVal.as_double();
                                                      if (args.empty() || args[0].is_undefined())
                                                      {
@@ -113,14 +150,14 @@ AnyValue &get_toPrecision_fn()
                                                      std::ostringstream ss;
                                                      ss << std::setprecision(precision) << self;
                                                      return AnyValue::make_string(ss.str()); },
-                                                 "toPrecision");
-    return fn;
-}
+                                                         "toPrecision");
+            return fn;
+        }
 
-AnyValue &get_toString_fn()
-{
-    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
-                                                 {
+        AnyValue &get_toString_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> args) -> AnyValue
+                                                         {
                                                      double self = thisVal.as_double();
                                                      int radix = 10;
                                                      if (!args.empty() && !args[0].is_undefined())
@@ -132,45 +169,53 @@ AnyValue &get_toString_fn()
                                                          throw Exception::make_exception("toString() radix argument must be between 2 and 36", "RangeError");
                                                      }
 
-                                                     return AnyValue::make_string(number_to_radix_string(self, radix)); },
-                                                 "toString");
-    return fn;
-}
+                                                     return AnyValue::make_string(JsNumber::to_radix_string(self, radix)); },
+                                                         "toString");
+            return fn;
+        }
 
-AnyValue &get_valueOf_fn()
-{
-    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
-                                                 { return AnyValue::make_number(thisVal.as_double()); },
-                                                 "valueOf");
-    return fn;
-}
+        AnyValue &get_valueOf_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                                         { return AnyValue::make_number(thisVal.as_double()); },
+                                                         "valueOf");
+            return fn;
+        }
 
-AnyValue &get_toLocaleString_fn()
-{
-    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
-                                                 { return AnyValue::make_string(AnyValue::make_number(thisVal.as_double()).to_std_string()); },
-                                                 "toLocaleString");
-    return fn;
-}
+        AnyValue &get_toLocaleString_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue>) -> AnyValue
+                                                         { return AnyValue::make_string(AnyValue::make_number(thisVal.as_double()).to_std_string()); },
+                                                         "toLocaleString");
+            return fn;
+        }
 
-std::optional<AnyValue> get(const std::string &key)
-{
-    if (key == "toExponential") return get_toExponential_fn();
-    if (key == "toFixed") return get_toFixed_fn();
-    if (key == "toPrecision") return get_toPrecision_fn();
-    if (key == "toString") return get_toString_fn();
-    if (key == "valueOf") return get_valueOf_fn();
-    if (key == "toLocaleString") return get_toLocaleString_fn();
-    return std::nullopt;
-}
-
-std::optional<AnyValue> get(const AnyValue &key)
-{
-    if (key == "toString" || key == AnyValue::from_symbol(WellKnownSymbols::toStringTag)) return get_toString_fn();
-    if (key == "valueOf") return get_valueOf_fn();
-    return std::nullopt;
-}
+        std::optional<AnyValue> get(const std::string &key)
+        {
+            if (key == "toExponential")
+                return get_toExponential_fn();
+            if (key == "toFixed")
+                return get_toFixed_fn();
+            if (key == "toPrecision")
+                return get_toPrecision_fn();
+            if (key == "toString")
+                return get_toString_fn();
+            if (key == "valueOf")
+                return get_valueOf_fn();
+            if (key == "toLocaleString")
+                return get_toLocaleString_fn();
+            return std::nullopt;
+        }
+
+        std::optional<AnyValue> get(const AnyValue &key)
+        {
+            if (key == "toString" || key == AnyValue::from_symbol(WellKnownSymbols::toStringTag))
+                return get_toString_fn();
+            if (key == "valueOf")
+                return get_valueOf_fn();
+            return std::nullopt;
+        }
 
-} // namespace NumberPrototypes
+    } // namespace NumberPrototypes
 
 } // namespace jspp

package/src/prelude/values/object.cpp

@@ -2,158 +2,199 @@
 #include "values/object.hpp"
 #include "values/prototypes/object.hpp"
 
-namespace jspp {
+namespace jspp
+{
 
-// --- JsObject Implementation ---
+    // --- JsObject Implementation ---
 
-JsObject::JsObject() : shape(Shape::empty_shape()), proto(Constants::Null) {}
+    JsObject::JsObject() : shape(Shape::empty_shape()), proto(Constants::Null) {}
 
-JsObject::JsObject(std::initializer_list<std::pair<std::string, AnyValue>> p, 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(std::initializer_list<std::pair<std::string, AnyValue>> p, 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, 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, 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 JsObject::to_std_string() const {
-    return "[Object Object]";
-}
+    std::string JsObject::to_std_string() const
+    {
+        return "[Object Object]";
+    }
 
-bool JsObject::has_property(const std::string &key) const {
-    if (deleted_keys.count(key)) return false;
+    bool 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.is_null() && !proto.is_undefined()) {
-        if (proto.has_property(key))
+        if (shape->get_offset(key).has_value())
             return true;
+        if (!proto.is_null() && !proto.is_undefined())
+        {
+            if (proto.has_property(key))
+                return true;
+        }
+        if (ObjectPrototypes::get(key).has_value())
+            return true;
+        return false;
     }
-    if (ObjectPrototypes::get(key).has_value())
-        return true;
-    return false;
-}
-
-bool JsObject::has_symbol_property(const AnyValue &key) const {
-    if (symbol_props.count(key))
-        return true;
-    if (!proto.is_null() && !proto.is_undefined()) {
-        if (proto.has_property(key)) return true;
+
+    bool JsObject::has_symbol_property(const AnyValue &key) const
+    {
+        if (symbol_props.count(key))
+            return true;
+        if (!proto.is_null() && !proto.is_undefined())
+        {
+            if (proto.has_property(key))
+                return true;
+        }
+        if (ObjectPrototypes::get(key).has_value())
+            return true;
+        return false;
     }
-    if (ObjectPrototypes::get(key).has_value())
-        return true;
-    return false;
-}
-
-AnyValue JsObject::get_property(const std::string &key, const AnyValue &thisVal) {
-    if (deleted_keys.count(key)) return Constants::UNDEFINED;
-
-    auto offset = shape->get_offset(key);
-    if (!offset.has_value()) {
-        if (!proto.is_null() && !proto.is_undefined()) {
-            if (proto.has_property(key)) {
-                return proto.get_property_with_receiver(key, thisVal);
+
+    AnyValue JsObject::get_property(const std::string &key, const AnyValue &thisVal)
+    {
+        if (deleted_keys.count(key))
+            return Constants::UNDEFINED;
+
+        auto offset = shape->get_offset(key);
+        if (!offset.has_value())
+        {
+            if (!proto.is_null() && !proto.is_undefined())
+            {
+                if (proto.has_property(key))
+                {
+                    return proto.get_property_with_receiver(key, thisVal);
+                }
             }
-        }
 
-        auto proto_it = ObjectPrototypes::get(key);
-        if (proto_it.has_value()) {
-            return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
+            auto proto_it = ObjectPrototypes::get(key);
+            if (proto_it.has_value())
+            {
+                return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key);
+            }
+            return Constants::UNDEFINED;
         }
-        return Constants::UNDEFINED;
+        return AnyValue::resolve_property_for_read(storage[offset.value()], thisVal, key);
     }
-    return AnyValue::resolve_property_for_read(storage[offset.value()], thisVal, key);
-}
-
-AnyValue JsObject::get_symbol_property(const AnyValue &key, const AnyValue &thisVal) {
-    auto it = symbol_props.find(key);
-    if (it == symbol_props.end()) {
-        if (!proto.is_null() && !proto.is_undefined()) {
-            auto res = proto.get_symbol_property_with_receiver(key, thisVal);
-            if (!res.is_undefined()) return res;
+
+    AnyValue JsObject::get_symbol_property(const AnyValue &key, const AnyValue &thisVal)
+    {
+        auto it = symbol_props.find(key);
+        if (it == symbol_props.end())
+        {
+            if (!proto.is_null() && !proto.is_undefined())
+            {
+                auto res = proto.get_symbol_property_with_receiver(key, thisVal);
+                if (!res.is_undefined())
+                    return res;
+            }
+
+            auto proto_it = ObjectPrototypes::get(key);
+            if (proto_it.has_value())
+            {
+                return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key.to_std_string());
+            }
+            return Constants::UNDEFINED;
         }
+        return AnyValue::resolve_property_for_read(it->second, thisVal, key.to_std_string());
+    }
 
+    AnyValue JsObject::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal)
+    {
         auto proto_it = ObjectPrototypes::get(key);
-        if (proto_it.has_value()) {
-            return AnyValue::resolve_property_for_read(proto_it.value(), thisVal, key.to_std_string());
+        if (proto_it.has_value())
+        {
+            auto proto_value = proto_it.value();
+            if (proto_value.is_accessor_descriptor())
+            {
+                return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
+            }
+            if (proto_value.is_data_descriptor() && !proto_value.as_data_descriptor()->writable)
+            {
+                return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
+            }
         }
-        return Constants::UNDEFINED;
-    }
-    return AnyValue::resolve_property_for_read(it->second, thisVal, key.to_std_string());
-}
-
-AnyValue JsObject::set_property(const std::string &key, const AnyValue &value, const AnyValue &thisVal) {
-    auto proto_it = ObjectPrototypes::get(key);
-    if (proto_it.has_value()) {
-        auto proto_value = proto_it.value();
-        if (proto_value.is_accessor_descriptor()) {
-            return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
+
+        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(storage[offset.value()], thisVal, value, key);
         }
-        if (proto_value.is_data_descriptor() && !proto_value.as_data_descriptor()->writable) {
-            return AnyValue::resolve_property_for_write(proto_value, thisVal, value, key);
+        else
+        {
+            shape = shape->transition(key);
+            storage.push_back(value);
+            return value;
         }
     }
 
-    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(storage[offset.value()], thisVal, value, key);
-    } else {
-        shape = shape->transition(key);
-        storage.push_back(value);
-        return value;
-    }
-}
-
-AnyValue JsObject::set_symbol_property(const AnyValue &key, const AnyValue &value, const AnyValue &thisVal) {
-    auto it = symbol_props.find(key);
-    if (it != symbol_props.end()) {
-        return AnyValue::resolve_property_for_write(it->second, thisVal, value, key.to_std_string());
-    } else {
-        symbol_props[key] = value;
-        return value;
+    AnyValue JsObject::set_symbol_property(const AnyValue &key, const AnyValue &value, const AnyValue &thisVal)
+    {
+        auto it = symbol_props.find(key);
+        if (it != symbol_props.end())
+        {
+            return AnyValue::resolve_property_for_write(it->second, thisVal, value, key.to_std_string());
+        }
+        else
+        {
+            symbol_props[key] = value;
+            return value;
+        }
     }
-}
 
-// --- ObjectPrototypes Implementation ---
+    // --- ObjectPrototypes Implementation ---
 
-namespace ObjectPrototypes {
+    namespace ObjectPrototypes
+    {
 
-AnyValue& get_toString_fn() {
-    static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> _) -> AnyValue
-                                                 { return AnyValue::make_string(thisVal.to_std_string()); },
-                                                 "toString");
-    return fn;
-}
+        AnyValue &get_toString_fn()
+        {
+            static AnyValue fn = AnyValue::make_function([](const AnyValue &thisVal, std::span<const AnyValue> _) -> AnyValue
+                                                         { return AnyValue::make_string(thisVal.to_std_string()); },
+                                                         "toString");
+            return fn;
+        }
 
-std::optional<AnyValue> get(const std::string &key) {
-    if (key == "toString") {
-        return get_toString_fn();
-    }
-    return std::nullopt;
-}
+        std::optional<AnyValue> get(const std::string &key)
+        {
+            if (key == "toString")
+            {
+                return get_toString_fn();
+            }
+            return std::nullopt;
+        }
 
-std::optional<AnyValue> get(const AnyValue &key) {
-    if (key.is_string())
-        return get(key.as_string()->value);
+        std::optional<AnyValue> get(const AnyValue &key)
+        {
+            if (key.is_string())
+                return get(key.as_string()->value);
 
-    if (key == AnyValue::from_symbol(WellKnownSymbols::toStringTag)) {
-        return get_toString_fn();
-    }
-    return std::nullopt;
-}
+            if (key == AnyValue::from_symbol(WellKnownSymbols::toStringTag))
+            {
+                return get_toString_fn();
+            }
+            return std::nullopt;
+        }
 
-} // namespace ObjectPrototypes
+    } // namespace ObjectPrototypes
 
 } // namespace jspp

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

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "types.hpp"
+#include <optional>
+
+namespace jspp
+{
+    class AnyValue;
+
+    namespace JsBoolean
+    {
+        std::string to_std_string(bool value);
+        std::string to_std_string(const AnyValue &value);
+    }
+
+    namespace BooleanPrototypes
+    {
+        AnyValue &get_toString_fn();
+        AnyValue &get_valueOf_fn();
+
+        std::optional<AnyValue> get(const std::string &key);
+        std::optional<AnyValue> get(const AnyValue &key);
+    }
+}

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

@@ -7,9 +7,16 @@ namespace jspp
 {
     class AnyValue;
 
+    namespace JsNumber
+    {
+        std::string to_std_string(double num);
+        std::string to_std_string(const AnyValue &value);
+        std::string to_radix_string(double value, int radix);
+
+    }
+
     namespace NumberPrototypes
     {
-        std::string number_to_radix_string(double value, int radix);
         AnyValue &get_toExponential_fn();
         AnyValue &get_toFixed_fn();
         AnyValue &get_toPrecision_fn();

package/dist/cli/file-utils.js

@@ -1,20 +0,0 @@
-import fs from "fs/promises";
-import path from "path";
-export async function getLatestMtime(dirPath) {
-    let maxMtime = 0;
-    const entries = await fs.readdir(dirPath, { withFileTypes: true });
-    for (const entry of entries) {
-        const fullPath = path.join(dirPath, entry.name);
-        if (entry.isDirectory()) {
-            const nestedMtime = await getLatestMtime(fullPath);
-            if (nestedMtime > maxMtime)
-                maxMtime = nestedMtime;
-        }
-        else {
-            const stats = await fs.stat(fullPath);
-            if (stats.mtimeMs > maxMtime)
-                maxMtime = stats.mtimeMs;
-        }
-    }
-    return maxMtime;
-}