From 8ee816b6d8bb0ff20af925e4c8e4e0f33aa32255 Mon Sep 17 00:00:00 2001 From: Rudy Ges Date: Sun, 15 Oct 2023 10:11:00 +0200 Subject: [PATCH] [js] Update js.lib.Object and js.lib.Symbol From their implementation in js-object haxelib --- std/js/Object.hx | 2 +- std/js/lib/Object.hx | 239 ++++++++++++++++++++++++++++-------------- std/js/lib/Proxy.hx | 4 +- std/js/lib/Reflect.hx | 10 +- std/js/lib/Symbol.hx | 81 ++++++++++++-- 5 files changed, 239 insertions(+), 97 deletions(-) diff --git a/std/js/Object.hx b/std/js/Object.hx index 7da188a7248..6b2ecfa3e42 100644 --- a/std/js/Object.hx +++ b/std/js/Object.hx @@ -24,4 +24,4 @@ package js; @:deprecated typedef Object = js.lib.Object; @:deprecated typedef ObjectPrototype = js.lib.Object.ObjectPrototype; -@:deprecated typedef ObjectPropertyDescriptor = js.lib.Object.ObjectPropertyDescriptor; +@:deprecated typedef ObjectPropertyDescriptor = js.lib.Object.ObjectPropertyDescriptor; diff --git a/std/js/lib/Object.hx b/std/js/lib/Object.hx index 55358b7d382..248c6bc2929 100644 --- a/std/js/lib/Object.hx +++ b/std/js/lib/Object.hx @@ -22,8 +22,8 @@ package js.lib; -import haxe.extern.Rest; import haxe.DynamicAccess; +import haxe.extern.Rest; /** The `js.lib.Object` constructor creates an object wrapper. @@ -32,126 +32,209 @@ import haxe.DynamicAccess; **/ @:native("Object") extern class Object { - /** - Copies the values of all enumerable own properties from one or more - source objects to a target object. - **/ - static function assign(target:T, sources:Rest<{}>):T; + static var prototype(default,never):ObjectPrototype; /** - Creates a new object with the specified prototype object and properties. + The Object constructor creates an object wrapper. **/ - @:pure static function create(proto:{}, ?propertiesObject:DynamicAccess):T; + @:pure function new(?value:Any); /** - Adds the named properties described by the given descriptors to an object. + The Object.assign() method is used to copy the values of all enumerable + own properties from one or more source objects to a target object. It + will return the target object. + + Note: this is an ES2015 feature + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign **/ - static function defineProperties(obj:T, props:DynamicAccess):T; + @:pure static function assign(target:TSource, sources:Rest<{}>):TDest; /** - Adds the named property described by a given descriptor to an object. + The Object.create() method create a new object, using an existing object + to provide the newly created object's __proto__ . (see browser console + for visual evidence.) + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create **/ - @:overload(function(obj:T, prop:Symbol, descriptor:ObjectPropertyDescriptor):T {}) - static function defineProperty(obj:T, prop:String, descriptor:ObjectPropertyDescriptor):T; + @:pure static function create(proto:Null<{}>, ?propertiesObject:DynamicAccess>):TObj; /** - Returns an array containing all of the [key, value] pairs of a given - object's own enumerable string properties. + The static method Object.defineProperty() defines a new property directly + on an object, or modifies an existing property on an object, and returns + the object. + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty **/ - @:pure static function entries(obj:{}):Array; + @:overload(function(obj:TObj, prop:Symbol, descriptor:ObjectPropertyDescriptor):TObj {}) + static function defineProperty(obj:TObj, prop:String, descriptor:ObjectPropertyDescriptor):TObj; /** - Freezes an object: other code can't delete or change any properties. + The Object.defineProperties() method defines new or modifies existing + properties directly on an object, returning the object. + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties **/ - static function freeze(obj:T):T; + static function defineProperties(obj:TObj, props:DynamicAccess>):TObj; /** - Returns a new object from an iterable of key-value pairs - (reverses Object.entries). + The Object.entries() method returns an array of a given object's own + enumerable property [key, value] pairs, in the same order as that + provided by a for...in loop (the difference being that a for-in loop + enumerates properties in the prototype chain as well). + + Note: this is an ES2017 feature + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries **/ - @:pure static function fromEntries(iterable:Any):T; + @:pure static function entries(obj:TObj):Array; /** - Returns a property descriptor for a named property on an object. + The Object.freeze() method freezes an object: that is, prevents new + properties from being added to it; prevents existing properties from + being removed; and prevents existing properties, or their enumerability, + configurability, or writability, from being changed, it also prevents the + prototype from being changed. + The method returns the passed object. + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze **/ - @:overload(function(target:Array, propertyKey:Int):Null {}) - @:overload(function(obj:{}, prop:Symbol):Null {}) - @:pure static function getOwnPropertyDescriptor(obj:{}, prop:String):Null; + static function freeze(obj:TObj):TObj; /** - Returns an array containing the names of all of the given object's own - enumerable and non-enumerable properties. + The Object.getOwnPropertyDescriptor() method returns a property + descriptor for an own property (that is, one directly present on an + object and not in the object's prototype chain) of a given object. + + In ES5, if the first argument to this method is not an object (a + primitive), then it will cause a TypeError. In ES2015, a non-object + first argument will be coerced to an object at first. + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor **/ - @:pure static function getOwnPropertyNames(obj:{}):Array; + @:overload(function(obj:String, prop:Symbol):Null> {}) + @:overload(function(obj:String, prop:String):Null> {}) + @:overload(function(target:Array, propertyKey:Int):Null> {}) + @:overload(function(obj:TObj, prop:Symbol):Null> {}) + @:pure static function getOwnPropertyDescriptor(obj:TObj, prop:String):Null>; /** - Returns an array of all symbol properties found directly upon a given object. + The Object.getOwnPropertyDescriptors() method returns all own property + descriptors of a given object. + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptors **/ - @:pure static function getOwnPropertySymbols(obj:{}):Array; + @:overload(function(target:String):DynamicAccess> {}) + @:overload(function(target:Array):DynamicAccess> {}) + @:pure static function getOwnPropertyDescriptors(obj:TObj):DynamicAccess>; /** - Returns the prototype of the specified object. + The Object.getOwnPropertyNames() method returns an array of all + properties (including non-enumerable properties except for those which + use Symbol) found directly upon a given object. + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames **/ - @:pure static function getPrototypeOf(obj:{}):Null; + @:pure static function getOwnPropertyNames(obj:TObj):Array; /** - Compares if two values are the same value. Equates all NaN values - (which differs from both Abstract Equality Comparison and - Strict Equality Comparison). + The Object.getOwnPropertySymbols() method returns an array of all symbol + properties found directly upon a given object. + + Note: this is an ES2015 feature + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertySymbols **/ - @:pure static function is(value1:T, value2:T):Bool; + @:pure static function getOwnPropertySymbols(obj:TObj):Array; /** - Determines if extending of an object is allowed. + The Object.getPrototypeOf() method returns the prototype (i.e. the value + of the internal [[Prototype]] property) of the specified object. + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf **/ - @:pure static function isExtensible(obj:{}):Bool; + @:pure static function getPrototypeOf(obj:TObj):TProto; /** - Determines if an object was frozen. + The Object.is() method determines whether two values are the same value. + + Note: this is an ES2015 feature + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is **/ - @:pure static function isFrozen(obj:{}):Bool; + @:pure static function is(obj1:TObj, obj2:TObj):Bool; /** - Determines if an object is sealed. + The Object.isExtensible() method determines if an object is extensible + (whether it can have new properties added to it). + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isExtensible **/ - @:pure static function isSealed(obj:{}):Bool; + @:pure static function isExtensible(obj:TObj):Bool; /** - Returns an array containing the names of all of the given object's own - enumerable string properties. + The Object.isFrozen() determines if an object is frozen. + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isFrozen **/ - @:pure static function keys(obj:{}):Array; + @:pure static function isFrozen(obj:TObj):Bool; /** - Prevents any extensions of an object. + The Object.isSealed() method determines if an object is sealed. + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isSealed **/ - static function preventExtensions(obj:T):T; + @:pure static function isSealed(obj:TObj):Bool; /** - Prevents other code from deleting properties of an object. + The Object.keys() method returns an array of a given object's own + enumerable properties, in the same order as that provided by a for...in + loop (the difference being that a for-in loop enumerates properties in + the prototype chain as well). + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys **/ - static function seal(obj:T):T; + @:pure static function keys(obj:TObj):Array; /** - Sets the prototype (i.e., the internal Prototype property). + The Object.preventExtensions() method prevents new properties from ever + being added to an object (i.e. prevents future extensions to the object). + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/preventExtensions **/ - static function setPrototypeOf(obj:T, prototype:Null<{}>):T; + static function preventExtensions(obj:TObj):TObj; /** - Returns an array containing the values that correspond to all of - a given object's own enumerable string properties. + The Object.seal() method seals an object, preventing new properties from + being added to it and marking all existing properties as + non-configurable. Values of present properties can still be changed as + long as they are writable. + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/seal **/ - @:pure static function values(obj:{}):Array; + static function seal(obj:TObj):TObj; /** - Allows the addition of properties to all objects of type Object. + The Object.setPrototypeOf() method sets the prototype (i.e., the internal + [[Prototype]] property) of a specified object to another object or null. + + Note: this is an ES2015 feature + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf **/ - static var prototype(default, never):ObjectPrototype; + static function setPrototypeOf(obj:TObj, proto:Null):TObj; /** - The Object constructor creates an object wrapper. + The Object.values() method returns an array of a given object's own + enumerable property values, in the same order as that provided by a + for...in loop (the difference being that a for-in loop enumerates + properties in the prototype chain as well). + + Note: this is an ES2017 feature + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/values **/ - @:pure function new(?value:Any); + @:pure static function values(obj:TObj):Array; } /** @@ -164,68 +247,65 @@ typedef ObjectPrototype = { property as a direct property of that object and not inherited through the prototype chain. **/ - var hasOwnProperty(default, never):Function; + var hasOwnProperty(default,never):Function; /** Returns a boolean indicating whether the object this method is called upon is in the prototype chain of the specified object. **/ - var isPrototypeOf(default, never):Function; + var isPrototypeOf(default,never):Function; /** Returns a boolean indicating if the internal enumerable attribute is set. **/ - var propertyIsEnumerable(default, never):Function; + var propertyIsEnumerable(default,never):Function; /** Calls `toString()`. **/ - var toLocaleString(default, never):Function; + var toLocaleString(default,never):Function; /** Returns a string representation of the object. **/ - var toString(default, never):Function; + var toString(default,never):Function; /** Returns the primitive value of the specified object. **/ - var valueOf(default, never):Function; + var valueOf(default,never):Function; } /** @see **/ -typedef ObjectPropertyDescriptor = { +typedef ObjectPropertyDescriptor = { + /** + The value associated with the property. + Can be any valid JavaScript value (number, object, function, etc). + **/ + @:optional var value:TProp; + /** `true` if and only if the type of this property descriptor may be changed and if the property may be deleted from the corresponding object. - Defaults to `false`. **/ - var ?configurable:Bool; + @:optional var configurable:Bool; /** `true` if and only if this property shows up during enumeration of the properties on the corresponding object. - Defaults to `false`. **/ - var ?enumerable:Bool; - - /** - The value associated with the property. - Can be any valid JavaScript value (number, object, function, etc). - **/ - var ?value:Any; + @:optional var enumerable:Bool; /** `true` if and only if the value associated with the property may be changed with an assignment operator. - Defaults to `false`. **/ - var ?writable:Bool; + @:optional var writable:Bool; /** A function which serves as a getter for the property, or `undefined` if @@ -235,7 +315,7 @@ typedef ObjectPropertyDescriptor = { property is defined due to inheritance). The return value will be used as the value of the property. **/ - var ?get:Void->Any; + @:optional var get:Void->TProp; /** A function which serves as a setter for the property, or undefined if @@ -243,7 +323,7 @@ typedef ObjectPropertyDescriptor = { is called with one argument (the value being assigned to the property) and with `this` set to the object through which the property is assigned. **/ - var ?set:Any->Void; + @:optional var set:TProp->Void; } /** @@ -252,7 +332,6 @@ typedef ObjectPropertyDescriptor = { abstract ObjectEntry(Array) { public var key(get, never):String; public var value(get, never):Any; - inline function get_key():String return this[0]; diff --git a/std/js/lib/Proxy.hx b/std/js/lib/Proxy.hx index 24c7668f5c1..e3848e9b479 100644 --- a/std/js/lib/Proxy.hx +++ b/std/js/lib/Proxy.hx @@ -65,12 +65,12 @@ typedef ProxyHandler = { /** A trap for `Object.getOwnPropertyDescriptor`. **/ - var ?getOwnPropertyDescriptor:(target:T, prop:EitherType) -> Null; + var ?getOwnPropertyDescriptor:(target:T, prop:EitherType) -> Null>; /** A trap for `Object.defineProperty`. **/ - var ?defineProperty:(target:T, property:EitherType, descriptor:ObjectPropertyDescriptor) -> Bool; + var ?defineProperty:(target:T, property:EitherType, descriptor:ObjectPropertyDescriptor) -> Bool; /** A trap for the `in` operator. diff --git a/std/js/lib/Reflect.hx b/std/js/lib/Reflect.hx index cce68769ef7..eca2fbf5703 100644 --- a/std/js/lib/Reflect.hx +++ b/std/js/lib/Reflect.hx @@ -49,8 +49,8 @@ extern class Reflect { /** Similar to `Object.defineProperty()`. Returns a Bool. */ - @:overload(function(target:{}, propertyKey:Symbol, attributes:ObjectPropertyDescriptor):Bool {}) - static function defineProperty(target:{}, propertyKey:String, attributes:ObjectPropertyDescriptor):Bool; + @:overload(function(target:{}, propertyKey:Symbol, attributes:ObjectPropertyDescriptor):Bool {}) + static function defineProperty(target:{}, propertyKey:String, attributes:ObjectPropertyDescriptor):Bool; /** The `delete` operator as a function. Equivalent to calling `delete target[name]`. @@ -71,9 +71,9 @@ extern class Reflect { Returns a property descriptor of the given property if it exists on the object, `undefined` otherwise. */ - @:overload(function(target:Array, propertyKey:Int):Null {}) - @:overload(function(target:{}, propertyKey:Symbol):Null {}) - @:pure static function getOwnPropertyDescriptor(target:{}, propertyKey:String):Null; + @:overload(function(target:Array, propertyKey:Int):Null> {}) + @:overload(function(target:{}, propertyKey:Symbol):Null> {}) + @:pure static function getOwnPropertyDescriptor(target:{}, propertyKey:String):Null>; /** Same as `Object.getPrototypeOf()`. diff --git a/std/js/lib/Symbol.hx b/std/js/lib/Symbol.hx index 61960149ce1..18cde8d8856 100644 --- a/std/js/lib/Symbol.hx +++ b/std/js/lib/Symbol.hx @@ -26,22 +26,30 @@ package js.lib; extern class Symbol { /** To create a new primitive symbol, use `new Symbol()` with an optional string as its `description`. - NOTE: Unlike in plain JavaScript, `new Symbol()` syntax is used in Haxe. This generates a `Symbol(...)` expression as required by the JavaScript specification. + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol **/ @:pure @:selfCall function new(?description:String); /** - Searches for existing symbols with the given key and returns it if found. - Otherwise a new symbol gets created in the global symbol registry with this key. + The Symbol.for(key) method searches for existing symbols in a + runtime-wide symbol registry with the given key and returns it if found. + Otherwise a new symbol gets created in the global symbol registry with + this key. + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/for **/ - @:native("for") static function for_(key:String):Symbol; + @:native('for') static function for_(key:String):Symbol; /** - Retrieves a shared symbol key from the global symbol registry for the given symbol. + The Symbol.keyFor(sym) method retrieves a shared symbol key from the + global symbol registry for the given symbol. + + See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/keyFor **/ - @:pure static function keyFor(sym:Symbol):Null; + @:pure static function keyFor(symbol:Symbol):Null; /** Returns a string containing the description of the Symbol. @@ -49,14 +57,68 @@ extern class Symbol { @:pure function toString():String; /** - A method returning the default iterator for an object. + A method returning the default iterator for an object. Used by for...of. **/ static var iterator(default, null):Symbol; /** - A method that returns the default AsyncIterator for an object. + A method that matches against a string, also used to determine if an + object may be used as a regular expression. Used by + String.prototype.match(). + **/ + static var match(default, null):Symbol; + + /** + A method that replaces matched substrings of a string. Used by + String.prototype.replace(). + **/ + static var replace(default, null):Symbol; + + /** + A method that returns the index within a string that matches the regular + expression. Used by String.prototype.search(). + **/ + static var search(default, null):Symbol; + + /** + A method that splits a string at the indices that match a regular + expression. Used by String.prototype.split(). + **/ + static var split(default, null):Symbol; + + /** + A method determining if a constructor object recognizes an object as its + instance. Used by instanceof. **/ - static var asyncIterator(default, null):Symbol; + static var hasInstance(default, null):Symbol; + + /** + A Boolean value indicating if an object should be flattened to its array + elements. Used by Array.prototype.concat(). + **/ + static var isConcatSpreadable(default, null):Symbol; + + /** + An object value of whose own and inherited property names are excluded + from the with environment bindings of the associated object. + **/ + static var unscopables(default, null):Symbol; + + /** + A constructor function that is used to create derived objects. + **/ + static var species(default, null):Symbol; + + /** + A method converting an object to a primitive value. + **/ + static var toPrimitive(default, null):Symbol; + + /** + A string value used for the default description of an object. Used by + Object.prototype.toString(). + **/ + static var toStringTag(default, null):Symbol; /** Retrieve symbol from a given `object`. @@ -66,3 +128,4 @@ extern class Symbol { inline function ofObject(object:{}):Null return (cast object)[cast this]; } +