diff options
Diffstat (limited to 'vendor/assets/javascripts/vue-resource.full.js')
| -rw-r--r-- | vendor/assets/javascripts/vue-resource.full.js | 1318 |
1 files changed, 1318 insertions, 0 deletions
diff --git a/vendor/assets/javascripts/vue-resource.full.js b/vendor/assets/javascripts/vue-resource.full.js new file mode 100644 index 00000000000..d7981dbec7e --- /dev/null +++ b/vendor/assets/javascripts/vue-resource.full.js @@ -0,0 +1,1318 @@ +/*! + * vue-resource v0.9.3 + * https://github.com/vuejs/vue-resource + * Released under the MIT License. + */ + +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : + typeof define === 'function' && define.amd ? define(factory) : + (global.VueResource = factory()); +}(this, function () { 'use strict'; + + /** + * Promises/A+ polyfill v1.1.4 (https://github.com/bramstein/promis) + */ + + var RESOLVED = 0; + var REJECTED = 1; + var PENDING = 2; + + function Promise$2(executor) { + + this.state = PENDING; + this.value = undefined; + this.deferred = []; + + var promise = this; + + try { + executor(function (x) { + promise.resolve(x); + }, function (r) { + promise.reject(r); + }); + } catch (e) { + promise.reject(e); + } + } + + Promise$2.reject = function (r) { + return new Promise$2(function (resolve, reject) { + reject(r); + }); + }; + + Promise$2.resolve = function (x) { + return new Promise$2(function (resolve, reject) { + resolve(x); + }); + }; + + Promise$2.all = function all(iterable) { + return new Promise$2(function (resolve, reject) { + var count = 0, + result = []; + + if (iterable.length === 0) { + resolve(result); + } + + function resolver(i) { + return function (x) { + result[i] = x; + count += 1; + + if (count === iterable.length) { + resolve(result); + } + }; + } + + for (var i = 0; i < iterable.length; i += 1) { + Promise$2.resolve(iterable[i]).then(resolver(i), reject); + } + }); + }; + + Promise$2.race = function race(iterable) { + return new Promise$2(function (resolve, reject) { + for (var i = 0; i < iterable.length; i += 1) { + Promise$2.resolve(iterable[i]).then(resolve, reject); + } + }); + }; + + var p$1 = Promise$2.prototype; + + p$1.resolve = function resolve(x) { + var promise = this; + + if (promise.state === PENDING) { + if (x === promise) { + throw new TypeError('Promise settled with itself.'); + } + + var called = false; + + try { + var then = x && x['then']; + + if (x !== null && typeof x === 'object' && typeof then === 'function') { + then.call(x, function (x) { + if (!called) { + promise.resolve(x); + } + called = true; + }, function (r) { + if (!called) { + promise.reject(r); + } + called = true; + }); + return; + } + } catch (e) { + if (!called) { + promise.reject(e); + } + return; + } + + promise.state = RESOLVED; + promise.value = x; + promise.notify(); + } + }; + + p$1.reject = function reject(reason) { + var promise = this; + + if (promise.state === PENDING) { + if (reason === promise) { + throw new TypeError('Promise settled with itself.'); + } + + promise.state = REJECTED; + promise.value = reason; + promise.notify(); + } + }; + + p$1.notify = function notify() { + var promise = this; + + nextTick(function () { + if (promise.state !== PENDING) { + while (promise.deferred.length) { + var deferred = promise.deferred.shift(), + onResolved = deferred[0], + onRejected = deferred[1], + resolve = deferred[2], + reject = deferred[3]; + + try { + if (promise.state === RESOLVED) { + if (typeof onResolved === 'function') { + resolve(onResolved.call(undefined, promise.value)); + } else { + resolve(promise.value); + } + } else if (promise.state === REJECTED) { + if (typeof onRejected === 'function') { + resolve(onRejected.call(undefined, promise.value)); + } else { + reject(promise.value); + } + } + } catch (e) { + reject(e); + } + } + } + }); + }; + + p$1.then = function then(onResolved, onRejected) { + var promise = this; + + return new Promise$2(function (resolve, reject) { + promise.deferred.push([onResolved, onRejected, resolve, reject]); + promise.notify(); + }); + }; + + p$1.catch = function (onRejected) { + return this.then(undefined, onRejected); + }; + + var PromiseObj = window.Promise || Promise$2; + + function Promise$1(executor, context) { + + if (executor instanceof PromiseObj) { + this.promise = executor; + } else { + this.promise = new PromiseObj(executor.bind(context)); + } + + this.context = context; + } + + Promise$1.all = function (iterable, context) { + return new Promise$1(PromiseObj.all(iterable), context); + }; + + Promise$1.resolve = function (value, context) { + return new Promise$1(PromiseObj.resolve(value), context); + }; + + Promise$1.reject = function (reason, context) { + return new Promise$1(PromiseObj.reject(reason), context); + }; + + Promise$1.race = function (iterable, context) { + return new Promise$1(PromiseObj.race(iterable), context); + }; + + var p = Promise$1.prototype; + + p.bind = function (context) { + this.context = context; + return this; + }; + + p.then = function (fulfilled, rejected) { + + if (fulfilled && fulfilled.bind && this.context) { + fulfilled = fulfilled.bind(this.context); + } + + if (rejected && rejected.bind && this.context) { + rejected = rejected.bind(this.context); + } + + return new Promise$1(this.promise.then(fulfilled, rejected), this.context); + }; + + p.catch = function (rejected) { + + if (rejected && rejected.bind && this.context) { + rejected = rejected.bind(this.context); + } + + return new Promise$1(this.promise.catch(rejected), this.context); + }; + + p.finally = function (callback) { + + return this.then(function (value) { + callback.call(this); + return value; + }, function (reason) { + callback.call(this); + return PromiseObj.reject(reason); + }); + }; + + var debug = false; + var util = {}; + var array = []; + function Util (Vue) { + util = Vue.util; + debug = Vue.config.debug || !Vue.config.silent; + } + + function warn(msg) { + if (typeof console !== 'undefined' && debug) { + console.warn('[VueResource warn]: ' + msg); + } + } + + function error(msg) { + if (typeof console !== 'undefined') { + console.error(msg); + } + } + + function nextTick(cb, ctx) { + return util.nextTick(cb, ctx); + } + + function trim(str) { + return str.replace(/^\s*|\s*$/g, ''); + } + + var isArray = Array.isArray; + + function isString(val) { + return typeof val === 'string'; + } + + function isBoolean(val) { + return val === true || val === false; + } + + function isFunction(val) { + return typeof val === 'function'; + } + + function isObject(obj) { + return obj !== null && typeof obj === 'object'; + } + + function isPlainObject(obj) { + return isObject(obj) && Object.getPrototypeOf(obj) == Object.prototype; + } + + function isFormData(obj) { + return typeof FormData !== 'undefined' && obj instanceof FormData; + } + + function when(value, fulfilled, rejected) { + + var promise = Promise$1.resolve(value); + + if (arguments.length < 2) { + return promise; + } + + return promise.then(fulfilled, rejected); + } + + function options(fn, obj, opts) { + + opts = opts || {}; + + if (isFunction(opts)) { + opts = opts.call(obj); + } + + return merge(fn.bind({ $vm: obj, $options: opts }), fn, { $options: opts }); + } + + function each(obj, iterator) { + + var i, key; + + if (typeof obj.length == 'number') { + for (i = 0; i < obj.length; i++) { + iterator.call(obj[i], obj[i], i); + } + } else if (isObject(obj)) { + for (key in obj) { + if (obj.hasOwnProperty(key)) { + iterator.call(obj[key], obj[key], key); + } + } + } + + return obj; + } + + var assign = Object.assign || _assign; + + function merge(target) { + + var args = array.slice.call(arguments, 1); + + args.forEach(function (source) { + _merge(target, source, true); + }); + + return target; + } + + function defaults(target) { + + var args = array.slice.call(arguments, 1); + + args.forEach(function (source) { + + for (var key in source) { + if (target[key] === undefined) { + target[key] = source[key]; + } + } + }); + + return target; + } + + function _assign(target) { + + var args = array.slice.call(arguments, 1); + + args.forEach(function (source) { + _merge(target, source); + }); + + return target; + } + + function _merge(target, source, deep) { + for (var key in source) { + if (deep && (isPlainObject(source[key]) || isArray(source[key]))) { + if (isPlainObject(source[key]) && !isPlainObject(target[key])) { + target[key] = {}; + } + if (isArray(source[key]) && !isArray(target[key])) { + target[key] = []; + } + _merge(target[key], source[key], deep); + } else if (source[key] !== undefined) { + target[key] = source[key]; + } + } + } + + function root (options, next) { + + var url = next(options); + + if (isString(options.root) && !url.match(/^(https?:)?\//)) { + url = options.root + '/' + url; + } + + return url; + } + + function query (options, next) { + + var urlParams = Object.keys(Url.options.params), + query = {}, + url = next(options); + + each(options.params, function (value, key) { + if (urlParams.indexOf(key) === -1) { + query[key] = value; + } + }); + + query = Url.params(query); + + if (query) { + url += (url.indexOf('?') == -1 ? '?' : '&') + query; + } + + return url; + } + + /** + * URL Template v2.0.6 (https://github.com/bramstein/url-template) + */ + + function expand(url, params, variables) { + + var tmpl = parse(url), + expanded = tmpl.expand(params); + + if (variables) { + variables.push.apply(variables, tmpl.vars); + } + + return expanded; + } + + function parse(template) { + + var operators = ['+', '#', '.', '/', ';', '?', '&'], + variables = []; + + return { + vars: variables, + expand: function (context) { + return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function (_, expression, literal) { + if (expression) { + + var operator = null, + values = []; + + if (operators.indexOf(expression.charAt(0)) !== -1) { + operator = expression.charAt(0); + expression = expression.substr(1); + } + + expression.split(/,/g).forEach(function (variable) { + var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable); + values.push.apply(values, getValues(context, operator, tmp[1], tmp[2] || tmp[3])); + variables.push(tmp[1]); + }); + + if (operator && operator !== '+') { + + var separator = ','; + + if (operator === '?') { + separator = '&'; + } else if (operator !== '#') { + separator = operator; + } + + return (values.length !== 0 ? operator : '') + values.join(separator); + } else { + return values.join(','); + } + } else { + return encodeReserved(literal); + } + }); + } + }; + } + + function getValues(context, operator, key, modifier) { + + var value = context[key], + result = []; + + if (isDefined(value) && value !== '') { + if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') { + value = value.toString(); + + if (modifier && modifier !== '*') { + value = value.substring(0, parseInt(modifier, 10)); + } + + result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : null)); + } else { + if (modifier === '*') { + if (Array.isArray(value)) { + value.filter(isDefined).forEach(function (value) { + result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : null)); + }); + } else { + Object.keys(value).forEach(function (k) { + if (isDefined(value[k])) { + result.push(encodeValue(operator, value[k], k)); + } + }); + } + } else { + var tmp = []; + + if (Array.isArray(value)) { + value.filter(isDefined).forEach(function (value) { + tmp.push(encodeValue(operator, value)); + }); + } else { + Object.keys(value).forEach(function (k) { + if (isDefined(value[k])) { + tmp.push(encodeURIComponent(k)); + tmp.push(encodeValue(operator, value[k].toString())); + } + }); + } + + if (isKeyOperator(operator)) { + result.push(encodeURIComponent(key) + '=' + tmp.join(',')); + } else if (tmp.length !== 0) { + result.push(tmp.join(',')); + } + } + } + } else { + if (operator === ';') { + result.push(encodeURIComponent(key)); + } else if (value === '' && (operator === '&' || operator === '?')) { + result.push(encodeURIComponent(key) + '='); + } else if (value === '') { + result.push(''); + } + } + + return result; + } + + function isDefined(value) { + return value !== undefined && value !== null; + } + + function isKeyOperator(operator) { + return operator === ';' || operator === '&' || operator === '?'; + } + + function encodeValue(operator, value, key) { + + value = operator === '+' || operator === '#' ? encodeReserved(value) : encodeURIComponent(value); + + if (key) { + return encodeURIComponent(key) + '=' + value; + } else { + return value; + } + } + + function encodeReserved(str) { + return str.split(/(%[0-9A-Fa-f]{2})/g).map(function (part) { + if (!/%[0-9A-Fa-f]/.test(part)) { + part = encodeURI(part); + } + return part; + }).join(''); + } + + function template (options) { + + var variables = [], + url = expand(options.url, options.params, variables); + + variables.forEach(function (key) { + delete options.params[key]; + }); + + return url; + } + + /** + * Service for URL templating. + */ + + var ie = document.documentMode; + var el = document.createElement('a'); + + function Url(url, params) { + + var self = this || {}, + options = url, + transform; + + if (isString(url)) { + options = { url: url, params: params }; + } + + options = merge({}, Url.options, self.$options, options); + + Url.transforms.forEach(function (handler) { + transform = factory(handler, transform, self.$vm); + }); + + return transform(options); + } + + /** + * Url options. + */ + + Url.options = { + url: '', + root: null, + params: {} + }; + + /** + * Url transforms. + */ + + Url.transforms = [template, query, root]; + + /** + * Encodes a Url parameter string. + * + * @param {Object} obj + */ + + Url.params = function (obj) { + + var params = [], + escape = encodeURIComponent; + + params.add = function (key, value) { + + if (isFunction(value)) { + value = value(); + } + + if (value === null) { + value = ''; + } + + this.push(escape(key) + '=' + escape(value)); + }; + + serialize(params, obj); + + return params.join('&').replace(/%20/g, '+'); + }; + + /** + * Parse a URL and return its components. + * + * @param {String} url + */ + + Url.parse = function (url) { + + if (ie) { + el.href = url; + url = el.href; + } + + el.href = url; + + return { + href: el.href, + protocol: el.protocol ? el.protocol.replace(/:$/, '') : '', + port: el.port, + host: el.host, + hostname: el.hostname, + pathname: el.pathname.charAt(0) === '/' ? el.pathname : '/' + el.pathname, + search: el.search ? el.search.replace(/^\?/, '') : '', + hash: el.hash ? el.hash.replace(/^#/, '') : '' + }; + }; + + function factory(handler, next, vm) { + return function (options) { + return handler.call(vm, options, next); + }; + } + + function serialize(params, obj, scope) { + + var array = isArray(obj), + plain = isPlainObject(obj), + hash; + + each(obj, function (value, key) { + + hash = isObject(value) || isArray(value); + + if (scope) { + key = scope + '[' + (plain || hash ? key : '') + ']'; + } + + if (!scope && array) { + params.add(value.name, value.value); + } else if (hash) { + serialize(params, value, key); + } else { + params.add(key, value); + } + }); + } + + function xdrClient (request) { + return new Promise$1(function (resolve) { + + var xdr = new XDomainRequest(), + handler = function (event) { + + var response = request.respondWith(xdr.responseText, { + status: xdr.status, + statusText: xdr.statusText + }); + + resolve(response); + }; + + request.abort = function () { + return xdr.abort(); + }; + + xdr.open(request.method, request.getUrl(), true); + xdr.timeout = 0; + xdr.onload = handler; + xdr.onerror = handler; + xdr.ontimeout = function () {}; + xdr.onprogress = function () {}; + xdr.send(request.getBody()); + }); + } + + var ORIGIN_URL = Url.parse(location.href); + var SUPPORTS_CORS = 'withCredentials' in new XMLHttpRequest(); + + function cors (request, next) { + + if (!isBoolean(request.crossOrigin) && crossOrigin(request)) { + request.crossOrigin = true; + } + + if (request.crossOrigin) { + + if (!SUPPORTS_CORS) { + request.client = xdrClient; + } + + delete request.emulateHTTP; + } + + next(); + } + + function crossOrigin(request) { + + var requestUrl = Url.parse(Url(request)); + + return requestUrl.protocol !== ORIGIN_URL.protocol || requestUrl.host !== ORIGIN_URL.host; + } + + function body (request, next) { + + if (request.emulateJSON && isPlainObject(request.body)) { + request.body = Url.params(request.body); + request.headers['Content-Type'] = 'application/x-www-form-urlencoded'; + } + + if (isFormData(request.body)) { + delete request.headers['Content-Type']; + } + + if (isPlainObject(request.body)) { + request.body = JSON.stringify(request.body); + } + + next(function (response) { + + var contentType = response.headers['Content-Type']; + + if (isString(contentType) && contentType.indexOf('application/json') === 0) { + + try { + response.data = response.json(); + } catch (e) { + response.data = null; + } + } else { + response.data = response.text(); + } + }); + } + + function jsonpClient (request) { + return new Promise$1(function (resolve) { + + var name = request.jsonp || 'callback', + callback = '_jsonp' + Math.random().toString(36).substr(2), + body = null, + handler, + script; + + handler = function (event) { + + var status = 0; + + if (event.type === 'load' && body !== null) { + status = 200; + } else if (event.type === 'error') { + status = 404; + } + + resolve(request.respondWith(body, { status: status })); + + delete window[callback]; + document.body.removeChild(script); + }; + + request.params[name] = callback; + + window[callback] = function (result) { + body = JSON.stringify(result); + }; + + script = document.createElement('script'); + script.src = request.getUrl(); + script.type = 'text/javascript'; + script.async = true; + script.onload = handler; + script.onerror = handler; + + document.body.appendChild(script); + }); + } + + function jsonp (request, next) { + + if (request.method == 'JSONP') { + request.client = jsonpClient; + } + + next(function (response) { + + if (request.method == 'JSONP') { + response.data = response.json(); + } + }); + } + + function before (request, next) { + + if (isFunction(request.before)) { + request.before.call(this, request); + } + + next(); + } + + /** + * HTTP method override Interceptor. + */ + + function method (request, next) { + + if (request.emulateHTTP && /^(PUT|PATCH|DELETE)$/i.test(request.method)) { + request.headers['X-HTTP-Method-Override'] = request.method; + request.method = 'POST'; + } + + next(); + } + + function header (request, next) { + + request.method = request.method.toUpperCase(); + request.headers = assign({}, Http.headers.common, !request.crossOrigin ? Http.headers.custom : {}, Http.headers[request.method.toLowerCase()], request.headers); + + next(); + } + + /** + * Timeout Interceptor. + */ + + function timeout (request, next) { + + var timeout; + + if (request.timeout) { + timeout = setTimeout(function () { + request.abort(); + }, request.timeout); + } + + next(function (response) { + + clearTimeout(timeout); + }); + } + + function xhrClient (request) { + return new Promise$1(function (resolve) { + + var xhr = new XMLHttpRequest(), + handler = function (event) { + + var response = request.respondWith('response' in xhr ? xhr.response : xhr.responseText, { + status: xhr.status === 1223 ? 204 : xhr.status, // IE9 status bug + statusText: xhr.status === 1223 ? 'No Content' : trim(xhr.statusText), + headers: parseHeaders(xhr.getAllResponseHeaders()) + }); + + resolve(response); + }; + + request.abort = function () { + return xhr.abort(); + }; + + xhr.open(request.method, request.getUrl(), true); + xhr.timeout = 0; + xhr.onload = handler; + xhr.onerror = handler; + + if (request.progress) { + if (request.method === 'GET') { + xhr.addEventListener('progress', request.progress); + } else if (/^(POST|PUT)$/i.test(request.method)) { + xhr.upload.addEventListener('progress', request.progress); + } + } + + if (request.credentials === true) { + xhr.withCredentials = true; + } + + each(request.headers || {}, function (value, header) { + xhr.setRequestHeader(header, value); + }); + + xhr.send(request.getBody()); + }); + } + + function parseHeaders(str) { + + var headers = {}, + value, + name, + i; + + each(trim(str).split('\n'), function (row) { + + i = row.indexOf(':'); + name = trim(row.slice(0, i)); + value = trim(row.slice(i + 1)); + + if (headers[name]) { + + if (isArray(headers[name])) { + headers[name].push(value); + } else { + headers[name] = [headers[name], value]; + } + } else { + + headers[name] = value; + } + }); + + return headers; + } + + function Client (context) { + + var reqHandlers = [sendRequest], + resHandlers = [], + handler; + + if (!isObject(context)) { + context = null; + } + + function Client(request) { + return new Promise$1(function (resolve) { + + function exec() { + + handler = reqHandlers.pop(); + + if (isFunction(handler)) { + handler.call(context, request, next); + } else { + warn('Invalid interceptor of type ' + typeof handler + ', must be a function'); + next(); + } + } + + function next(response) { + + if (isFunction(response)) { + + resHandlers.unshift(response); + } else if (isObject(response)) { + + resHandlers.forEach(function (handler) { + response = when(response, function (response) { + return handler.call(context, response) || response; + }); + }); + + when(response, resolve); + + return; + } + + exec(); + } + + exec(); + }, context); + } + + Client.use = function (handler) { + reqHandlers.push(handler); + }; + + return Client; + } + + function sendRequest(request, resolve) { + + var client = request.client || xhrClient; + + resolve(client(request)); + } + + var classCallCheck = function (instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + }; + + /** + * HTTP Response. + */ + + var Response = function () { + function Response(body, _ref) { + var url = _ref.url; + var headers = _ref.headers; + var status = _ref.status; + var statusText = _ref.statusText; + classCallCheck(this, Response); + + + this.url = url; + this.body = body; + this.headers = headers || {}; + this.status = status || 0; + this.statusText = statusText || ''; + this.ok = status >= 200 && status < 300; + } + + Response.prototype.text = function text() { + return this.body; + }; + + Response.prototype.blob = function blob() { + return new Blob([this.body]); + }; + + Response.prototype.json = function json() { + return JSON.parse(this.body); + }; + + return Response; + }(); + + var Request = function () { + function Request(options) { + classCallCheck(this, Request); + + + this.method = 'GET'; + this.body = null; + this.params = {}; + this.headers = {}; + + assign(this, options); + } + + Request.prototype.getUrl = function getUrl() { + return Url(this); + }; + + Request.prototype.getBody = function getBody() { + return this.body; + }; + + Request.prototype.respondWith = function respondWith(body, options) { + return new Response(body, assign(options || {}, { url: this.getUrl() })); + }; + + return Request; + }(); + + /** + * Service for sending network requests. + */ + + var CUSTOM_HEADERS = { 'X-Requested-With': 'XMLHttpRequest' }; + var COMMON_HEADERS = { 'Accept': 'application/json, text/plain, */*' }; + var JSON_CONTENT_TYPE = { 'Content-Type': 'application/json;charset=utf-8' }; + + function Http(options) { + + var self = this || {}, + client = Client(self.$vm); + + defaults(options || {}, self.$options, Http.options); + + Http.interceptors.forEach(function (handler) { + client.use(handler); + }); + + return client(new Request(options)).then(function (response) { + + return response.ok ? response : Promise$1.reject(response); + }, function (response) { + + if (response instanceof Error) { + error(response); + } + + return Promise$1.reject(response); + }); + } + + Http.options = {}; + + Http.headers = { + put: JSON_CONTENT_TYPE, + post: JSON_CONTENT_TYPE, + patch: JSON_CONTENT_TYPE, + delete: JSON_CONTENT_TYPE, + custom: CUSTOM_HEADERS, + common: COMMON_HEADERS + }; + + Http.interceptors = [before, timeout, method, body, jsonp, header, cors]; + + ['get', 'delete', 'head', 'jsonp'].forEach(function (method) { + + Http[method] = function (url, options) { + return this(assign(options || {}, { url: url, method: method })); + }; + }); + + ['post', 'put', 'patch'].forEach(function (method) { + + Http[method] = function (url, body, options) { + return this(assign(options || {}, { url: url, method: method, body: body })); + }; + }); + + function Resource(url, params, actions, options) { + + var self = this || {}, + resource = {}; + + actions = assign({}, Resource.actions, actions); + + each(actions, function (action, name) { + + action = merge({ url: url, params: params || {} }, options, action); + + resource[name] = function () { + return (self.$http || Http)(opts(action, arguments)); + }; + }); + + return resource; + } + + function opts(action, args) { + + var options = assign({}, action), + params = {}, + body; + + switch (args.length) { + + case 2: + + params = args[0]; + body = args[1]; + + break; + + case 1: + + if (/^(POST|PUT|PATCH)$/i.test(options.method)) { + body = args[0]; + } else { + params = args[0]; + } + + break; + + case 0: + + break; + + default: + + throw 'Expected up to 4 arguments [params, body], got ' + args.length + ' arguments'; + } + + options.body = body; + options.params = assign({}, options.params, params); + + return options; + } + + Resource.actions = { + + get: { method: 'GET' }, + save: { method: 'POST' }, + query: { method: 'GET' }, + update: { method: 'PUT' }, + remove: { method: 'DELETE' }, + delete: { method: 'DELETE' } + + }; + + function plugin(Vue) { + + if (plugin.installed) { + return; + } + + Util(Vue); + + Vue.url = Url; + Vue.http = Http; + Vue.resource = Resource; + Vue.Promise = Promise$1; + + Object.defineProperties(Vue.prototype, { + + $url: { + get: function () { + return options(Vue.url, this, this.$options.url); + } + }, + + $http: { + get: function () { + return options(Vue.http, this, this.$options.http); + } + }, + + $resource: { + get: function () { + return Vue.resource.bind(this); + } + }, + + $promise: { + get: function () { + var _this = this; + + return function (executor) { + return new Vue.Promise(executor, _this); + }; + } + } + + }); + } + + if (typeof window !== 'undefined' && window.Vue) { + window.Vue.use(plugin); + } + + return plugin; + +}));
\ No newline at end of file |