LibJS: Add Object.{keys,values,entries}()

Libraries/LibJS/Runtime/Object.cpp

@@ -108,6 +108,69 @@ Value Object::get_own_property(const Object& this_object, const FlyString& prope
  return value_here;
 }
 
+Value Object::get_enumerable_own_properties(const Object& this_object, GetOwnPropertyMode kind) const
+{
+ auto* properties_array = Array::create(interpreter().global_object());
+
+ // FIXME: Support generic iterables
+ if (this_object.is_string_object()) {
+ auto str = static_cast<const StringObject&>(this_object).primitive_string().string();
+
+ for (size_t i = 0; i < str.length(); ++i) {
+ if (kind == GetOwnPropertyMode::Key) {
+ properties_array->put_by_index(i, js_string(interpreter(), String::number(i)));
+ } else if (kind == GetOwnPropertyMode::Value) {
+ properties_array->put_by_index(i, js_string(interpreter(), String::format("%c", str[i])));
+ } else {
+ auto* entry_array = Array::create(interpreter().global_object());
+ entry_array->put_by_index(0, js_string(interpreter(), String::number(i)));
+ entry_array->put_by_index(1, js_string(interpreter(), String::format("%c", str[i])));
+ properties_array->put_by_index(i, entry_array);
+ }
+ }
+
+ return properties_array;
+ }
+
+ size_t property_index = 0;
+ for (size_t i = 0; i < m_elements.size(); ++i) {
+ if (m_elements.at(i).is_empty())
+ continue;
+
+ if (kind == GetOwnPropertyMode::Key) {
+ properties_array->put_by_index(property_index, js_string(interpreter(), String::number(i)));
+ } else if (kind == GetOwnPropertyMode::Value) {
+ properties_array->put_by_index(property_index, m_elements.at(i));
+ } else {
+ auto* entry_array = Array::create(interpreter().global_object());
+ entry_array->put_by_index(0, js_string(interpreter(), String::number(i)));
+ entry_array->put_by_index(1, m_elements.at(i));
+ properties_array->put_by_index(property_index, entry_array);
+ }
+
+ ++property_index;
+ }
+
+ for (auto& it : this_object.shape().property_table_ordered()) {
+ if (it.value.attributes & Attribute::Enumerable) {
+ size_t offset = it.value.offset + property_index;
+
+ if (kind == GetOwnPropertyMode::Key) {
+ properties_array->put_by_index(offset, js_string(interpreter(), it.key));
+ } else if (kind == GetOwnPropertyMode::Value) {
+ properties_array->put_by_index(offset, this_object.get(it.key));
+ } else {
+ auto* entry_array = Array::create(interpreter().global_object());
+ entry_array->put_by_index(0, js_string(interpreter(), it.key));
+ entry_array->put_by_index(1, this_object.get(it.key));
+ properties_array->put_by_index(offset, entry_array);
+ }
+ }
+ }
+
+ return properties_array;
+}
+
 void Object::set_shape(Shape& new_shape)
 {
  m_storage.resize(new_shape.property_count());

Libraries/LibJS/Runtime/Object.h

@@ -61,6 +61,13 @@ class Object : public Cell {
 
  Value get_own_property(const Object& this_object, const FlyString& property_name) const;
 
+ enum class GetOwnPropertyMode {
+ Key,
+ Value,
+ KeyAndValue,
+ };
+ Value get_enumerable_own_properties(const Object& this_object, GetOwnPropertyMode) const;
+
  enum class PutOwnPropertyMode {
  Put,
  DefineProperty,

Libraries/LibJS/Runtime/ObjectConstructor.cpp

@@ -47,6 +47,9 @@ ObjectConstructor::ObjectConstructor()
  put_native_function("getOwnPropertyNames", get_own_property_names, 1, attr);
  put_native_function("getPrototypeOf", get_prototype_of, 1, attr);
  put_native_function("setPrototypeOf", set_prototype_of, 2, attr);
+ put_native_function("keys", keys, 1, attr);
+ put_native_function("values", values, 1, attr);
+ put_native_function("entries", entries, 1, attr);
 }
 
 ObjectConstructor::~ObjectConstructor()
@@ -165,4 +168,40 @@ Value ObjectConstructor::is(Interpreter& interpreter)
  return typed_eq(interpreter, value1, value2);
 }
 
+Value ObjectConstructor::keys(Interpreter& interpreter)
+{
+ if (!interpreter.argument_count())
+ return interpreter.throw_exception<TypeError>("Can't convert undefined to object");
+
+ auto* obj_arg = interpreter.argument(0).to_object(interpreter.heap());
+ if (interpreter.exception())
+ return {};
+
+ return obj_arg->get_enumerable_own_properties(*obj_arg, GetOwnPropertyMode::Key);
+}
+
+Value ObjectConstructor::values(Interpreter& interpreter)
+{
+ if (!interpreter.argument_count())
+ return interpreter.throw_exception<TypeError>("Can't convert undefined to object");
+
+ auto* obj_arg = interpreter.argument(0).to_object(interpreter.heap());
+ if (interpreter.exception())
+ return {};
+
+ return obj_arg->get_enumerable_own_properties(*obj_arg, GetOwnPropertyMode::Value);
+}
+
+Value ObjectConstructor::entries(Interpreter& interpreter)
+{
+ if (!interpreter.argument_count())
+ return interpreter.throw_exception<TypeError>("Can't convert undefined to object");
+
+ auto* obj_arg = interpreter.argument(0).to_object(interpreter.heap());
+ if (interpreter.exception())
+ return {};
+
+ return obj_arg->get_enumerable_own_properties(*obj_arg, GetOwnPropertyMode::KeyAndValue);
+}
+
 }

