comt: comparison src/cm/media/js/lib/yui/yui_3.10.3/releasenotes/HISTORY.event-custom.md

equal deleted inserted replaced

-:322d0feea350
+:89ef5ed3c48b
+Custom Event Infrastructure Change History
+==========================================
+3.10.3
+------
+* No changes.
+3.10.2
+------
+* Fixed issue with facade carrying stale data for the "no subscriber" case.
+* Fixed regression where `once()` and `onceAfter()` subscriptions using the
+`*` prefix threw a TypeError [#676]. `target.once('*:fooChange', callback)`
+* Fixed exception with fire(type, null) with emitFacade:true.
+3.10.1
+------
+* No changes.
+3.10.0
+------
+* Significant performance improvements in common CustomEvent operations.
+There are improvements across the board, but the work was largely aimed at events
+with no listeners (to facilate speeding up `new Base()` which publishes/fires 2
+events [init, initializedChange], which usually don't have listeners).
+For example, on Chrome:
+`fire() with 0 listeners` is 6 times faster
+`fire() with 2 listeners` is 2-3 times faster (w, w/o payload)
+`publish()` is 2 times faster
+`publish() compared to _publish()` is 5 times faster (see below)
+`EventTarget construction + publish + fire with 0 listeners` is 3 times faster
+Major performance related changes are listed below.
+Commit messages have detailed descriptions of incremental changes, and the
+benefits introduced.
+* Moved more properties to the `CustomEvent` prototype, to improve publish costs
+* Instantiate `_subscribers`, `_afters` arrays lazily to reduce publish costs for the
+no listener case. Same thing was also done for less commonly used features, like the
+`targets` map.
+* Reduce `new EventTarget` costs, by removing default properties which just match the
+`CustomEvent` defaults. It reduces the number of properties we need to iterate each time
+we mix values while publishing.
+* Removed unrequired `Y.stamp` on _yuievt. It wasn't being used in the library code base
+* Changed `Y.stamp` calls to `Y.guid` where it was being used to set up `id` properties.
+There didn't seem to be a need to add the `_yuid` property and it added overhead.
+* Provide a fast-track for `fire` with no potential subscribers (no local subscribers, no
+bubble targets, and no broadcast), by jumping to the default function directly (if
+configured) or just doing nothing, if no default function.
+* Made `*` support close to zero cost for folks who aren't using it, by only trying to look
+for siblings if someone had subscribed using `*`.
+* Reduced `isObject` checks, by combining facade creation and argument manipulation
+into `_getFacade()`.
+* Improved `fireComplex` times, by creating lesser used queues lazily (`es.queue`, `es.afterQueue`).
+* Avoid `slice` and related arguments iteration costs for common `fire` signatures,
+(`fire("foo")`, `fire("foo", {})`) by working with arguments directly for these cases.
+Since `fire` is open-ended in terms of it's number of args, anything besides the above
+signatures still use `slice`.
+* `fire(...)` now delegates to `_fire(array)` to avoid repeated conversion of `arguments` to
+arrays, across the calling stack from `eventTarget.fire()` to `customEvent.fire()`.
+* Avoid `_monitor()` hops, but checking for whether or not monitoring is enabled outside
+of the function.
+* Removed `Y.cached` wrapper around `_getType()`. This was an interesting one. The work
+we do to generate the key for the cache, turned out to be more than what `_getType()` costs
+if we just re-run it.
+* Added a fast-path *currently private* `_publish()` for low-level, critical path
+implementations, such as Attribute and Base.
+`_publish()` doesn't provide any API sugar (e.g. type to fulltype conversation), and
+leaves the `CustomEvent` configuration to the caller to avoid iteration and mixing costs.
+The assumption is that low-level callers know about the event system architecture, and
+know what they're doing. That's why its private for now, but its 5x faster than `publish()`
+for a comparable event configuration. `publish()` leverages `_publish()`, also ends up being
+faster after this change, but not by such a big factor.
+* Revert EventTarget back to lazily creating `targets`.
+3.9.1
+-----
+* No changes.
+3.9.0
+-----
+* No changes.
+3.8.1
+-----
+* No changes.
+3.8.0
+-----
+* No changes.
+3.7.3
+-----
+* No changes.
+3.7.2
+-----
+* No changes.
+3.7.1
+-----
+* No changes.
+3.7.0
+-----
+* CustomEvent run-time performance optimizations.
+a. [!] The `subscribers` and `afters` CustomEvent instance properties have
+been deprecated, and replaced with private arrays (instead of hashes).
+If you're referring to the `subscribers` or `afters` properties directly,
+you can set the `Y.CustomEvent.keepDeprecatedSubs` to true, to restore
+them, but you will incur a performance hit in doing so.
+The rest of the CustomEvent API is driven by the new private arrays, and
+does not require the `subscribers` and `afters` properties, so you should
+only enable `keepDeprecatedSubs` if your code is referring to the properties
+directly.
+If you are using the above properties directly, please file an enhancement
+request and we'll provide a public way to achieve the same results, without
+the performance hit before we remove the properties permanently.
+b. Avoid new EventTarget when stoppedFn is not used.
+c. Optimized mixing during the creation of a custom event object.
+d. Optimized mixing done on the facade, during a fire with payload.
+Performance results on Chrome 19/MacOS below, for the use case where we're
+iring with a payload:
+## Custom Event Lifecycle Numbers (Fix a, b, c)
+BEFORE (3.6.0):
+EventTarget with attribute style publish, fire, with on/after listeners x 7,623 ops/sec
+CURRENT (With fixes a, b, c):
+EventTarget with attribute style publish, fire, with on/after listeners x 23,642 ops/sec
+## Payload Numbers (Fix d)
+BEFORE (3.6.0):
+Fire With Payload - 10 listeners x 27,918 ops/sec ±1.32% (54 runs sampled)
+CURRENT (With fix d):
+Fire With Payload - 10 listeners x 63,362 ops/sec ±0.37% (58 runs sampled)
+The benchmark tests can be found in src/event-custom/tests/benchmark
+Log messages for the follow commits have more details:
+e7415e71decf3d921161e8883270e16b433aa150 - subscribers/afters fix.
+29f63996f8b69a7bb6d2e27f4d350c320998c0b2 - optimized payload mix fix.
+* CustomEvent memory optimizations.
+* Fixed `_facade` and `firedWith` which were holding onto a reference
+to the last fired event facade. Now `_facade` is reset to null after
+the fire sequence, and `firedWith` is only maintained for `fireOnce`
+CustomEvents. i
+This allows the facade from the last fired event to be GC'd whereas
+prior to this change it wasn't.
+3.6.0
+-----
+* Fixed memory consumption issue where Y.Do's internal touched object cache,
+Y.Do.objs, would never release object references.
+The Y.Do.objs property has been deprecated as of 3.6.0, and will be null.
+The cached state previously stored in Y.Do.objs has been moved onto the
+AOP'd object itself, in the *private* `_yuiaop` property.
+The only reason `_yuiaop` is mentioned here, is to provide a temporary
+migration path for users who may have been using Y.Do.objs. If you are using
+this property, please file a ticket with the use case, and we'll look at
+addressing the use case formally, while not impacting GC.
+3.5.1
+-----
+* No changes.
+3.5.0
+-----
+* Multiple calls to target.publish({ ... }) now work [Ticket #2531671]
+3.4.1
+-----
+* onceAfter (added in 3.4.0) now works for array and object signatures.
+[Ticket #2531121]
+3.4.0
+-----
+* Custom events published from `Y` no longer bubble by default.
+3.3.0
+-----
+* Undocumented and poorly named `each()` method on EventHandle changed to
+`batch()`.
+* After listeners for events fired in a `defaultFn` or listener are queued in
+the correct order.
+* Added `Y.Do.originalRetVal` and `Y.Do.currentRetVal` statics accessible by
+`Y.Do.after()` subscribers.
+* Exposed the previously private `EventTarget.parseType`.
+3.2.0
+-----
+* Fixed `defaultTargetOnly` publish configuration.
+* `detach()` now decrements `subCount`/`afterCount`.
+* Detaching via category no longer affects subscriptions on other objects.
+3.1.1
+-----
+* No changes.
+3.1.0
+-----
+* Wildcard prefix subscriptions supported: `target.on('*:click', …)` will be
+notified when `tree:click`, `tab:click`, etc are fired.
+* Added `EventTarget::once`, which is equivalent to `on()`, except the
+listener automatically detaches itself once executed.
+* Added event monitoring. When configured, an `EventTarget` will emit events
+for `publish()`, `attach()`, `fire()`, and `detach()` operations on the
+hosted events.
+* `EventTarget::on`'s `type` parameter is overloaded to accept arrays and
+objects for attaching multiple types at once.
+* `EventTarget::detach` returns the event target like the API docs already
+stated.
+* Events can now be configured to execute the `defaultFn` only on the targeted
+object, not on the bubble targets.
+* The event order has been reworked so that the after listeners for the entire
+event stack execute after all `defaultFn` across the entire bubble stack.
+3.0.0
+-----
+* Broken into core base and complex modules.
+* `broadcast` works for simple events.
+* If configured to return an `EventHandle`, the return value will always be a
+single object, regardless of how many listeners were attached. Previously,
+multiple listeners provided an array of detach handles.
+3.0.0beta1
+----------
+* [!] Exposed methods are `on()` for the before moment, `after()` for the
+after moment, and `detach()` for unsubscribe. `subscribe()`, `before()`,
+`unsubscribe()`, and corresponding methods are deprecated.
+* Implemented the `broadcast` flag:
+* `broadcast = 1`: local, accessible via `Y.on('prefix:event')`.
+* `broadcast = 2`: global, accessible via `Y.on()` or globally via
+`Y.Global.on('prefix:event')`.
+Broadcast listeners cannot effect the `defaultFn` or host subscribers (so
+are in effect, after listeners), although this is still possible by added
+either `Y` or `Y.Global` as `EventTarget`s.
+* Moved `event-custom` out of `event` package.
+* `EventTarget` accepts a `prefix` configuration. This is used in all exposed
+methods to handle shortcuts to event names, e.g., `'click'` and
+`'menu:click'` are the same if the prefix is `'menu'`.
+* Event type accepts a event category which can be used to detach events:
+Y.on('category|prefix:event', fn);
+Y.detach('category|prefix:event');
+Y.detach('category|*');
+* Added `chain` config to events that makes the return value the event target
+rather than a detach handle. Use with the detach category prefix.
+* The `type` parameter can be an object containing multiple events to attach:
+Y.on({ 'event1': fn1, 'event2': fn2 });
+* `Y.fire` payload for event facades can be another facade or a custom event.