| /** |
| * @license AngularJS v1.6.4 |
| * (c) 2010-2017 Google, Inc. http://angularjs.org |
| * License: MIT |
| */ |
| (function(window, angular) {'use strict'; |
| |
| /** |
| * @ngdoc module |
| * @name ngCookies |
| * @description |
| * |
| * # ngCookies |
| * |
| * The `ngCookies` module provides a convenient wrapper for reading and writing browser cookies. |
| * |
| * |
| * <div doc-module-components="ngCookies"></div> |
| * |
| * See {@link ngCookies.$cookies `$cookies`} for usage. |
| */ |
| |
| |
| angular.module('ngCookies', ['ng']). |
| info({ angularVersion: '1.6.4' }). |
| /** |
| * @ngdoc provider |
| * @name $cookiesProvider |
| * @description |
| * Use `$cookiesProvider` to change the default behavior of the {@link ngCookies.$cookies $cookies} service. |
| * */ |
| provider('$cookies', [/** @this */function $CookiesProvider() { |
| /** |
| * @ngdoc property |
| * @name $cookiesProvider#defaults |
| * @description |
| * |
| * Object containing default options to pass when setting cookies. |
| * |
| * The object may have following properties: |
| * |
| * - **path** - `{string}` - The cookie will be available only for this path and its |
| * sub-paths. By default, this is the URL that appears in your `<base>` tag. |
| * - **domain** - `{string}` - The cookie will be available only for this domain and |
| * its sub-domains. For security reasons the user agent will not accept the cookie |
| * if the current domain is not a sub-domain of this domain or equal to it. |
| * - **expires** - `{string|Date}` - String of the form "Wdy, DD Mon YYYY HH:MM:SS GMT" |
| * or a Date object indicating the exact date/time this cookie will expire. |
| * - **secure** - `{boolean}` - If `true`, then the cookie will only be available through a |
| * secured connection. |
| * |
| * Note: By default, the address that appears in your `<base>` tag will be used as the path. |
| * This is important so that cookies will be visible for all routes when html5mode is enabled. |
| * |
| * @example |
| * |
| * ```js |
| * angular.module('cookiesProviderExample', ['ngCookies']) |
| * .config(['$cookiesProvider', function($cookiesProvider) { |
| * // Setting default options |
| * $cookiesProvider.defaults.domain = 'foo.com'; |
| * $cookiesProvider.defaults.secure = true; |
| * }]); |
| * ``` |
| **/ |
| var defaults = this.defaults = {}; |
| |
| function calcOptions(options) { |
| return options ? angular.extend({}, defaults, options) : defaults; |
| } |
| |
| /** |
| * @ngdoc service |
| * @name $cookies |
| * |
| * @description |
| * Provides read/write access to browser's cookies. |
| * |
| * <div class="alert alert-info"> |
| * Up until Angular 1.3, `$cookies` exposed properties that represented the |
| * current browser cookie values. In version 1.4, this behavior has changed, and |
| * `$cookies` now provides a standard api of getters, setters etc. |
| * </div> |
| * |
| * Requires the {@link ngCookies `ngCookies`} module to be installed. |
| * |
| * @example |
| * |
| * ```js |
| * angular.module('cookiesExample', ['ngCookies']) |
| * .controller('ExampleController', ['$cookies', function($cookies) { |
| * // Retrieving a cookie |
| * var favoriteCookie = $cookies.get('myFavorite'); |
| * // Setting a cookie |
| * $cookies.put('myFavorite', 'oatmeal'); |
| * }]); |
| * ``` |
| */ |
| this.$get = ['$$cookieReader', '$$cookieWriter', function($$cookieReader, $$cookieWriter) { |
| return { |
| /** |
| * @ngdoc method |
| * @name $cookies#get |
| * |
| * @description |
| * Returns the value of given cookie key |
| * |
| * @param {string} key Id to use for lookup. |
| * @returns {string} Raw cookie value. |
| */ |
| get: function(key) { |
| return $$cookieReader()[key]; |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $cookies#getObject |
| * |
| * @description |
| * Returns the deserialized value of given cookie key |
| * |
| * @param {string} key Id to use for lookup. |
| * @returns {Object} Deserialized cookie value. |
| */ |
| getObject: function(key) { |
| var value = this.get(key); |
| return value ? angular.fromJson(value) : value; |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $cookies#getAll |
| * |
| * @description |
| * Returns a key value object with all the cookies |
| * |
| * @returns {Object} All cookies |
| */ |
| getAll: function() { |
| return $$cookieReader(); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $cookies#put |
| * |
| * @description |
| * Sets a value for given cookie key |
| * |
| * @param {string} key Id for the `value`. |
| * @param {string} value Raw value to be stored. |
| * @param {Object=} options Options object. |
| * See {@link ngCookies.$cookiesProvider#defaults $cookiesProvider.defaults} |
| */ |
| put: function(key, value, options) { |
| $$cookieWriter(key, value, calcOptions(options)); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $cookies#putObject |
| * |
| * @description |
| * Serializes and sets a value for given cookie key |
| * |
| * @param {string} key Id for the `value`. |
| * @param {Object} value Value to be stored. |
| * @param {Object=} options Options object. |
| * See {@link ngCookies.$cookiesProvider#defaults $cookiesProvider.defaults} |
| */ |
| putObject: function(key, value, options) { |
| this.put(key, angular.toJson(value), options); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $cookies#remove |
| * |
| * @description |
| * Remove given cookie |
| * |
| * @param {string} key Id of the key-value pair to delete. |
| * @param {Object=} options Options object. |
| * See {@link ngCookies.$cookiesProvider#defaults $cookiesProvider.defaults} |
| */ |
| remove: function(key, options) { |
| $$cookieWriter(key, undefined, calcOptions(options)); |
| } |
| }; |
| }]; |
| }]); |
| |
| angular.module('ngCookies'). |
| /** |
| * @ngdoc service |
| * @name $cookieStore |
| * @deprecated |
| * sinceVersion="v1.4.0" |
| * Please use the {@link ngCookies.$cookies `$cookies`} service instead. |
| * |
| * @requires $cookies |
| * |
| * @description |
| * Provides a key-value (string-object) storage, that is backed by session cookies. |
| * Objects put or retrieved from this storage are automatically serialized or |
| * deserialized by angular's toJson/fromJson. |
| * |
| * Requires the {@link ngCookies `ngCookies`} module to be installed. |
| * |
| * @example |
| * |
| * ```js |
| * angular.module('cookieStoreExample', ['ngCookies']) |
| * .controller('ExampleController', ['$cookieStore', function($cookieStore) { |
| * // Put cookie |
| * $cookieStore.put('myFavorite','oatmeal'); |
| * // Get cookie |
| * var favoriteCookie = $cookieStore.get('myFavorite'); |
| * // Removing a cookie |
| * $cookieStore.remove('myFavorite'); |
| * }]); |
| * ``` |
| */ |
| factory('$cookieStore', ['$cookies', function($cookies) { |
| |
| return { |
| /** |
| * @ngdoc method |
| * @name $cookieStore#get |
| * |
| * @description |
| * Returns the value of given cookie key |
| * |
| * @param {string} key Id to use for lookup. |
| * @returns {Object} Deserialized cookie value, undefined if the cookie does not exist. |
| */ |
| get: function(key) { |
| return $cookies.getObject(key); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $cookieStore#put |
| * |
| * @description |
| * Sets a value for given cookie key |
| * |
| * @param {string} key Id for the `value`. |
| * @param {Object} value Value to be stored. |
| */ |
| put: function(key, value) { |
| $cookies.putObject(key, value); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $cookieStore#remove |
| * |
| * @description |
| * Remove given cookie |
| * |
| * @param {string} key Id of the key-value pair to delete. |
| */ |
| remove: function(key) { |
| $cookies.remove(key); |
| } |
| }; |
| |
| }]); |
| |
| /** |
| * @name $$cookieWriter |
| * @requires $document |
| * |
| * @description |
| * This is a private service for writing cookies |
| * |
| * @param {string} name Cookie name |
| * @param {string=} value Cookie value (if undefined, cookie will be deleted) |
| * @param {Object=} options Object with options that need to be stored for the cookie. |
| */ |
| function $$CookieWriter($document, $log, $browser) { |
| var cookiePath = $browser.baseHref(); |
| var rawDocument = $document[0]; |
| |
| function buildCookieString(name, value, options) { |
| var path, expires; |
| options = options || {}; |
| expires = options.expires; |
| path = angular.isDefined(options.path) ? options.path : cookiePath; |
| if (angular.isUndefined(value)) { |
| expires = 'Thu, 01 Jan 1970 00:00:00 GMT'; |
| value = ''; |
| } |
| if (angular.isString(expires)) { |
| expires = new Date(expires); |
| } |
| |
| var str = encodeURIComponent(name) + '=' + encodeURIComponent(value); |
| str += path ? ';path=' + path : ''; |
| str += options.domain ? ';domain=' + options.domain : ''; |
| str += expires ? ';expires=' + expires.toUTCString() : ''; |
| str += options.secure ? ';secure' : ''; |
| |
| // per http://www.ietf.org/rfc/rfc2109.txt browser must allow at minimum: |
| // - 300 cookies |
| // - 20 cookies per unique domain |
| // - 4096 bytes per cookie |
| var cookieLength = str.length + 1; |
| if (cookieLength > 4096) { |
| $log.warn('Cookie \'' + name + |
| '\' possibly not set or overflowed because it was too large (' + |
| cookieLength + ' > 4096 bytes)!'); |
| } |
| |
| return str; |
| } |
| |
| return function(name, value, options) { |
| rawDocument.cookie = buildCookieString(name, value, options); |
| }; |
| } |
| |
| $$CookieWriter.$inject = ['$document', '$log', '$browser']; |
| |
| angular.module('ngCookies').provider('$$cookieWriter', /** @this */ function $$CookieWriterProvider() { |
| this.$get = $$CookieWriter; |
| }); |
| |
| |
| })(window, window.angular); |