Libraries/LibJS/Runtime/ObjectConstructor.h

@@ -48,6 +48,9 @@ class ObjectConstructor final : public NativeFunction {
  static Value get_own_property_names(Interpreter&);
  static Value get_prototype_of(Interpreter&);
  static Value set_prototype_of(Interpreter&);
+ static Value keys(Interpreter&);
+ static Value values(Interpreter&);
+ static Value entries(Interpreter&);
 };
 
 }

Libraries/LibJS/Tests/Object.entries.js

@@ -0,0 +1,54 @@
+load("test-common.js");
+
+try {
+ assert(Object.entries.length === 1);
+ assert(Object.entries(true).length === 0);
+ assert(Object.entries(45).length === 0);
+ assert(Object.entries(-998).length === 0);
+ assert(Object.entries("abcd").length === 4);
+ assert(Object.entries([1, 2, 3]).length === 3);
+ assert(Object.entries({ a: 1, b: 2, c: 3 }).length === 3);
+
+ assertThrowsError(() => {
+ Object.entries(null);
+ }, {
+ error: TypeError,
+ message: "ToObject on null or undefined.",
+ });
+
+ assertThrowsError(() => {
+ Object.entries(undefined);
+ }, {
+ error: TypeError,
+ message: "ToObject on null or undefined.",
+ });
+
+ let entries = Object.entries({ foo: 1, bar: 2, baz: 3 });
+ assert(
+ entries.length === 3 && entries[0].length === 2 && 
+ entries[1].length === 2 && entries[2].length === 2 &&
+ entries[0][0] === "foo" && entries[0][1] === 1 &&
+ entries[1][0] === "bar" && entries[1][1] === 2 &&
+ entries[2][0] === "baz" && entries[2][1] === 3
+ );
+
+ entries = Object.entries(["a", "b", "c"]);
+ assert(
+ entries.length === 3 && entries[0].length === 2 && 
+ entries[1].length === 2 && entries[2].length === 2 &&
+ entries[0][0] === "0" && entries[0][1] === "a" &&
+ entries[1][0] === "1" && entries[1][1] === "b" &&
+ entries[2][0] === "2" && entries[2][1] === "c"
+ );
+
+ let obj = { foo: 1 };
+ Object.defineProperty(obj, "getFoo", {
+ value: function() { return this.foo; },
+ });
+ let entries = Object.entries(obj);
+ assert(entries.length === 1 && entries[0][0] === "foo" && entries[0][1] === 1);
+
+ console.log("PASS");
+} catch (e) {
+ console.log("FAIL: " + e);
+} 

Libraries/LibJS/Tests/Object.keys.js

@@ -0,0 +1,42 @@
+load("test-common.js");
+
+try {
+ assert(Object.keys.length === 1);
+ assert(Object.keys(true).length === 0);
+ assert(Object.keys(45).length === 0);
+ assert(Object.keys(-998).length === 0);
+ assert(Object.keys("abcd").length === 4);
+ assert(Object.keys([1, 2, 3]).length === 3);
+ assert(Object.keys({ a: 1, b: 2, c: 3 }).length === 3);
+
+ assertThrowsError(() => {
+ Object.keys(null);
+ }, {
+ error: TypeError,
+ message: "ToObject on null or undefined.",
+ });
+
+ assertThrowsError(() => {
+ Object.keys(undefined);
+ }, {
+ error: TypeError,
+ message: "ToObject on null or undefined.",
+ });
+
+ let keys = Object.keys({ foo: 1, bar: 2, baz: 3 });
+ assert(keys[0] === "foo" && keys[1] === "bar" && keys[2] === "baz");
+
+ keys = Object.keys(["a", "b", "c"]);
+ assert(keys[0] === "0" && keys[1] === "1" && keys[2] === "2");
+
+ let obj = { foo: 1 };
+ Object.defineProperty(obj, 'getFoo', {
+ value: function() { return this.foo; },
+ });
+ keys = Object.keys(obj);
+ assert(keys.length === 1 && keys[0] === 'foo');
+
+ console.log("PASS");
+} catch (e) {
+ console.log("FAIL: " + e);
+} 

Libraries/LibJS/Tests/Object.values.js

@@ -0,0 +1,42 @@
+load("test-common.js");
+
+try {
+ assert(Object.values.length === 1);
+ assert(Object.values(true).length === 0);
+ assert(Object.values(45).length === 0);
+ assert(Object.values(-998).length === 0);
+ assert(Object.values("abcd").length === 4);
+ assert(Object.values([1, 2, 3]).length === 3);
+ assert(Object.values({ a: 1, b: 2, c: 3 }).length === 3);
+
+ assertThrowsError(() => {
+ Object.values(null);
+ }, {
+ error: TypeError,
+ message: "ToObject on null or undefined.",
+ });
+
+ assertThrowsError(() => {
+ Object.values(undefined);
+ }, {
+ error: TypeError,
+ message: "ToObject on null or undefined.",
+ });
+
+ let values = Object.values({ foo: 1, bar: 2, baz: 3 });
+ assert(values[0] === 1 && values[1] === 2 && values[2] === 3);
+
+ values = Object.values(["a", "b", "c"]);
+ assert(values[0] === "a" && values[1] === "b" && values[2] === "c");
+
+ let obj = { foo: 1 };
+ Object.defineProperty(obj, 'getFoo', {
+ value: function() { return this.foo; },
+ });
+ let values = Object.values(obj);
+ assert(values.length === 1 && values[0] === 1);
+
+ console.log("PASS");
+} catch (e) {
+ console.log("FAIL: " + e);
+}