base-build-debug.js revision 50ebe4de3ac641ae0af0b39a29ccf82e4c3760b6
/**
* The base-build submodule provides Base.build functionality, which
* can be used to create custom classes, by aggregating extensions onto
* a main class.
*
* @module base
* @submodule base-build
* @for Base
*/
L = Y.Lang,
INITIALIZER = "initializer",
DESTRUCTOR = "destructor",
extClass = extensions[i];
delete extProto[INITIALIZER];
delete extProto[DESTRUCTOR];
// Prototype, old non-displacing augment
// Custom Statics
if (initializer) {
}
if (destructor) {
}
}
if (px) {
}
if (sx) {
}
if (dynamic) {
}
return builtClass;
};
var aggregates,
aggr,
l,
i;
if (cfg) {
}
if (statics) {
}
if (aggregates) {
aggr = aggregates[i];
}
}
}
if (custom) {
for (i in custom) {
if (custom.hasOwnProperty(i)) {
custom[i](i, r, s);
}
}
}
},
function BuiltClass() {
}
return BuiltClass;
},
for (j = 0; j < ll; j++) {
return true;
}
}
}
}
return false;
},
if (!buildCfg) {
}
return builtClass;
},
var aggr = [],
cust = {},
statics = [],
c = main,
i,
l;
// Prototype Chain
while (c && c.prototype) {
if (buildCfg) {
if (buildCfg.aggregates) {
}
}
}
}
}
// Exts
if (exts) {
c = exts[i];
if (buildCfg) {
if (buildCfg.aggregates) {
}
}
}
}
}
}
if (cfgAggr) {
}
if (cfgCustBuild) {
}
if (cfgStatics) {
}
return {
};
},
}
}
prop = aggregates[i];
}
}
return sxclone;
}
});
/**
* <p>
* Builds a custom constructor function (class) from the
* main function, and array of extension functions (classes)
* provided. The NAME field for the constructor function is
* defined by the first argument passed in.
* </p>
* <p>
* The cfg object supports the following properties
* </p>
* <dl>
* <dt>dynamic <boolean></dt>
* <dd>
* <p>If true (default), a completely new class
* is created which extends the main class, and acts as the
* host on which the extension classes are augmented.</p>
* <p>If false, the extensions classes are augmented directly to
* the main class, modifying the main class' prototype.</p>
* </dd>
* <dt>aggregates <String[]></dt>
* <dd>An array of static property names, which will get aggregated
* on to the built class, in addition to the default properties build
* will always aggregate as defined by the main class' static _buildCfg
* property.
* </dd>
* </dl>
*
* @method build
* @deprecated Use the more convenient Base.create and Base.mix methods instead
* @static
* @param {Function} name The name of the new class. Used to defined the NAME property for the new class.
* @param {Function} main The main class on which to base the built class
* @param {Function[]} extensions The set of extension classes which will be
* augmented/aggregated to the built class.
* @param {Object} cfg Optional. Build configuration for the class (see description).
* @return {Function} A custom class, created from the provided main and extension classes
*/
};
/**
* Creates a new class (constructor function) which extends the base class passed in as the second argument,
* and mixes in the array of extensions provided.
*
* Prototype properties or methods can be added to the new class, using the px argument (similar to Y.extend).
*
* Static properties or methods can be added to the new class, using the sx argument (similar to Y.extend).
*
* **NOTE FOR COMPONENT DEVELOPERS**: Both the `base` class, and `extensions` can define static a `_buildCfg`
* property, which acts as class creation meta-data, and drives how special static properties from the base
* class, or extensions should be copied, aggregated or (custom) mixed into the newly created class.
*
* The `_buildCfg` property is a hash with 3 supported properties: `statics`, `aggregates` and `custom`, e.g:
*
*
* MyBaseClass._buildCfg = {
*
* // Static properties/methods to copy (Alias) to the built class.
* statics: ["CopyThisMethod", "CopyThisProperty"],
*
* // Static props to aggregate onto the built class.
* aggregates: ["AggregateThisProperty"],
*
* // Static properties which need custom handling (e.g. deep merge etc.)
* custom: {
* "CustomProperty" : function(property, Receiver, Supplier) {
* ...
* Receiver.CustomProperty.triggers.push(supplier.CustomProperty.triggers);
* ...
* }
* }
* };
*
* MyBaseClass.CopyThisMethod = function() {...};
* MyBaseClass.CopyThisProperty = "foo";
* MyBaseClass.AggregateThisProperty = {...};
* MyBaseClass.CustomProperty = {
* triggers: [...]
* }
*
* // Or, if the Extension is the thing introducing the property:
*
* MyExtension._buildCfg = {
* statics : ...
* aggregates : ...
* custom : ...
* }
*
* This way, when users pass your base or extension class to `Y.Base.create` or `Y.Base.mix`, they don't need to
* know which properties need special handling. `Y.Base` has a buildCfg which defines `ATTRS` for custom mix handling
* (to protect the static config objects), and `Y.Widget` has a buildCfg which specifies `HTML_PARSER` for
* straight up aggregation.
*
* @method create
* @static
* @param {Function} name The name of the newly created class. Used to defined the NAME property for the new class.
* @param {Function} main The base class which the new class should extend. This class needs to be Base or a class derived from base (e.g. Widget).
* @param {Function[]} extensions The list of extensions which will be mixed into the built class.
* @param {Object} px The set of prototype properties/methods to add to the built class.
* @param {Object} sx The set of static properties/methods to add to the built class.
* @return {Function} The newly created class.
*/
};
/**
* <p>Mixes in a list of extensions to an existing class.</p>
* @method mix
* @static
* @param {Function} main The existing class into which the extensions should be mixed. The class needs to be Base or a class derived from Base (e.g. Widget)
* @param {Function[]} extensions The set of extension classes which will mixed into the existing main class.
* @return {Function} The modified main class, with extensions mixed in.
*/
};
/**
* The build configuration for the Base class.
*
* Defines the static fields which need to be aggregated
* when the Base class is used as the main class passed to
* the <a href="#method_Base.build">Base.build</a> method.
*
* @property _buildCfg
* @type Object
* @static
* @final
* @private
*/
custom : {
if (s.ATTRS) {
a;
for (a in sAttrs) {
if (sAttrs.hasOwnProperty(a)) {
}
}
}
}
},
};