// @cmd.optimizer.requires.async/** * This mixin allows users to easily require external scripts in their classes. This load * process delays application launch (`Ext.onReady`) until all such scripts are loaded * ensuring that your class will have access to its required scripts from the start. * * For example: * * Ext.define('Feed', { * mixins: ['Ext.mixin.Mashup'], * * requiredScripts: [ * '//www.foo.com/code/bar.js' // preserve http/s * ], * * // The code in "bar.js" will be available at application launch * }); * * If your required script needs to be dynamic, for example it contains a key for an API, you can * use the {@link Ext.Manifest#mashup mashup} object. * * @since 5.0.0 */Ext.define('Ext.mixin.Mashup', function (Mashup) { return { extend: 'Ext.Mixin', mixinConfig: { id: 'mashup', extended: function (baseClass, derivedClass) { Mashup.process(derivedClass); } }, /** * @cfg {String/String[]} requiredScripts * Scripts that are required to be loaded in order for your Mashup to work. * These scripts can also use {@link Ext.Template template} syntax if there is data in the * {@link Ext.Manifest#mashup mashup} object for the class `xtype`. * * For example, `Ext.ux.google.Map` needs an API key and so its `requiredScripts` looks * like this: * * requiredScripts: { * '//maps.googleapis.com/maps/api/js?key={key}' * } * * The `key` property is provided in `app.json` or directly in `Ext.manifest`: * * "mashup": { * "map": { // the xtype * "key": "[GOOGLE_MAPS_KEY]" * } * } * * For non-components (classes that have no `xtype`), the `mashupConfig` can be used * to supply the configuration key: * * mashupConfig: { * key: 'map' * } */ /** * @cfg {Object} mashup * An object that allows developers to pass values into templates used to populate * {@link Ext.Mashup#requiredScripts requiredScripts}. * * Here is an example of passing a key along to `Ext.ux.google.Map`. * * "mashup": { * "map": { // the xtype * "key": "[GOOGLE_MAPS_KEY]" * } * } * * @member Ext.Manifest */ statics: { process: function (targetClass) { var body = targetClass.prototype, requiredScripts = body.requiredScripts, hooks = targetClass._classHooks, onCreated = hooks.onCreated, xtypes = targetClass.prototype.xtypes, mashup = Ext.manifest.mashup || {}, options = body.mashupConfig, i, script; if (requiredScripts) { delete body.requiredScripts; hooks.onCreated = function() { var me = this, scripts = [], args = Ext.Array.slice(arguments), redirect = mashup.redirect || {}; requiredScripts = scripts.concat(requiredScripts); options = options && mashup[options.key]; if (xtypes) { for (i = 0; !options && i < xtypes.length; ++i) { options = mashup[xtypes[i]]; } } for (i = 0; i < requiredScripts.length; i++) { script = requiredScripts[i]; if (redirect[script] === false) { continue; } script = redirect[script] || script; if (script.indexOf('{') > -1) { if (options) { script = new Ext.Template(script).apply(options); } //<debug> else { Ext.log.error('Missing mashup options for ' + body.$className + ' script "' + script + '"'); } //</debug> } scripts.push(script); } if (!scripts.length) { hooks.onCreated = onCreated; hooks.onCreated.call(me, args); return; } Ext.Loader.loadScripts({ url: scripts, cache: true, // no cache busting onError: function(opts, error) { targetClass.scriptError = targetClass.prototype.scriptError = error; hooks.onCreated = onCreated; hooks.onCreated.call(me, args); }, onLoad: function() { hooks.onCreated = onCreated; hooks.onCreated.call(me, args); } }); }; } } }, onClassMixedIn: function (targetClass) { Mashup.process(targetClass); }}});