--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cm/media/js/lib/yui/yui_3.10.3/releasenotes/HISTORY.event-custom.md Tue Jul 16 14:29:46 2013 +0200
@@ -0,0 +1,337 @@
+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.