639 lines
23 KiB
JavaScript
639 lines
23 KiB
JavaScript
/**
|
|
* @license AngularJS v1.8.0
|
|
* (c) 2010-2020 Google, Inc. http://angularjs.org
|
|
* License: MIT
|
|
*/
|
|
|
|
(function() {'use strict';
|
|
// NOTE:
|
|
// These functions are copied here from `src/Angular.js`, because they are needed inside the
|
|
// `angular-loader.js` closure and need to be available before the main `angular.js` script has
|
|
// been loaded.
|
|
function isFunction(value) {return typeof value === 'function';}
|
|
function isDefined(value) {return typeof value !== 'undefined';}
|
|
function isNumber(value) {return typeof value === 'number';}
|
|
function isObject(value) {return value !== null && typeof value === 'object';}
|
|
function isScope(obj) {return obj && obj.$evalAsync && obj.$watch;}
|
|
function isUndefined(value) {return typeof value === 'undefined';}
|
|
function isWindow(obj) {return obj && obj.window === obj;}
|
|
function sliceArgs(args, startIndex) {return Array.prototype.slice.call(args, startIndex || 0);}
|
|
function toJsonReplacer(key, value) {
|
|
var val = value;
|
|
|
|
if (typeof key === 'string' && key.charAt(0) === '$' && key.charAt(1) === '$') {
|
|
val = undefined;
|
|
} else if (isWindow(value)) {
|
|
val = '$WINDOW';
|
|
} else if (value && window.document === value) {
|
|
val = '$DOCUMENT';
|
|
} else if (isScope(value)) {
|
|
val = '$SCOPE';
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
/* exported toDebugString */
|
|
|
|
function serializeObject(obj, maxDepth) {
|
|
var seen = [];
|
|
|
|
// There is no direct way to stringify object until reaching a specific depth
|
|
// and a very deep object can cause a performance issue, so we copy the object
|
|
// based on this specific depth and then stringify it.
|
|
if (isValidObjectMaxDepth(maxDepth)) {
|
|
// This file is also included in `angular-loader`, so `copy()` might not always be available in
|
|
// the closure. Therefore, it is lazily retrieved as `angular.copy()` when needed.
|
|
obj = angular.copy(obj, null, maxDepth);
|
|
}
|
|
return JSON.stringify(obj, function(key, val) {
|
|
val = toJsonReplacer(key, val);
|
|
if (isObject(val)) {
|
|
|
|
if (seen.indexOf(val) >= 0) return '...';
|
|
|
|
seen.push(val);
|
|
}
|
|
return val;
|
|
});
|
|
}
|
|
|
|
function toDebugString(obj, maxDepth) {
|
|
if (typeof obj === 'function') {
|
|
return obj.toString().replace(/ \{[\s\S]*$/, '');
|
|
} else if (isUndefined(obj)) {
|
|
return 'undefined';
|
|
} else if (typeof obj !== 'string') {
|
|
return serializeObject(obj, maxDepth);
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
/* exported
|
|
minErrConfig,
|
|
errorHandlingConfig,
|
|
isValidObjectMaxDepth
|
|
*/
|
|
|
|
var minErrConfig = {
|
|
objectMaxDepth: 5,
|
|
urlErrorParamsEnabled: true
|
|
};
|
|
|
|
/**
|
|
* @ngdoc function
|
|
* @name angular.errorHandlingConfig
|
|
* @module ng
|
|
* @kind function
|
|
*
|
|
* @description
|
|
* Configure several aspects of error handling in AngularJS if used as a setter or return the
|
|
* current configuration if used as a getter. The following options are supported:
|
|
*
|
|
* - **objectMaxDepth**: The maximum depth to which objects are traversed when stringified for error messages.
|
|
*
|
|
* Omitted or undefined options will leave the corresponding configuration values unchanged.
|
|
*
|
|
* @param {Object=} config - The configuration object. May only contain the options that need to be
|
|
* updated. Supported keys:
|
|
*
|
|
* * `objectMaxDepth` **{Number}** - The max depth for stringifying objects. Setting to a
|
|
* non-positive or non-numeric value, removes the max depth limit.
|
|
* Default: 5
|
|
*
|
|
* * `urlErrorParamsEnabled` **{Boolean}** - Specifies whether the generated error url will
|
|
* contain the parameters of the thrown error. Disabling the parameters can be useful if the
|
|
* generated error url is very long.
|
|
*
|
|
* Default: true. When used without argument, it returns the current value.
|
|
*/
|
|
function errorHandlingConfig(config) {
|
|
if (isObject(config)) {
|
|
if (isDefined(config.objectMaxDepth)) {
|
|
minErrConfig.objectMaxDepth = isValidObjectMaxDepth(config.objectMaxDepth) ? config.objectMaxDepth : NaN;
|
|
}
|
|
if (isDefined(config.urlErrorParamsEnabled) && isBoolean(config.urlErrorParamsEnabled)) {
|
|
minErrConfig.urlErrorParamsEnabled = config.urlErrorParamsEnabled;
|
|
}
|
|
} else {
|
|
return minErrConfig;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* @param {Number} maxDepth
|
|
* @return {boolean}
|
|
*/
|
|
function isValidObjectMaxDepth(maxDepth) {
|
|
return isNumber(maxDepth) && maxDepth > 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* @description
|
|
*
|
|
* This object provides a utility for producing rich Error messages within
|
|
* AngularJS. It can be called as follows:
|
|
*
|
|
* var exampleMinErr = minErr('example');
|
|
* throw exampleMinErr('one', 'This {0} is {1}', foo, bar);
|
|
*
|
|
* The above creates an instance of minErr in the example namespace. The
|
|
* resulting error will have a namespaced error code of example.one. The
|
|
* resulting error will replace {0} with the value of foo, and {1} with the
|
|
* value of bar. The object is not restricted in the number of arguments it can
|
|
* take.
|
|
*
|
|
* If fewer arguments are specified than necessary for interpolation, the extra
|
|
* interpolation markers will be preserved in the final string.
|
|
*
|
|
* Since data will be parsed statically during a build step, some restrictions
|
|
* are applied with respect to how minErr instances are created and called.
|
|
* Instances should have names of the form namespaceMinErr for a minErr created
|
|
* using minErr('namespace'). Error codes, namespaces and template strings
|
|
* should all be static strings, not variables or general expressions.
|
|
*
|
|
* @param {string} module The namespace to use for the new minErr instance.
|
|
* @param {function} ErrorConstructor Custom error constructor to be instantiated when returning
|
|
* error from returned function, for cases when a particular type of error is useful.
|
|
* @returns {function(code:string, template:string, ...templateArgs): Error} minErr instance
|
|
*/
|
|
|
|
function minErr(module, ErrorConstructor) {
|
|
ErrorConstructor = ErrorConstructor || Error;
|
|
|
|
var url = 'https://errors.angularjs.org/1.8.0/';
|
|
var regex = url.replace('.', '\\.') + '[\\s\\S]*';
|
|
var errRegExp = new RegExp(regex, 'g');
|
|
|
|
return function() {
|
|
var code = arguments[0],
|
|
template = arguments[1],
|
|
message = '[' + (module ? module + ':' : '') + code + '] ',
|
|
templateArgs = sliceArgs(arguments, 2).map(function(arg) {
|
|
return toDebugString(arg, minErrConfig.objectMaxDepth);
|
|
}),
|
|
paramPrefix, i;
|
|
|
|
// A minErr message has two parts: the message itself and the url that contains the
|
|
// encoded message.
|
|
// The message's parameters can contain other error messages which also include error urls.
|
|
// To prevent the messages from getting too long, we strip the error urls from the parameters.
|
|
|
|
message += template.replace(/\{\d+\}/g, function(match) {
|
|
var index = +match.slice(1, -1);
|
|
|
|
if (index < templateArgs.length) {
|
|
return templateArgs[index].replace(errRegExp, '');
|
|
}
|
|
|
|
return match;
|
|
});
|
|
|
|
message += '\n' + url + (module ? module + '/' : '') + code;
|
|
|
|
if (minErrConfig.urlErrorParamsEnabled) {
|
|
for (i = 0, paramPrefix = '?'; i < templateArgs.length; i++, paramPrefix = '&') {
|
|
message += paramPrefix + 'p' + i + '=' + encodeURIComponent(templateArgs[i]);
|
|
}
|
|
}
|
|
|
|
return new ErrorConstructor(message);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @ngdoc type
|
|
* @name angular.Module
|
|
* @module ng
|
|
* @description
|
|
*
|
|
* Interface for configuring AngularJS {@link angular.module modules}.
|
|
*/
|
|
|
|
function setupModuleLoader(window) {
|
|
|
|
var $injectorMinErr = minErr('$injector');
|
|
var ngMinErr = minErr('ng');
|
|
|
|
function ensure(obj, name, factory) {
|
|
return obj[name] || (obj[name] = factory());
|
|
}
|
|
|
|
var angular = ensure(window, 'angular', Object);
|
|
|
|
// We need to expose `angular.$$minErr` to modules such as `ngResource` that reference it during bootstrap
|
|
angular.$$minErr = angular.$$minErr || minErr;
|
|
|
|
return ensure(angular, 'module', function() {
|
|
/** @type {Object.<string, angular.Module>} */
|
|
var modules = {};
|
|
|
|
/**
|
|
* @ngdoc function
|
|
* @name angular.module
|
|
* @module ng
|
|
* @description
|
|
*
|
|
* The `angular.module` is a global place for creating, registering and retrieving AngularJS
|
|
* modules.
|
|
* All modules (AngularJS core or 3rd party) that should be available to an application must be
|
|
* registered using this mechanism.
|
|
*
|
|
* Passing one argument retrieves an existing {@link angular.Module},
|
|
* whereas passing more than one argument creates a new {@link angular.Module}
|
|
*
|
|
*
|
|
* # Module
|
|
*
|
|
* A module is a collection of services, directives, controllers, filters, and configuration information.
|
|
* `angular.module` is used to configure the {@link auto.$injector $injector}.
|
|
*
|
|
* ```js
|
|
* // Create a new module
|
|
* var myModule = angular.module('myModule', []);
|
|
*
|
|
* // register a new service
|
|
* myModule.value('appName', 'MyCoolApp');
|
|
*
|
|
* // configure existing services inside initialization blocks.
|
|
* myModule.config(['$locationProvider', function($locationProvider) {
|
|
* // Configure existing providers
|
|
* $locationProvider.hashPrefix('!');
|
|
* }]);
|
|
* ```
|
|
*
|
|
* Then you can create an injector and load your modules like this:
|
|
*
|
|
* ```js
|
|
* var injector = angular.injector(['ng', 'myModule'])
|
|
* ```
|
|
*
|
|
* However it's more likely that you'll just use
|
|
* {@link ng.directive:ngApp ngApp} or
|
|
* {@link angular.bootstrap} to simplify this process for you.
|
|
*
|
|
* @param {!string} name The name of the module to create or retrieve.
|
|
* @param {!Array.<string>=} requires If specified then new module is being created. If
|
|
* unspecified then the module is being retrieved for further configuration.
|
|
* @param {Function=} configFn Optional configuration function for the module. Same as
|
|
* {@link angular.Module#config Module#config()}.
|
|
* @returns {angular.Module} new module with the {@link angular.Module} api.
|
|
*/
|
|
return function module(name, requires, configFn) {
|
|
|
|
var info = {};
|
|
|
|
var assertNotHasOwnProperty = function(name, context) {
|
|
if (name === 'hasOwnProperty') {
|
|
throw ngMinErr('badname', 'hasOwnProperty is not a valid {0} name', context);
|
|
}
|
|
};
|
|
|
|
assertNotHasOwnProperty(name, 'module');
|
|
if (requires && modules.hasOwnProperty(name)) {
|
|
modules[name] = null;
|
|
}
|
|
return ensure(modules, name, function() {
|
|
if (!requires) {
|
|
throw $injectorMinErr('nomod', 'Module \'{0}\' is not available! You either misspelled ' +
|
|
'the module name or forgot to load it. If registering a module ensure that you ' +
|
|
'specify the dependencies as the second argument.', name);
|
|
}
|
|
|
|
/** @type {!Array.<Array.<*>>} */
|
|
var invokeQueue = [];
|
|
|
|
/** @type {!Array.<Function>} */
|
|
var configBlocks = [];
|
|
|
|
/** @type {!Array.<Function>} */
|
|
var runBlocks = [];
|
|
|
|
var config = invokeLater('$injector', 'invoke', 'push', configBlocks);
|
|
|
|
/** @type {angular.Module} */
|
|
var moduleInstance = {
|
|
// Private state
|
|
_invokeQueue: invokeQueue,
|
|
_configBlocks: configBlocks,
|
|
_runBlocks: runBlocks,
|
|
|
|
/**
|
|
* @ngdoc method
|
|
* @name angular.Module#info
|
|
* @module ng
|
|
*
|
|
* @param {Object=} info Information about the module
|
|
* @returns {Object|Module} The current info object for this module if called as a getter,
|
|
* or `this` if called as a setter.
|
|
*
|
|
* @description
|
|
* Read and write custom information about this module.
|
|
* For example you could put the version of the module in here.
|
|
*
|
|
* ```js
|
|
* angular.module('myModule', []).info({ version: '1.0.0' });
|
|
* ```
|
|
*
|
|
* The version could then be read back out by accessing the module elsewhere:
|
|
*
|
|
* ```
|
|
* var version = angular.module('myModule').info().version;
|
|
* ```
|
|
*
|
|
* You can also retrieve this information during runtime via the
|
|
* {@link $injector#modules `$injector.modules`} property:
|
|
*
|
|
* ```js
|
|
* var version = $injector.modules['myModule'].info().version;
|
|
* ```
|
|
*/
|
|
info: function(value) {
|
|
if (isDefined(value)) {
|
|
if (!isObject(value)) throw ngMinErr('aobj', 'Argument \'{0}\' must be an object', 'value');
|
|
info = value;
|
|
return this;
|
|
}
|
|
return info;
|
|
},
|
|
|
|
/**
|
|
* @ngdoc property
|
|
* @name angular.Module#requires
|
|
* @module ng
|
|
*
|
|
* @description
|
|
* Holds the list of modules which the injector will load before the current module is
|
|
* loaded.
|
|
*/
|
|
requires: requires,
|
|
|
|
/**
|
|
* @ngdoc property
|
|
* @name angular.Module#name
|
|
* @module ng
|
|
*
|
|
* @description
|
|
* Name of the module.
|
|
*/
|
|
name: name,
|
|
|
|
|
|
/**
|
|
* @ngdoc method
|
|
* @name angular.Module#provider
|
|
* @module ng
|
|
* @param {string} name service name
|
|
* @param {Function} providerType Construction function for creating new instance of the
|
|
* service.
|
|
* @description
|
|
* See {@link auto.$provide#provider $provide.provider()}.
|
|
*/
|
|
provider: invokeLaterAndSetModuleName('$provide', 'provider'),
|
|
|
|
/**
|
|
* @ngdoc method
|
|
* @name angular.Module#factory
|
|
* @module ng
|
|
* @param {string} name service name
|
|
* @param {Function} providerFunction Function for creating new instance of the service.
|
|
* @description
|
|
* See {@link auto.$provide#factory $provide.factory()}.
|
|
*/
|
|
factory: invokeLaterAndSetModuleName('$provide', 'factory'),
|
|
|
|
/**
|
|
* @ngdoc method
|
|
* @name angular.Module#service
|
|
* @module ng
|
|
* @param {string} name service name
|
|
* @param {Function} constructor A constructor function that will be instantiated.
|
|
* @description
|
|
* See {@link auto.$provide#service $provide.service()}.
|
|
*/
|
|
service: invokeLaterAndSetModuleName('$provide', 'service'),
|
|
|
|
/**
|
|
* @ngdoc method
|
|
* @name angular.Module#value
|
|
* @module ng
|
|
* @param {string} name service name
|
|
* @param {*} object Service instance object.
|
|
* @description
|
|
* See {@link auto.$provide#value $provide.value()}.
|
|
*/
|
|
value: invokeLater('$provide', 'value'),
|
|
|
|
/**
|
|
* @ngdoc method
|
|
* @name angular.Module#constant
|
|
* @module ng
|
|
* @param {string} name constant name
|
|
* @param {*} object Constant value.
|
|
* @description
|
|
* Because the constants are fixed, they get applied before other provide methods.
|
|
* See {@link auto.$provide#constant $provide.constant()}.
|
|
*/
|
|
constant: invokeLater('$provide', 'constant', 'unshift'),
|
|
|
|
/**
|
|
* @ngdoc method
|
|
* @name angular.Module#decorator
|
|
* @module ng
|
|
* @param {string} name The name of the service to decorate.
|
|
* @param {Function} decorFn This function will be invoked when the service needs to be
|
|
* instantiated and should return the decorated service instance.
|
|
* @description
|
|
* See {@link auto.$provide#decorator $provide.decorator()}.
|
|
*/
|
|
decorator: invokeLaterAndSetModuleName('$provide', 'decorator', configBlocks),
|
|
|
|
/**
|
|
* @ngdoc method
|
|
* @name angular.Module#animation
|
|
* @module ng
|
|
* @param {string} name animation name
|
|
* @param {Function} animationFactory Factory function for creating new instance of an
|
|
* animation.
|
|
* @description
|
|
*
|
|
* **NOTE**: animations take effect only if the **ngAnimate** module is loaded.
|
|
*
|
|
*
|
|
* Defines an animation hook that can be later used with
|
|
* {@link $animate $animate} service and directives that use this service.
|
|
*
|
|
* ```js
|
|
* module.animation('.animation-name', function($inject1, $inject2) {
|
|
* return {
|
|
* eventName : function(element, done) {
|
|
* //code to run the animation
|
|
* //once complete, then run done()
|
|
* return function cancellationFunction(element) {
|
|
* //code to cancel the animation
|
|
* }
|
|
* }
|
|
* }
|
|
* })
|
|
* ```
|
|
*
|
|
* See {@link ng.$animateProvider#register $animateProvider.register()} and
|
|
* {@link ngAnimate ngAnimate module} for more information.
|
|
*/
|
|
animation: invokeLaterAndSetModuleName('$animateProvider', 'register'),
|
|
|
|
/**
|
|
* @ngdoc method
|
|
* @name angular.Module#filter
|
|
* @module ng
|
|
* @param {string} name Filter name - this must be a valid AngularJS expression identifier
|
|
* @param {Function} filterFactory Factory function for creating new instance of filter.
|
|
* @description
|
|
* See {@link ng.$filterProvider#register $filterProvider.register()}.
|
|
*
|
|
* <div class="alert alert-warning">
|
|
* **Note:** Filter names must be valid AngularJS {@link expression} identifiers, such as `uppercase` or `orderBy`.
|
|
* Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
|
|
* your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
|
|
* (`myapp_subsection_filterx`).
|
|
* </div>
|
|
*/
|
|
filter: invokeLaterAndSetModuleName('$filterProvider', 'register'),
|
|
|
|
/**
|
|
* @ngdoc method
|
|
* @name angular.Module#controller
|
|
* @module ng
|
|
* @param {string|Object} name Controller name, or an object map of controllers where the
|
|
* keys are the names and the values are the constructors.
|
|
* @param {Function} constructor Controller constructor function.
|
|
* @description
|
|
* See {@link ng.$controllerProvider#register $controllerProvider.register()}.
|
|
*/
|
|
controller: invokeLaterAndSetModuleName('$controllerProvider', 'register'),
|
|
|
|
/**
|
|
* @ngdoc method
|
|
* @name angular.Module#directive
|
|
* @module ng
|
|
* @param {string|Object} name Directive name, or an object map of directives where the
|
|
* keys are the names and the values are the factories.
|
|
* @param {Function} directiveFactory Factory function for creating new instance of
|
|
* directives.
|
|
* @description
|
|
* See {@link ng.$compileProvider#directive $compileProvider.directive()}.
|
|
*/
|
|
directive: invokeLaterAndSetModuleName('$compileProvider', 'directive'),
|
|
|
|
/**
|
|
* @ngdoc method
|
|
* @name angular.Module#component
|
|
* @module ng
|
|
* @param {string|Object} name Name of the component in camelCase (i.e. `myComp` which will match `<my-comp>`),
|
|
* or an object map of components where the keys are the names and the values are the component definition objects.
|
|
* @param {Object} options Component definition object (a simplified
|
|
* {@link ng.$compile#directive-definition-object directive definition object})
|
|
*
|
|
* @description
|
|
* See {@link ng.$compileProvider#component $compileProvider.component()}.
|
|
*/
|
|
component: invokeLaterAndSetModuleName('$compileProvider', 'component'),
|
|
|
|
/**
|
|
* @ngdoc method
|
|
* @name angular.Module#config
|
|
* @module ng
|
|
* @param {Function} configFn Execute this function on module load. Useful for service
|
|
* configuration.
|
|
* @description
|
|
* Use this method to configure services by injecting their
|
|
* {@link angular.Module#provider `providers`}, e.g. for adding routes to the
|
|
* {@link ngRoute.$routeProvider $routeProvider}.
|
|
*
|
|
* Note that you can only inject {@link angular.Module#provider `providers`} and
|
|
* {@link angular.Module#constant `constants`} into this function.
|
|
*
|
|
* For more about how to configure services, see
|
|
* {@link providers#provider-recipe Provider Recipe}.
|
|
*/
|
|
config: config,
|
|
|
|
/**
|
|
* @ngdoc method
|
|
* @name angular.Module#run
|
|
* @module ng
|
|
* @param {Function} initializationFn Execute this function after injector creation.
|
|
* Useful for application initialization.
|
|
* @description
|
|
* Use this method to register work which should be performed when the injector is done
|
|
* loading all modules.
|
|
*/
|
|
run: function(block) {
|
|
runBlocks.push(block);
|
|
return this;
|
|
}
|
|
};
|
|
|
|
if (configFn) {
|
|
config(configFn);
|
|
}
|
|
|
|
return moduleInstance;
|
|
|
|
/**
|
|
* @param {string} provider
|
|
* @param {string} method
|
|
* @param {String=} insertMethod
|
|
* @returns {angular.Module}
|
|
*/
|
|
function invokeLater(provider, method, insertMethod, queue) {
|
|
if (!queue) queue = invokeQueue;
|
|
return function() {
|
|
queue[insertMethod || 'push']([provider, method, arguments]);
|
|
return moduleInstance;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {string} provider
|
|
* @param {string} method
|
|
* @returns {angular.Module}
|
|
*/
|
|
function invokeLaterAndSetModuleName(provider, method, queue) {
|
|
if (!queue) queue = invokeQueue;
|
|
return function(recipeName, factoryFunction) {
|
|
if (factoryFunction && isFunction(factoryFunction)) factoryFunction.$$moduleName = name;
|
|
queue.push([provider, method, arguments]);
|
|
return moduleInstance;
|
|
};
|
|
}
|
|
});
|
|
};
|
|
});
|
|
|
|
}
|
|
|
|
setupModuleLoader(window);
|
|
})(window);
|
|
|
|
/**
|
|
* Closure compiler type information
|
|
*
|
|
* @typedef { {
|
|
* requires: !Array.<string>,
|
|
* invokeQueue: !Array.<Array.<*>>,
|
|
*
|
|
* service: function(string, Function):angular.Module,
|
|
* factory: function(string, Function):angular.Module,
|
|
* value: function(string, *):angular.Module,
|
|
*
|
|
* filter: function(string, Function):angular.Module,
|
|
*
|
|
* init: function(Function):angular.Module
|
|
* } }
|
|
*/
|
|
angular.Module;
|
|
|