--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cm/media/js/lib/yui/yui_3.10.3/releasenotes/HISTORY.base.md Tue Jul 16 14:29:46 2013 +0200
@@ -0,0 +1,372 @@
+Base Change History
+===================
+
+3.10.3
+------
+
+* No changes.
+
+3.10.2
+------
+
+* No changes.
+
+3.10.1
+------
+
+* No changes.
+
+3.10.0
+------
+
+* Significant performance improvements in common Base/BaseCore operations.
+
+ For example, on Chrome:
+
+ `new BaseCore()` is 3 times faster
+ `BaseCore set()` is 3 times faster
+ `BaseCore get()` is 5 times faster
+
+ In addition to the above basic `BaseCore` numbers, improvements in CustomEvent
+ performance, result in the following improvements for `Base`
+
+ `new Base()` is 4 times faster
+ `Base set()` is 4 times faster
+ `Base get()` is 5 times faster
+
+ Major performance related changes are listed in the list of updates below.
+
+ Commit messages have detailed descriptions of incremental changes, and the
+ benefits introduced.
+
+* [!] The result of static `ATTRS` aggregation is now cached during the creation of
+ the first instance of a given "class", and the cached results are reused for
+ subsequent instances.
+
+ This provides significant performance benefits, but has the potential to introduce
+ a backwards compatibility issue in the hopefully rare circumstance that you're
+ modifying the static ATTRS collection directly, after the first instance is created.
+
+ [!] If you are modifying static `ATTRS` collection directly after an instance is
+ created (e.g. if an optional module comes in and updates the collection dynamically),
+ you will need to change the implementation to use the static `Y.Base.modifyAttrs()`
+ or `Y.BaseCore.modifyAttrs()` method, so we can mark the cached aggregation
+ dirty, and recompute it.
+
+ `Y.Base.modifyAttrs(MyClass, {..changes to merge..})`
+
+ `Base.create` and `Base.mix` will take care of this internally, so you only need
+ to use the above methods if your own code is touching the ATTRS object on a class.
+ Additionaly, `Base.create` and `Base.mix` will add the `modifyAttrs` to your created
+ class, so you can also call it directly on the class. e.g.
+
+ `MyCreatedClass.modifyAttrs({..changes to merge..})`
+
+3.9.1
+-----
+
+* No changes.
+
+3.9.0
+-----
+
+* No changes.
+
+3.8.1
+-----
+
+* No changes.
+
+3.8.0
+-----
+
+* `Y.Base.create()` can now be used with `Y.BaseCore`, in addition to its
+ existing usage with `Y.Base`. This allows non-observable, BaseCore hierarchies
+ to use class extensions.
+
+* Extracted the `Y.BaseObservable` class extension from `Y.Base`. This is a new
+ class extension for `Y.BaseCore` which adds support for observability. This
+ allows BaseCore subclasses to mix-in BaseObservable at runtime, bringing their
+ functionality up to that of `Y.Base`.
+
+3.7.3
+-----
+
+* No changes.
+
+3.7.2
+-----
+
+* No changes.
+
+3.7.1
+-----
+
+* No changes.
+
+3.7.0
+-----
+
+* No changes.
+
+3.6.0
+-----
+
+ * "value" defined in a subclass ATTRS definition, will now override
+ "valueFn" for the same attribute from the superclass chain.
+
+ Previously, "value" would only override "value" and "valueFn"
+ would only overide "valueFn", and in the aggregated set of
+ attributes, "valueFn" would take precedence over "value".
+
+ This meant that subclasses had to define a "valueFn" to overide
+ superclasses, if the superclass used "valueFn".
+
+3.5.1
+-----
+
+ * No changes.
+
+3.5.0
+-----
+
+ * Only invoke Base constructor logic once to
+ support multi-inheritance scenario in which
+ an extension passed to Base.create inherits from Base
+ itself.
+
+ NOTE: To support multiple inhertiance more deeply, we'd
+ need to remove the hasOwnProperty restriction around object
+ key iteration.
+
+ * Added Y.BaseCore which is core Base functionality without
+ Custom Events (it uses Y.AttributeCore instead of Y.Attribute).
+
+ Y.BaseCore still maintains the ATTRS handling, init/destroy
+ lifecycle and plugin support, but doesn't fire any custom evnets
+ of it's own (the idea is that it will the base for Node-Plugin
+ type components, built off of a WidgetCore)
+
+ Y.Base is now Y.BaseCore + Y.Attribute, and is 100% backwards
+ compatible.
+
+ Summary:
+
+ Y.Attribute - Common Attribute Functionality (100% backwards compat)
+ Y.Base - Common Base Functionality (100% backwards compat)
+
+ Y.AttributeCore - Lightest Attribute support, without CustomEvents
+ Y.BaseCore - Lightest Base support, without CustomEvents
+
+ --
+
+ Y.AttributeEvents - Augmentable Attribute Events support
+ Y.AttributeExtras - Augmentable 20% usage for Attribute (modifyAttr, removeAttr, reset ...)
+ Y.AttributeComplex - Augmentable support for constructor complex attribute parsing ({"x.y":foo})
+
+ --
+
+ Y.Attribute = Y.AttributeCore + Y.AttributeEvents + Y.AttributeExtras
+ Y.Base = Y.BaseCore + Y.Attribute
+
+ --
+
+ Modules:
+
+ "base-base" : Y.Base
+ "base-core" : Y.BaseCore
+
+ "base-build" : Y.Base.build/create/mix mixin
+
+ * Extended Base.create/mix support for _buildCfg, to Extensions, mainly so that
+ extensions can define a whitelist of statics which need to be copied to the
+ main class.
+
+ e.g.
+
+ MyExtension._buildCfg = {
+ aggregates:["newPropsToAggregate"...],
+ custom: {
+ newPropsToCustomMix
+ },
+ statics: ["newPropsToCopy"]
+ };
+
+3.4.1
+-----
+
+ * No changes.
+
+3.4.0
+-----
+
+ * Base now destroys plugins before destroying itself
+
+ * Base.create/mix extensions can now define initializer and
+ destructor prototype functions, which will get invoked after
+ the initializer for the host class into which they are mixed and
+ before it's destructor.
+
+ * Use a hash version of whitelist mix for improved performance.
+ Also removed non-required hasOwnProperty check and delete.
+
+3.3.0
+-----
+
+ * Fixed Base.mix when used on a class created using Base.create
+
+ * toString no longer inadvertently stamps the object, however,
+ we now stamp Base objects in the constructor, to support
+ use cases where the "toString" stamping was implicitly being
+ relied upon (e.g. in DD, as hashkeys).
+
+3.2.0
+-----
+
+ * Fixed Base.create to properly isolate ATTRS on extensions
+
+3.1.1
+-----
+
+ * No changes
+
+3.1.0
+-----
+
+ * As the final step in the destroy phase, Base now does a detachAll() to avoid invoking listeners
+ which may be waiting to be in an async. step which occurs after destruction.
+
+ * "init" and "destroy" events are now published with the defaultTargetOnly property set to true
+
+ * Added support for MyClass.EVENT_PREFIX to allow developers
+ to define their own event prefix
+
+ * Made "init" and "destroy" events fireOnce:true (along with
+ "render" in Widget), so that subscriptions made after the
+ events are fired, are notified immediately.
+
+ * Dynamic and non-dynamically built classes now have their
+ extensions instantiated the same way - during _initHierarchy.
+
+ * Updated ATTRS handling for Base.build, so that ATTRS are
+ also aggregated at the attribute configuration object level,
+ allowing extensions to add to, or overwrite, attribute
+ configuration properties on the host.
+
+ * Added sugar Base.create and Base.mix methods on top of
+ Base.build, to simplify the 2 main use cases:
+
+ 1) Creating a completely new class which uses extensions.
+ 2) Mixing in extensions to an existing class.
+
+ * Documented non-attribute on, after, bubbleTargets and plugins
+ property support in the Base constructor config argument
+
+3.0.0
+-----
+
+ * Fixed hasImpl method on built classes, to look up the class
+ hierarchy for applied extensions.
+
+ * Plugin.Host removed from base-base module and delivered as it's
+ own module - "pluginhost"
+
+ * base broken up into..
+
+ base-base: Provides class hierarchy support for ATTRS and
+ initialization
+
+ base-build: Provides Extension support in the form of
+ Base.build
+
+ base-pluginhost: Augments Plugin.Host to Base, adding plugin
+ support
+
+3.0.0 beta 1
+------------
+
+ * Config argument for init event now merged into the event facade,
+ instead of being passed separately (available as e.cfg).
+
+ * Removed Base.create. On review, considered to be overkill.
+ Users can easily create new instances, using Base.build
+
+ * Moved PluginHost down from Widget to Base, since utils and
+ Node will also support Plugins.
+
+ * PluginHost.plug and unplug now accept the plugin class as
+ arguments [plug(pluginClass, cfg) and unplug(pluginClass)].
+
+ * Split base module up into base-base and base-build.
+
+ * Added lazy attribute initialization support, to improve performance.
+
+ This also removes order dependency when processing ATTRS for a
+ particular class.
+
+ If a get/set call is made for an uninitialized attribute A, in the
+ getter/setter/validator or valueFns of another attribute B, A will
+ be intiailized on the fly.
+
+ * Added ability to subscribe to on/after events through the
+ constructor config object, e.g.:
+
+ new MyBaseObject({
+ on: {
+ init: handlerFn,
+ myAttrChange: handlerFn
+ },
+ after: {
+ init: handlerFn,
+ myAttrChange: handlerFn
+ },
+ ...
+ });
+
+ * Developers can now override the default clone behavior we use to
+ isolate default ATTRS config values, using cloneDefaultValue, e.g.:
+
+ ATTRS = {
+ myAttr : {
+ value: AnObjectOrArrayReference
+ cloneDefaultValue: true|false|"deep"|"shallow"
+ }
+ }
+
+ If the cloneDefaultValue property is not defined, Base will clone
+ any Arrays or Object literals which are used as default values when
+ configuring attributes for an instance, so that updates to instance
+ values do not modify the default value.
+
+ This behavior can be over-ridden using the cloneDefaultValue property:
+
+ true, deep:
+
+ Use Y.clone to protect the default value.
+
+ shallow:
+
+ Use Y.merge, to protect the default value.
+
+ false:
+
+ Don't clone Arrays or Object literals. The value is intended
+ to be used by reference, for example, when it points to
+ a utility object.
+
+ * Base.plug and Base.unplug used to add static Plugins (default plugins
+ for a class). Replaces static PLUGINS array, allowing subclasses to
+ easily unplug static plugins added higher up in the hierarchy.
+
+ * Base adds all attributes lazily. This means attributes don't get
+ initialized until the first call to get/set, speeding up construction
+ of Base based objects.
+
+ Attributes which have setters which set some other state in the object,
+ can configure the attribute to disable lazy initialization, by setting
+ lazyAdd:false as part of their attribute configuration, so that the setter
+ gets invoked during construction.
+
+3.0.0PR1 - Initial release
+--------------------------
+