sebastienros.jint/Jint/Native/Json/JsonInstance.cs

using Jint.Collections;
using Jint.Native.Object;
using Jint.Native.Symbol;
using Jint.Runtime;
using Jint.Runtime.Descriptors;
using Jint.Runtime.Interop;

namespace Jint.Native.Json
{
    internal sealed class JsonInstance : ObjectInstance
    {
        private readonly Realm _realm;

        internal JsonInstance(
            Engine engine,
            Realm realm,
            ObjectPrototype objectPrototype)
            : base(engine)
        {
            _realm = realm;
            _prototype = objectPrototype;
        }

        protected override void Initialize()
        {
            var properties = new PropertyDictionary(2, checkExistingKeys: false)
            {
#pragma warning disable 618
                ["parse"] = new PropertyDescriptor(new ClrFunction(Engine, "parse", Parse, 2, PropertyFlag.Configurable), true, false, true),
                ["stringify"] = new PropertyDescriptor(new ClrFunction(Engine, "stringify", Stringify, 3, PropertyFlag.Configurable), true, false, true)
#pragma warning restore 618
            };
            SetProperties(properties);

            var symbols = new SymbolDictionary(1)
            {
                [GlobalSymbolRegistry.ToStringTag] = new PropertyDescriptor("JSON", false, false, true),
            };
            SetSymbols(symbols);
        }

        private static JsValue InternalizeJSONProperty(JsValue holder, JsValue name, ICallable reviver)
        {
            var temp = holder.Get(name);
            if (temp is ObjectInstance val)
            {
                if (val.IsArray())
                {
                    var i = 0UL;
                    var len = TypeConverter.ToLength(val.Get(CommonProperties.Length));
                    while (i < len)
                    {
                        var prop = JsString.Create(i);
                        var newElement = InternalizeJSONProperty(val, prop, reviver);
                        if (newElement.IsUndefined())
                        {
                            val.Delete(prop);
                        }
                        else
                        {
                            val.CreateDataProperty(prop, newElement);
                        }
                        i = i + 1;
                    }
                }
                else
                {
                    var keys = val.EnumerableOwnProperties(EnumerableOwnPropertyNamesKind.Key);
                    foreach (var p in keys)
                    {
                        var newElement = InternalizeJSONProperty(val, p, reviver);
                        if (newElement.IsUndefined())
                        {
                            val.Delete(p);
                        }
                        else
                        {
                            val.CreateDataProperty(p, newElement);
                        }
                    }
                }
            }

            return reviver.Call(holder, new[] { name, temp });
        }

        /// <summary>
        /// https://tc39.es/ecma262/#sec-json.parse
        /// </summary>
        private JsValue Parse(JsValue thisObject, JsValue[] arguments)
        {
            var jsonString = TypeConverter.ToString(arguments.At(0));
            var reviver = arguments.At(1);

            var parser = new JsonParser(_engine);
            var unfiltered = parser.Parse(jsonString);

            if (reviver.IsCallable)
            {
                var root = _realm.Intrinsics.Object.Construct(Arguments.Empty);
                var rootName = JsString.Empty;
                root.CreateDataPropertyOrThrow(rootName, unfiltered);
                return InternalizeJSONProperty(root, rootName, (ICallable) reviver);
            }
            else
            {
                return unfiltered;
            }
        }

        private JsValue Stringify(JsValue thisObject, JsValue[] arguments)
        {
            var value = arguments.At(0);
            var replacer = arguments.At(1);
            var space = arguments.At(2);

            if (value.IsUndefined() && replacer.IsUndefined())
            {
                return Undefined;
            }

            var serializer = new JsonSerializer(_engine);
            return serializer.Serialize(value, replacer, space);
        }
    }
}