/bower_components/js-cookie/CONTRIBUTING.md |
@@ -0,0 +1,79 @@ |
## Issues |
|
- Report issues or feature requests on [GitHub Issues](https://github.com/js-cookie/js-cookie/issues). |
- If reporting a bug, please add a [simplified example](http://sscce.org/). |
|
## Pull requests |
- Create a new topic branch for every separate change you make. |
- Create a test case if you are fixing a bug or implementing an important feature. |
- Make sure the build runs successfully. |
|
## Development |
|
### Tools |
We use the following tools for development: |
|
- [Qunit](http://qunitjs.com/) for tests. |
- [NodeJS](http://nodejs.org/download/) required to run grunt. |
- [Grunt](http://gruntjs.com/getting-started) for task management. |
|
### Getting started |
Install [NodeJS](http://nodejs.org/). |
Install globally grunt-cli using the following command: |
|
$ npm install -g grunt-cli |
|
Browse to the project root directory and install the dev dependencies: |
|
$ npm install -d |
|
To execute the build and tests run the following command in the root of the project: |
|
$ grunt |
|
You should see a green message in the console: |
|
Done, without errors. |
|
### Tests |
You can also run the tests in the browser. |
Start a test server from the project root: |
|
$ grunt connect:tests |
|
This will automatically open the test suite at http://127.0.0.1:10000 in the default browser, with livereload enabled. |
|
_Note: we recommend cleaning all the browser cookies before running the tests, that can avoid false positive failures._ |
|
### Automatic build |
You can build automatically after a file change using the following command: |
|
$ grunt watch |
|
## Integration with server-side |
|
js-cookie allows integrating the encoding test suite with solutions written in other server-side languages. To integrate successfully, the server-side solution need to execute the `test/encoding.html` file in it's integration testing routine with a web automation tool, like [Selenium](http://www.seleniumhq.org/). js-cookie test suite exposes an API to make this happen. |
|
### ?integration_baseurl |
|
Specify the base url to pass the cookies into the server through a query string. If `integration_baseurl` query is not present, then js-cookie will assume there's no server. |
|
### window.global_test_results |
|
After the test suite has finished, js-cookie exposes the global `window.global_test_results` property containing an Object Literal that represents the [QUnit's details](http://api.qunitjs.com/QUnit.done/). js-cookie also adds an additional property representing an Array containing the tests data. |
|
### Handling requests |
|
When js-cookie encoding tests are executed, it will request a url in the server through an iframe representing each test being run. js-cookie expects the server to handle the input and return the proper `Set-Cookie` headers in the response. js-cookie will then read the response and verify if the encoding is consistent with js-cookie default encoding mechanism |
|
js-cookie will send some requests to the server from the baseurl in the format `/encoding?name=<cookie>`, where `<cookie>` represents the cookie-name to be read from the request. |
|
The server should handle those requests, internally parsing the cookie from the request and writing it again. It must set an `application/json` content type containing an object literal in the content body with `name` and `value` keys, each representing the cookie-name and cookie-value decoded by the server-side implementation. |
|
If the server fails to respond with this specification in any request, the related QUnit test will fail. This is to make sure the server-side implementation will always be in sync with js-cookie encoding tests for maximum compatibility. |
|
### Projects using it |
|
This hook is being used in the following projects: |
|
* [Java Cookie](https://github.com/js-cookie/java-cookie). |
/bower_components/js-cookie/README.md |
@@ -0,0 +1,291 @@ |
<p align="center"> |
<img src="https://cloud.githubusercontent.com/assets/835857/14581711/ba623018-0436-11e6-8fce-d2ccd4d379c9.gif"> |
</p> |
|
# JavaScript Cookie [![Build Status](https://travis-ci.org/js-cookie/js-cookie.svg?branch=master)](https://travis-ci.org/js-cookie/js-cookie) [![Code Climate](https://codeclimate.com/github/js-cookie/js-cookie.svg)](https://codeclimate.com/github/js-cookie/js-cookie) |
|
A simple, lightweight JavaScript API for handling cookies |
|
* Works in [all](https://saucelabs.com/u/js-cookie) browsers |
* Accepts [any](#encoding) character |
* [Heavily](test) tested |
* No dependency |
* [Unobtrusive](#json) JSON support |
* Supports AMD/CommonJS |
* [RFC 6265](https://tools.ietf.org/html/rfc6265) compliant |
* Useful [Wiki](https://github.com/js-cookie/js-cookie/wiki) |
* Enable [custom encoding/decoding](#converters) |
* **~900 bytes** gzipped! |
|
**If you're viewing this at https://github.com/js-cookie/js-cookie, you're reading the documentation for the master branch. |
[View documentation for the latest release.](https://github.com/js-cookie/js-cookie/tree/latest#readme)** |
|
## Build Status Matrix |
|
[![Selenium Test Status](https://saucelabs.com/browser-matrix/js-cookie.svg)](https://saucelabs.com/u/js-cookie) |
|
## Installation |
|
### Direct download |
|
Download the script [here](https://github.com/js-cookie/js-cookie/blob/latest/src/js.cookie.js) and include it (unless you are packaging scripts somehow else): |
|
```html |
<script src="/path/to/js.cookie.js"></script> |
``` |
|
**Do not include the script directly from GitHub (http://raw.github.com/...).** The file is being served as text/plain and as such being blocked |
in Internet Explorer on Windows 7 for instance (because of the wrong MIME type). Bottom line: GitHub is not a CDN. |
|
### Package Managers |
|
JavaScript Cookie supports [npm](https://www.npmjs.com/package/js-cookie) and [Bower](http://bower.io/search/?q=js-cookie) under the name `js-cookie`. |
|
### Module Loaders |
|
JavaScript Cookie can also be loaded as an AMD, CommonJS or [ES6](https://github.com/js-cookie/js-cookie/issues/233#issuecomment-233187386) module. |
|
## Basic Usage |
|
Create a cookie, valid across the entire site: |
|
```javascript |
Cookies.set('name', 'value'); |
``` |
|
Create a cookie that expires 7 days from now, valid across the entire site: |
|
```javascript |
Cookies.set('name', 'value', { expires: 7 }); |
``` |
|
Create an expiring cookie, valid to the path of the current page: |
|
```javascript |
Cookies.set('name', 'value', { expires: 7, path: '' }); |
``` |
|
Read cookie: |
|
```javascript |
Cookies.get('name'); // => 'value' |
Cookies.get('nothing'); // => undefined |
``` |
|
Read all visible cookies: |
|
```javascript |
Cookies.get(); // => { name: 'value' } |
``` |
|
Delete cookie: |
|
```javascript |
Cookies.remove('name'); |
``` |
|
Delete a cookie valid to the path of the current page: |
|
```javascript |
Cookies.set('name', 'value', { path: '' }); |
Cookies.remove('name'); // fail! |
Cookies.remove('name', { path: '' }); // removed! |
``` |
|
*IMPORTANT! when deleting a cookie, you must pass the exact same path and domain attributes that was used to set the cookie, unless you're relying on the [default attributes](#cookie-attributes).* |
|
## Namespace conflicts |
|
If there is any danger of a conflict with the namespace `Cookies`, the `noConflict` method will allow you to define a new namespace and preserve the original one. This is especially useful when running the script on third party sites e.g. as part of a widget or SDK. |
|
```javascript |
// Assign the js-cookie api to a different variable and restore the original "window.Cookies" |
var Cookies2 = Cookies.noConflict(); |
Cookies2.set('name', 'value'); |
``` |
|
*Note: The `.noConflict` method is not necessary when using AMD or CommonJS, thus it is not exposed in those environments.* |
|
## JSON |
|
js-cookie provides unobtrusive JSON storage for cookies. |
|
When creating a cookie you can pass an Array or Object Literal instead of a string in the value. If you do so, js-cookie will store the string representation of the object according to `JSON.stringify`: |
|
```javascript |
Cookies.set('name', { foo: 'bar' }); |
``` |
|
When reading a cookie with the default `Cookies.get` api, you receive the string representation stored in the cookie: |
|
```javascript |
Cookies.get('name'); // => '{"foo":"bar"}' |
``` |
|
```javascript |
Cookies.get(); // => { name: '{"foo":"bar"}' } |
``` |
|
When reading a cookie with the `Cookies.getJSON` api, you receive the parsed representation of the string stored in the cookie according to `JSON.parse`: |
|
```javascript |
Cookies.getJSON('name'); // => { foo: 'bar' } |
``` |
|
```javascript |
Cookies.getJSON(); // => { name: { foo: 'bar' } } |
``` |
|
*Note: To support IE6-7 ([and IE 8 compatibility mode](http://stackoverflow.com/questions/4715373/json-object-undefined-in-internet-explorer-8)) you need to include the JSON-js polyfill: https://github.com/douglascrockford/JSON-js* |
|
## Encoding |
|
This project is [RFC 6265](http://tools.ietf.org/html/rfc6265#section-4.1.1) compliant. All special characters that are not allowed in the cookie-name or cookie-value are encoded with each one's UTF-8 Hex equivalent using [percent-encoding](http://en.wikipedia.org/wiki/Percent-encoding). |
The only character in cookie-name or cookie-value that is allowed and still encoded is the percent `%` character, it is escaped in order to interpret percent input as literal. |
Please note that the default encoding/decoding strategy is meant to be interoperable [only between cookies that are read/written by js-cookie](https://github.com/js-cookie/js-cookie/pull/200#discussion_r63270778). To override the default encoding/decoding strategy you need to use a [converter](#converter). |
|
## Cookie Attributes |
|
Cookie attributes defaults can be set globally by setting properties of the `Cookies.defaults` object or individually for each call to `Cookies.set(...)` by passing a plain object in the last argument. Per-call attributes override the default attributes. |
|
### expires |
|
Define when the cookie will be removed. Value can be a [`Number`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number) which will be interpreted as days from time of creation or a [`Date`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date) instance. If omitted, the cookie becomes a session cookie. |
|
To create a cookie that expires in less than a day, you can check the [FAQ on the Wiki](https://github.com/js-cookie/js-cookie/wiki/Frequently-Asked-Questions#expire-cookies-in-less-than-a-day). |
|
**Default:** Cookie is removed when the user closes the browser. |
|
**Examples:** |
|
```javascript |
Cookies.set('name', 'value', { expires: 365 }); |
Cookies.get('name'); // => 'value' |
Cookies.remove('name'); |
``` |
|
### path |
|
A [`String`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String) indicating the path where the cookie is visible. |
|
**Default:** `/` |
|
**Examples:** |
|
```javascript |
Cookies.set('name', 'value', { path: '' }); |
Cookies.get('name'); // => 'value' |
Cookies.remove('name', { path: '' }); |
``` |
|
**Note regarding Internet Explorer:** |
|
> Due to an obscure bug in the underlying WinINET InternetGetCookie implementation, IE’s document.cookie will not return a cookie if it was set with a path attribute containing a filename. |
|
(From [Internet Explorer Cookie Internals (FAQ)](http://blogs.msdn.com/b/ieinternals/archive/2009/08/20/wininet-ie-cookie-internals-faq.aspx)) |
|
This means one cannot set a path using `path: window.location.pathname` in case such pathname contains a filename like so: `/check.html` (or at least, such cookie cannot be read correctly). |
|
### domain |
|
A [`String`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String) indicating a valid domain where the cookie should be visible. The cookie will also be visible to all subdomains. |
|
**Default:** Cookie is visible only to the domain or subdomain of the page where the cookie was created, except for Internet Explorer (see below). |
|
**Examples:** |
|
Assuming a cookie that is being created on `site.com`: |
|
```javascript |
Cookies.set('name', 'value', { domain: 'subdomain.site.com' }); |
Cookies.get('name'); // => undefined (need to read at 'subdomain.site.com') |
``` |
|
**Note regarding Internet Explorer default behavior:** |
|
> Q3: If I don’t specify a DOMAIN attribute (for) a cookie, IE sends it to all nested subdomains anyway? |
> A: Yes, a cookie set on example.com will be sent to sub2.sub1.example.com. |
> Internet Explorer differs from other browsers in this regard. |
|
(From [Internet Explorer Cookie Internals (FAQ)](http://blogs.msdn.com/b/ieinternals/archive/2009/08/20/wininet-ie-cookie-internals-faq.aspx)) |
|
This means that if you omit the `domain` attribute, it will be visible for a subdomain in IE. |
|
### secure |
|
Either `true` or `false`, indicating if the cookie transmission requires a secure protocol (https). |
|
**Default:** No secure protocol requirement. |
|
**Examples:** |
|
```javascript |
Cookies.set('name', 'value', { secure: true }); |
Cookies.get('name'); // => 'value' |
Cookies.remove('name', { secure: true }); |
``` |
|
## Converters |
|
### Read |
|
Create a new instance of the api that overrides the default decoding implementation. |
All get methods that rely in a proper decoding to work, such as `Cookies.get()` and `Cookies.get('name')`, will run the converter first for each cookie. |
The returning String will be used as the cookie value. |
|
Example from reading one of the cookies that can only be decoded using the `escape` function: |
|
```javascript |
document.cookie = 'escaped=%u5317'; |
document.cookie = 'default=%E5%8C%97'; |
var cookies = Cookies.withConverter(function (value, name) { |
if ( name === 'escaped' ) { |
return unescape(value); |
} |
}); |
cookies.get('escaped'); // 北 |
cookies.get('default'); // 北 |
cookies.get(); // { escaped: '北', default: '北' } |
``` |
|
### Write |
|
Create a new instance of the api that overrides the default encoding implementation: |
|
```javascript |
Cookies.withConverter({ |
read: function (value, name) { |
// Read converter |
}, |
write: function (value, name) { |
// Write converter |
} |
}); |
``` |
|
## Server-side integration |
|
Check out the [Servers Docs](SERVER_SIDE.md) |
|
## Contributing |
|
Check out the [Contributing Guidelines](CONTRIBUTING.md) |
|
## Manual release steps |
|
* Increment the "version" attribute of `package.json` |
* Increment the version number in the `src/js.cookie.js` file |
* Commit with the message "Release version x.x.x" |
* Create version tag in git |
* Create a github release and upload the minified file |
* Change the `latest` tag pointer to the latest commit |
* `git tag -fa latest` |
* `git push <remote> :refs/tags/latest` |
* Commit with the message "Prepare for the next development iteration" |
* Release on npm |
|
## Authors |
|
* [Klaus Hartl](https://github.com/carhartl) |
* [Fagner Brack](https://github.com/FagnerMartinsBrack) |
* And awesome [contributors](https://github.com/js-cookie/js-cookie/graphs/contributors) |
/bower_components/js-cookie/SERVER_SIDE.md |
@@ -0,0 +1,107 @@ |
# Server-side integration |
|
There are some servers that are not compliant with the [RFC 6265](http://tools.ietf.org/html/rfc6265). For those, some characters that are not encoded by JavaScript Cookie might be treated differently. |
|
Here we document the most important server-side peculiarities and their workarounds. Feel free to send a [Pull Request](https://github.com/js-cookie/js-cookie/blob/master/CONTRIBUTING.md#pull-requests) if you see something that can be improved. |
|
*Disclaimer: This documentation is entirely based on community provided information. The examples below should be used only as a reference.* |
|
## PHP |
|
In PHP, `setcookie()` function encodes cookie values using `urlencode()` function, which applies `%`-encoding but also encodes spaces as `+` signs, [for historical reasons](http://php.net/manual/en/function.urlencode.php#function.urlencode). When cookies are read back via `$_COOKIE` or `filter_input(INPUT_COOKIE)`, they would go trough a decoding process which decodes `%`-encoded sequences and also converts `+` signs back to spaces. However, the plus (`+`) sign is valid cookie character by itself, which means that libraries that adhere to standards will interpret `+` signs differently to PHP. |
|
This presents two types of problems: |
|
1. PHP writes a cookie via `setcookie()` and all spaces get converted to `+` signs. JavaScript Cookie read `+` signs and uses them literally, since it is a valid cookie character. |
2. JavaScript Cookie writes a cookie with a value that contains `+` signs and stores it as is, since it is a valid cookie character. PHP read a cookie and converts `+` signs to spaces. |
|
To make both PHP and JavaScript Cookie play nicely together? |
|
**In PHP**, use `setrawcookie()` instead of `setcookie()`: |
|
```php |
setrawcookie($name, rawurlencode($value)); |
``` |
|
**In JavaScript**, use a custom converter. |
|
**Example**: |
|
```javascript |
var PHPCookies = Cookies.withConverter({ |
write: function (value) { |
// Encode all characters according to the "encodeURIComponent" spec |
return encodeURIComponent(value) |
// Revert the characters that are unnecessarly encoded but are |
// allowed in a cookie value, except for the plus sign (%2B) |
.replace(/%(23|24|26|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent); |
}, |
read: function (value) { |
return value |
// Decode the plus sign to spaces first, otherwise "legit" encoded pluses |
// will be replaced incorrectly |
.replace(/\+/g, ' ') |
// Decode all characters according to the "encodeURIComponent" spec |
.replace(/(%[0-9A-Z]{2})+/g, decodeURIComponent); |
} |
}); |
``` |
|
Rack seems to have [a similar problem](https://github.com/js-cookie/js-cookie/issues/70#issuecomment-132503017). |
|
## Tomcat |
|
### Version >= 7.x |
|
It seems that there is a situation where Tomcat does not [read the parens correctly](https://github.com/js-cookie/js-cookie/issues/92#issue-107743407). To fix this you need to write a custom write converter. |
|
**Example**: |
|
```javascript |
var TomcatCookies = Cookies.withConverter({ |
write: function (value) { |
// Encode all characters according to the "encodeURIComponent" spec |
return encodeURIComponent(value) |
// Revert the characters that are unnecessarly encoded but are |
// allowed in a cookie value |
.replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent) |
// Encode the parens that are interpreted incorrectly by Tomcat |
.replace(/[\(\)]/g, escape); |
} |
}); |
``` |
|
### Version >= 8.0.15 |
|
Since Tomcat 8.0.15, it is possible to configure RFC 6265 compliance by changing your `conf/context.xml` file and adding the new [CookieProcessor](https://tomcat.apache.org/tomcat-8.0-doc/config/cookie-processor.html) nested inside the Context element. It would be like this: |
|
```xml |
<Context> |
<CookieProcessor className="org.apache.tomcat.util.http.Rfc6265CookieProcessor"/> |
</context> |
``` |
And you're all done. |
|
Alternatively, you can check the [Java Cookie](https://github.com/js-cookie/java-cookie) project, which integrates nicely with JavaScript Cookie. |
|
## JBoss 7.1.1 |
|
It seems that the servlet implementation of JBoss 7.1.1 [does not read some characters correctly](https://github.com/js-cookie/js-cookie/issues/70#issuecomment-148944674), even though they are allowed as per [RFC 6265](https://tools.ietf.org/html/rfc6265#section-4.1.1). To fix this you need to write a custom converter to send those characters correctly. |
|
**Example**: |
|
```javascript |
var JBossCookies = Cookies.withConverter({ |
write: function (value) { |
// Encode all characters according to the "encodeURIComponent" spec |
return encodeURIComponent(value) |
// Revert the characters that are unnecessarly encoded but are |
// allowed in a cookie value |
.replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent) |
// Encode again the characters that are not allowed in JBoss 7.1.1, like "[" and "]": |
.replace(/[\[\]]/g, encodeURIComponent); |
} |
}); |
``` |
|
Alternatively, you can check the [Java Cookie](https://github.com/js-cookie/java-cookie) project, which integrates nicely with JavaScript Cookie. |
/bower_components/js-cookie/src/js.cookie.js |
@@ -0,0 +1,156 @@ |
/*! |
* JavaScript Cookie v2.1.3 |
* https://github.com/js-cookie/js-cookie |
* |
* Copyright 2006, 2015 Klaus Hartl & Fagner Brack |
* Released under the MIT license |
*/ |
;(function (factory) { |
var registeredInModuleLoader = false; |
if (typeof define === 'function' && define.amd) { |
define(factory); |
registeredInModuleLoader = true; |
} |
if (typeof exports === 'object') { |
module.exports = factory(); |
registeredInModuleLoader = true; |
} |
if (!registeredInModuleLoader) { |
var OldCookies = window.Cookies; |
var api = window.Cookies = factory(); |
api.noConflict = function () { |
window.Cookies = OldCookies; |
return api; |
}; |
} |
}(function () { |
function extend () { |
var i = 0; |
var result = {}; |
for (; i < arguments.length; i++) { |
var attributes = arguments[ i ]; |
for (var key in attributes) { |
result[key] = attributes[key]; |
} |
} |
return result; |
} |
|
function init (converter) { |
function api (key, value, attributes) { |
var result; |
if (typeof document === 'undefined') { |
return; |
} |
|
// Write |
|
if (arguments.length > 1) { |
attributes = extend({ |
path: '/' |
}, api.defaults, attributes); |
|
if (typeof attributes.expires === 'number') { |
var expires = new Date(); |
expires.setMilliseconds(expires.getMilliseconds() + attributes.expires * 864e+5); |
attributes.expires = expires; |
} |
|
try { |
result = JSON.stringify(value); |
if (/^[\{\[]/.test(result)) { |
value = result; |
} |
} catch (e) {} |
|
if (!converter.write) { |
value = encodeURIComponent(String(value)) |
.replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent); |
} else { |
value = converter.write(value, key); |
} |
|
key = encodeURIComponent(String(key)); |
key = key.replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent); |
key = key.replace(/[\(\)]/g, escape); |
|
return (document.cookie = [ |
key, '=', value, |
attributes.expires ? '; expires=' + attributes.expires.toUTCString() : '', // use expires attribute, max-age is not supported by IE |
attributes.path ? '; path=' + attributes.path : '', |
attributes.domain ? '; domain=' + attributes.domain : '', |
attributes.secure ? '; secure' : '' |
].join('')); |
} |
|
// Read |
|
if (!key) { |
result = {}; |
} |
|
// To prevent the for loop in the first place assign an empty array |
// in case there are no cookies at all. Also prevents odd result when |
// calling "get()" |
var cookies = document.cookie ? document.cookie.split('; ') : []; |
var rdecode = /(%[0-9A-Z]{2})+/g; |
var i = 0; |
|
for (; i < cookies.length; i++) { |
var parts = cookies[i].split('='); |
var cookie = parts.slice(1).join('='); |
|
if (cookie.charAt(0) === '"') { |
cookie = cookie.slice(1, -1); |
} |
|
try { |
var name = parts[0].replace(rdecode, decodeURIComponent); |
cookie = converter.read ? |
converter.read(cookie, name) : converter(cookie, name) || |
cookie.replace(rdecode, decodeURIComponent); |
|
if (this.json) { |
try { |
cookie = JSON.parse(cookie); |
} catch (e) {} |
} |
|
if (key === name) { |
result = cookie; |
break; |
} |
|
if (!key) { |
result[name] = cookie; |
} |
} catch (e) {} |
} |
|
return result; |
} |
|
api.set = api; |
api.get = function (key) { |
return api.call(api, key); |
}; |
api.getJSON = function () { |
return api.apply({ |
json: true |
}, [].slice.call(arguments)); |
}; |
api.defaults = {}; |
|
api.remove = function (key, attributes) { |
api(key, '', extend(attributes, { |
expires: -1 |
})); |
}; |
|
api.withConverter = init; |
|
return api; |
} |
|
return init(function () {}); |
})); |