ngx-restangular
Version:
1,007 lines • 111 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: lib/ngx-restangular.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { Injectable, Inject, Injector, Optional } from '@angular/core';
import { assign } from 'core-js/features/object';
import { map, bind, union, values, pick, isEmpty, isFunction, isNumber, isUndefined, isArray, isObject, extend, each, every, omit, get, defaults, clone, includes } from 'lodash';
import { BehaviorSubject } from 'rxjs';
import { filter } from 'rxjs/operators';
import { RESTANGULAR } from './ngx-restangular.config';
import { RestangularHttp } from './ngx-restangular-http';
import { RestangularConfigurer } from './ngx-restangular-config.factory';
export class Restangular {
/**
* @param {?} configObj
* @param {?} injector
* @param {?} http
*/
constructor(configObj, injector, http) {
this.configObj = configObj;
this.injector = injector;
this.http = http;
this.provider = new providerConfig(http);
/** @type {?} */
const element = this.provider.$get();
assign(this, element);
this.setDefaultConfig();
}
/**
* @return {?}
*/
setDefaultConfig() {
if (!this.configObj || !isFunction(this.configObj.fn)) {
return;
}
/** @type {?} */
const arrDI = map(this.configObj.arrServices, (/**
* @param {?} services
* @return {?}
*/
(services) => {
return this.injector.get(services);
}));
this.configObj.fn(...[this.provider, ...arrDI]);
}
}
Restangular.decorators = [
{ type: Injectable }
];
/** @nocollapse */
Restangular.ctorParameters = () => [
{ type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [RESTANGULAR,] }] },
{ type: Injector },
{ type: RestangularHttp }
];
if (false) {
/** @type {?} */
Restangular.prototype.provider;
/** @type {?} */
Restangular.prototype.addElementTransformer;
/** @type {?} */
Restangular.prototype.extendCollection;
/** @type {?} */
Restangular.prototype.extendModel;
/** @type {?} */
Restangular.prototype.copy;
/** @type {?} */
Restangular.prototype.configuration;
/** @type {?} */
Restangular.prototype.service;
/** @type {?} */
Restangular.prototype.id;
/** @type {?} */
Restangular.prototype.route;
/** @type {?} */
Restangular.prototype.parentResource;
/** @type {?} */
Restangular.prototype.restangularCollection;
/** @type {?} */
Restangular.prototype.cannonicalId;
/** @type {?} */
Restangular.prototype.etag;
/** @type {?} */
Restangular.prototype.selfLink;
/** @type {?} */
Restangular.prototype.get;
/** @type {?} */
Restangular.prototype.getList;
/** @type {?} */
Restangular.prototype.put;
/** @type {?} */
Restangular.prototype.post;
/** @type {?} */
Restangular.prototype.remove;
/** @type {?} */
Restangular.prototype.head;
/** @type {?} */
Restangular.prototype.trace;
/** @type {?} */
Restangular.prototype.options;
/** @type {?} */
Restangular.prototype.patch;
/** @type {?} */
Restangular.prototype.getRestangularUrl;
/** @type {?} */
Restangular.prototype.getRequestedUrl;
/** @type {?} */
Restangular.prototype.putElement;
/** @type {?} */
Restangular.prototype.addRestangularMethod;
/** @type {?} */
Restangular.prototype.getParentList;
/** @type {?} */
Restangular.prototype.clone;
/** @type {?} */
Restangular.prototype.ids;
/** @type {?} */
Restangular.prototype.httpConfig;
/** @type {?} */
Restangular.prototype.reqParams;
/** @type {?} */
Restangular.prototype.one;
/** @type {?} */
Restangular.prototype.all;
/** @type {?} */
Restangular.prototype.several;
/** @type {?} */
Restangular.prototype.oneUrl;
/** @type {?} */
Restangular.prototype.allUrl;
/** @type {?} */
Restangular.prototype.customPUT;
/** @type {?} */
Restangular.prototype.customPATCH;
/** @type {?} */
Restangular.prototype.customPOST;
/** @type {?} */
Restangular.prototype.customDELETE;
/** @type {?} */
Restangular.prototype.customGET;
/** @type {?} */
Restangular.prototype.customGETLIST;
/** @type {?} */
Restangular.prototype.customOperation;
/** @type {?} */
Restangular.prototype.doPUT;
/** @type {?} */
Restangular.prototype.doPATCH;
/** @type {?} */
Restangular.prototype.doPOST;
/** @type {?} */
Restangular.prototype.doDELETE;
/** @type {?} */
Restangular.prototype.doGET;
/** @type {?} */
Restangular.prototype.doGETLIST;
/** @type {?} */
Restangular.prototype.fromServer;
/** @type {?} */
Restangular.prototype.withConfig;
/** @type {?} */
Restangular.prototype.withHttpConfig;
/** @type {?} */
Restangular.prototype.singleOne;
/** @type {?} */
Restangular.prototype.plain;
/** @type {?} */
Restangular.prototype.save;
/** @type {?} */
Restangular.prototype.restangularized;
/** @type {?} */
Restangular.prototype.restangularizeElement;
/** @type {?} */
Restangular.prototype.restangularizeCollection;
/** @type {?} */
Restangular.prototype.configObj;
/**
* @type {?}
* @private
*/
Restangular.prototype.injector;
/**
* @type {?}
* @private
*/
Restangular.prototype.http;
}
/**
* @param {?} $http
* @return {?}
*/
function providerConfig($http) {
/** @type {?} */
const globalConfiguration = {};
RestangularConfigurer(this, globalConfiguration);
this.$get = $get;
/**
* @return {?}
*/
function $get() {
/**
* @param {?} config
* @return {?}
*/
function createServiceForConfiguration(config) {
/** @type {?} */
const service = {};
/** @type {?} */
const urlHandler = new config.urlCreatorFactory[config.urlCreator]();
urlHandler.setConfig(config);
/**
* @param {?} parent
* @param {?} elem
* @param {?} route
* @param {?} reqParams
* @param {?} fromServer
* @return {?}
*/
function restangularizeBase(parent, elem, route, reqParams, fromServer) {
elem[config.restangularFields.route] = route;
elem[config.restangularFields.getRestangularUrl] = bind(urlHandler.fetchUrl, urlHandler, elem);
elem[config.restangularFields.getRequestedUrl] = bind(urlHandler.fetchRequestedUrl, urlHandler, elem);
elem[config.restangularFields.addRestangularMethod] = bind(addRestangularMethodFunction, elem);
elem[config.restangularFields.clone] = bind(copyRestangularizedElement, elem);
elem[config.restangularFields.reqParams] = isEmpty(reqParams) ? null : reqParams;
elem[config.restangularFields.withHttpConfig] = bind(withHttpConfig, elem);
elem[config.restangularFields.plain] = bind(stripRestangular, elem, elem);
// Tag element as restangularized
elem[config.restangularFields.restangularized] = true;
// RequestLess connection
elem[config.restangularFields.one] = bind(one, elem, elem);
elem[config.restangularFields.all] = bind(all, elem, elem);
elem[config.restangularFields.several] = bind(several, elem, elem);
elem[config.restangularFields.oneUrl] = bind(oneUrl, elem, elem);
elem[config.restangularFields.allUrl] = bind(allUrl, elem, elem);
elem[config.restangularFields.fromServer] = !!fromServer;
if (parent && config.shouldSaveParent(route)) {
/** @type {?} */
const parentId = config.getIdFromElem(parent);
/** @type {?} */
const parentUrl = config.getUrlFromElem(parent);
/** @type {?} */
const restangularFieldsForParent = union(values(pick(config.restangularFields, ['route', 'singleOne', 'parentResource'])), config.extraFields);
/** @type {?} */
const parentResource = pick(parent, restangularFieldsForParent);
if (config.isValidId(parentId)) {
config.setIdToElem(parentResource, parentId, route);
}
if (config.isValidId(parentUrl)) {
config.setUrlToElem(parentResource, parentUrl, route);
}
elem[config.restangularFields.parentResource] = parentResource;
}
else {
elem[config.restangularFields.parentResource] = null;
}
return elem;
}
/**
* @param {?} parent
* @param {?} route
* @param {?} id
* @param {?} singleOne
* @return {?}
*/
function one(parent, route, id, singleOne) {
/** @type {?} */
let error;
if (isNumber(route) || isNumber(parent)) {
error = 'You\'re creating a Restangular entity with the number ';
error += 'instead of the route or the parent. For example, you can\'t call .one(12).';
throw new Error(error);
}
if (isUndefined(route)) {
error = 'You\'re creating a Restangular entity either without the path. ';
error += 'For example you can\'t call .one(). Please check if your arguments are valid.';
throw new Error(error);
}
/** @type {?} */
const elem = {};
config.setIdToElem(elem, id, route);
config.setFieldToElem(config.restangularFields.singleOne, elem, singleOne);
return restangularizeElem(parent, elem, route, false);
}
/**
* @param {?} parent
* @param {?} route
* @return {?}
*/
function all(parent, route) {
return restangularizeCollection(parent, [], route, false);
}
/**
* @param {?} parent
* @param {?} route
* @return {?}
*/
function several(parent, route /*, ids */) {
/** @type {?} */
const collection = [];
collection[config.restangularFields.ids] = Array.prototype.splice.call(arguments, 2);
return restangularizeCollection(parent, collection, route, false);
}
/**
* @param {?} parent
* @param {?} route
* @param {?} url
* @return {?}
*/
function oneUrl(parent, route, url) {
if (!route) {
throw new Error('Route is mandatory when creating new Restangular objects.');
}
/** @type {?} */
const elem = {};
config.setUrlToElem(elem, url, route);
return restangularizeElem(parent, elem, route, false);
}
/**
* @param {?} parent
* @param {?} route
* @param {?} url
* @return {?}
*/
function allUrl(parent, route, url) {
if (!route) {
throw new Error('Route is mandatory when creating new Restangular objects.');
}
/** @type {?} */
const elem = {};
config.setUrlToElem(elem, url, route);
return restangularizeCollection(parent, elem, route, false);
}
// Promises
/**
* @param {?} subject
* @param {?} isCollection
* @param {?} valueToFill
* @return {?}
*/
function restangularizeResponse(subject, isCollection, valueToFill) {
return subject.pipe(filter((/**
* @param {?} res
* @return {?}
*/
res => !!res)));
}
/**
* @param {?} subject
* @param {?} response
* @param {?} data
* @param {?} filledValue
* @return {?}
*/
function resolvePromise(subject, response, data, filledValue) {
extend(filledValue, data);
// Trigger the full response interceptor.
if (config.fullResponse) {
subject.next(extend(response, {
data: data
}));
}
else {
subject.next(data);
}
subject.complete();
}
// Elements
/**
* @param {?} elem
* @return {?}
*/
function stripRestangular(elem) {
if (isArray(elem)) {
/** @type {?} */
const array = [];
each(elem, (/**
* @param {?} value
* @return {?}
*/
function (value) {
array.push(config.isRestangularized(value) ? stripRestangular(value) : value);
}));
return array;
}
else {
return omit(elem, values(omit(config.restangularFields, 'id')));
}
}
/**
* @param {?} elem
* @return {?}
*/
function addCustomOperation(elem) {
elem[config.restangularFields.customOperation] = bind(customFunction, elem);
/** @type {?} */
const requestMethods = { get: customFunction, delete: customFunction };
each(['put', 'patch', 'post'], (/**
* @param {?} name
* @return {?}
*/
function (name) {
requestMethods[name] = (/**
* @param {?} operation
* @param {?} element
* @param {?} path
* @param {?} params
* @param {?} headers
* @return {?}
*/
function (operation, element, path, params, headers) {
return bind(customFunction, this)(operation, path, params, headers, element);
});
}));
each(requestMethods, (/**
* @param {?} requestFunc
* @param {?} name
* @return {?}
*/
function (requestFunc, name) {
/** @type {?} */
const callOperation = name === 'delete' ? 'remove' : name;
each(['do', 'custom'], (/**
* @param {?} alias
* @return {?}
*/
function (alias) {
elem[alias + name.toUpperCase()] = bind(requestFunc, elem, callOperation);
}));
}));
elem[config.restangularFields.customGETLIST] = bind(fetchFunction, elem);
elem[config.restangularFields.doGETLIST] = elem[config.restangularFields.customGETLIST];
}
/**
* @param {?} fromElement
* @param {?=} toElement
* @return {?}
*/
function copyRestangularizedElement(fromElement, toElement = {}) {
/** @type {?} */
const copiedElement = assign(toElement, fromElement);
return restangularizeElem(copiedElement[config.restangularFields.parentResource], copiedElement, copiedElement[config.restangularFields.route], true);
}
/**
* @param {?} parent
* @param {?} element
* @param {?} route
* @param {?=} fromServer
* @param {?=} collection
* @param {?=} reqParams
* @return {?}
*/
function restangularizeElem(parent, element, route, fromServer, collection, reqParams) {
/** @type {?} */
const elem = config.onBeforeElemRestangularized(element, false, route);
/** @type {?} */
const localElem = restangularizeBase(parent, elem, route, reqParams, fromServer);
if (config.useCannonicalId) {
localElem[config.restangularFields.cannonicalId] = config.getIdFromElem(localElem);
}
if (collection) {
localElem[config.restangularFields.getParentList] = (/**
* @return {?}
*/
function () {
return collection;
});
}
localElem[config.restangularFields.restangularCollection] = false;
localElem[config.restangularFields.get] = bind(getFunction, localElem);
localElem[config.restangularFields.getList] = bind(fetchFunction, localElem);
localElem[config.restangularFields.put] = bind(putFunction, localElem);
localElem[config.restangularFields.post] = bind(postFunction, localElem);
localElem[config.restangularFields.remove] = bind(deleteFunction, localElem);
localElem[config.restangularFields.head] = bind(headFunction, localElem);
localElem[config.restangularFields.trace] = bind(traceFunction, localElem);
localElem[config.restangularFields.options] = bind(optionsFunction, localElem);
localElem[config.restangularFields.patch] = bind(patchFunction, localElem);
localElem[config.restangularFields.save] = bind(save, localElem);
addCustomOperation(localElem);
return config.transformElem(localElem, false, route, service, true);
}
/**
* @param {?} parent
* @param {?} element
* @param {?} route
* @param {?=} fromServer
* @param {?=} reqParams
* @return {?}
*/
function restangularizeCollection(parent, element, route, fromServer, reqParams) {
/** @type {?} */
const elem = config.onBeforeElemRestangularized(element, true, route);
/** @type {?} */
const localElem = restangularizeBase(parent, elem, route, reqParams, fromServer);
localElem[config.restangularFields.restangularCollection] = true;
localElem[config.restangularFields.post] = bind(postFunction, localElem, null);
localElem[config.restangularFields.remove] = bind(deleteFunction, localElem);
localElem[config.restangularFields.head] = bind(headFunction, localElem);
localElem[config.restangularFields.trace] = bind(traceFunction, localElem);
localElem[config.restangularFields.putElement] = bind(putElementFunction, localElem);
localElem[config.restangularFields.options] = bind(optionsFunction, localElem);
localElem[config.restangularFields.patch] = bind(patchFunction, localElem);
localElem[config.restangularFields.get] = bind(getById, localElem);
localElem[config.restangularFields.getList] = bind(fetchFunction, localElem, null);
addCustomOperation(localElem);
return config.transformElem(localElem, true, route, service, true);
}
/**
* @param {?} parent
* @param {?} element
* @param {?} route
* @return {?}
*/
function restangularizeCollectionAndElements(parent, element, route) {
/** @type {?} */
const collection = restangularizeCollection(parent, element, route, false);
each(collection, (/**
* @param {?} elem
* @return {?}
*/
function (elem) {
if (elem) {
restangularizeElem(parent, elem, route, false);
}
}));
return collection;
}
/**
* @param {?} id
* @param {?} reqParams
* @param {?} headers
* @return {?}
*/
function getById(id, reqParams, headers) {
return this.customGET(id.toString(), reqParams, headers);
}
/**
* @param {?} idx
* @param {?} params
* @param {?} headers
* @return {?}
*/
function putElementFunction(idx, params, headers) {
/** @type {?} */
const __this = this;
/** @type {?} */
const elemToPut = this[idx];
/** @type {?} */
const subject = new BehaviorSubject(null);
/** @type {?} */
let filledArray = [];
filledArray = config.transformElem(filledArray, true, elemToPut[config.restangularFields.route], service);
elemToPut.put(params, headers)
.subscribe((/**
* @param {?} serverElem
* @return {?}
*/
function (serverElem) {
/** @type {?} */
const newArray = copyRestangularizedElement(__this);
newArray[idx] = serverElem;
filledArray = newArray;
subject.next(newArray);
}), (/**
* @param {?} response
* @return {?}
*/
function (response) {
subject.error(response);
}), (/**
* @return {?}
*/
function () {
subject.complete();
}));
return restangularizeResponse(subject, true, filledArray);
}
/**
* @param {?} resData
* @param {?} operation
* @param {?} route
* @param {?} fetchUrl
* @param {?} response
* @param {?} subject
* @return {?}
*/
function parseResponse(resData, operation, route, fetchUrl, response, subject) {
/** @type {?} */
const data = config.responseExtractor(resData, operation, route, fetchUrl, response, subject);
/** @type {?} */
const etag = response.headers.get('ETag');
if (data && etag) {
data[config.restangularFields.etag] = etag;
}
return data;
}
/**
* @param {?} what
* @param {?} reqParams
* @param {?} headers
* @return {?}
*/
function fetchFunction(what, reqParams, headers) {
/** @type {?} */
const __this = this;
/** @type {?} */
const subject = new BehaviorSubject(null);
/** @type {?} */
const operation = 'getList';
/** @type {?} */
const url = urlHandler.fetchUrl(this, what);
/** @type {?} */
const whatFetched = what || __this[config.restangularFields.route];
/** @type {?} */
const request = config.fullRequestInterceptor(null, operation, whatFetched, url, headers || {}, reqParams || {}, this[config.restangularFields.httpConfig] || {});
/** @type {?} */
let filledArray = [];
filledArray = config.transformElem(filledArray, true, whatFetched, service);
/** @type {?} */
let method = 'getList';
if (config.jsonp) {
method = 'jsonp';
}
/** @type {?} */
const okCallback = (/**
* @param {?} response
* @return {?}
*/
function (response) {
/** @type {?} */
const resData = response.body;
/** @type {?} */
const fullParams = response.config.params;
/** @type {?} */
let data = parseResponse(resData, operation, whatFetched, url, response, subject);
// support empty response for getList() calls (some APIs respond with 204 and empty body)
if (isUndefined(data) || '' === data) {
data = [];
}
if (!isArray(data)) {
throw new Error('Response for getList SHOULD be an array and not an object or something else');
}
if (true === config.plainByDefault) {
return resolvePromise(subject, response, data, filledArray);
}
/** @type {?} */
let processedData = map(data, (/**
* @param {?} elem
* @return {?}
*/
function (elem) {
if (!__this[config.restangularFields.restangularCollection]) {
return restangularizeElem(__this, elem, what, true, data);
}
else {
return restangularizeElem(__this[config.restangularFields.parentResource], elem, __this[config.restangularFields.route], true, data);
}
}));
processedData = extend(data, processedData);
if (!__this[config.restangularFields.restangularCollection]) {
resolvePromise(subject, response, restangularizeCollection(__this, processedData, what, true, fullParams), filledArray);
}
else {
resolvePromise(subject, response, restangularizeCollection(__this[config.restangularFields.parentResource], processedData, __this[config.restangularFields.route], true, fullParams), filledArray);
}
});
urlHandler.resource(this, $http, request.httpConfig, request.headers, request.params, what, this[config.restangularFields.etag], operation)[method]()
.subscribe(okCallback, (/**
* @param {?} response
* @return {?}
*/
function error(response) {
if (response.status === 304 && __this[config.restangularFields.restangularCollection]) {
resolvePromise(subject, response, __this, filledArray);
}
else if (every(config.errorInterceptors, (/**
* @param {?} cb
* @return {?}
*/
function (cb) {
return cb(response, subject, okCallback) !== false;
}))) {
// triggered if no callback returns false
subject.error(response);
}
}));
return restangularizeResponse(subject, true, filledArray);
}
/**
* @param {?} httpConfig
* @return {?}
*/
function withHttpConfig(httpConfig) {
this[config.restangularFields.httpConfig] = httpConfig;
return this;
}
/**
* @param {?} params
* @param {?} headers
* @return {?}
*/
function save(params, headers) {
if (this[config.restangularFields.fromServer]) {
return this[config.restangularFields.put](params, headers);
}
else {
return bind(elemFunction, this)('post', undefined, params, undefined, headers);
}
}
/**
* @param {?} operation
* @param {?} what
* @param {?} params
* @param {?} obj
* @param {?} headers
* @return {?}
*/
function elemFunction(operation, what, params, obj, headers) {
/** @type {?} */
const __this = this;
/** @type {?} */
const subject = new BehaviorSubject(null);
/** @type {?} */
const resParams = params || {};
/** @type {?} */
const route = what || this[config.restangularFields.route];
/** @type {?} */
const fetchUrl = urlHandler.fetchUrl(this, what);
/** @type {?} */
let callObj = obj || this;
// fallback to etag on restangular object (since for custom methods we probably don't explicitly specify the etag field)
/** @type {?} */
const etag = callObj[config.restangularFields.etag] || (operation !== 'post' ? this[config.restangularFields.etag] : null);
if (isObject(callObj) && config.isRestangularized(callObj)) {
callObj = stripRestangular(callObj);
}
/** @type {?} */
const request = config.fullRequestInterceptor(callObj, operation, route, fetchUrl, headers || {}, resParams || {}, this[config.restangularFields.httpConfig] || {});
/** @type {?} */
let filledObject = {};
filledObject = config.transformElem(filledObject, false, route, service);
/** @type {?} */
const okCallback = (/**
* @param {?} response
* @return {?}
*/
function (response) {
/** @type {?} */
const resData = get(response, 'body');
/** @type {?} */
const fullParams = get(response, 'config.params');
/** @type {?} */
const elem = parseResponse(resData, operation, route, fetchUrl, response, subject);
if (elem) {
/** @type {?} */
let data;
if (true === config.plainByDefault) {
return resolvePromise(subject, response, elem, filledObject);
}
if (operation === 'post' && !__this[config.restangularFields.restangularCollection]) {
data = restangularizeElem(__this[config.restangularFields.parentResource], elem, route, true, null, fullParams);
resolvePromise(subject, response, data, filledObject);
}
else {
data = restangularizeElem(__this[config.restangularFields.parentResource], elem, __this[config.restangularFields.route], true, null, fullParams);
data[config.restangularFields.singleOne] = __this[config.restangularFields.singleOne];
resolvePromise(subject, response, data, filledObject);
}
}
else {
resolvePromise(subject, response, undefined, filledObject);
}
});
/** @type {?} */
const errorCallback = (/**
* @param {?} response
* @return {?}
*/
function (response) {
if (response.status === 304 && config.isSafe(operation)) {
resolvePromise(subject, response, __this, filledObject);
}
else if (every(config.errorInterceptors, (/**
* @param {?} cb
* @return {?}
*/
function (cb) {
return cb(response, subject, okCallback) !== false;
}))) {
// triggered if no callback returns false
subject.error(response);
}
});
// Overriding HTTP Method
/** @type {?} */
let callOperation = operation;
/** @type {?} */
let callHeaders = extend({}, request.headers);
/** @type {?} */
const isOverrideOperation = config.isOverridenMethod(operation);
if (isOverrideOperation) {
callOperation = 'post';
callHeaders = extend(callHeaders, { 'X-HTTP-Method-Override': operation === 'remove' ? 'DELETE' : operation.toUpperCase() });
}
else if (config.jsonp && callOperation === 'get') {
callOperation = 'jsonp';
}
if (config.isSafe(operation)) {
if (isOverrideOperation) {
urlHandler.resource(this, $http, request.httpConfig, callHeaders, request.params, what, etag, callOperation)[callOperation]({}).subscribe(okCallback, errorCallback);
}
else {
urlHandler.resource(this, $http, request.httpConfig, callHeaders, request.params, what, etag, callOperation)[callOperation]().subscribe(okCallback, errorCallback);
}
}
else {
urlHandler.resource(this, $http, request.httpConfig, callHeaders, request.params, what, etag, callOperation)[callOperation](request.element).subscribe(okCallback, errorCallback);
}
return restangularizeResponse(subject, false, filledObject);
}
/**
* @param {?} params
* @param {?} headers
* @return {?}
*/
function getFunction(params, headers) {
return bind(elemFunction, this)('get', undefined, params, undefined, headers);
}
/**
* @param {?} params
* @param {?} headers
* @return {?}
*/
function deleteFunction(params, headers) {
return bind(elemFunction, this)('remove', undefined, params, undefined, headers);
}
/**
* @param {?} params
* @param {?} headers
* @return {?}
*/
function putFunction(params, headers) {
return bind(elemFunction, this)('put', undefined, params, undefined, headers);
}
/**
* @param {?} what
* @param {?} elem
* @param {?} params
* @param {?} headers
* @return {?}
*/
function postFunction(what, elem, params, headers) {
return bind(elemFunction, this)('post', what, params, elem, headers);
}
/**
* @param {?} params
* @param {?} headers
* @return {?}
*/
function headFunction(params, headers) {
return bind(elemFunction, this)('head', undefined, params, undefined, headers);
}
/**
* @param {?} params
* @param {?} headers
* @return {?}
*/
function traceFunction(params, headers) {
return bind(elemFunction, this)('trace', undefined, params, undefined, headers);
}
/**
* @param {?} params
* @param {?} headers
* @return {?}
*/
function optionsFunction(params, headers) {
return bind(elemFunction, this)('options', undefined, params, undefined, headers);
}
/**
* @param {?} elem
* @param {?} params
* @param {?} headers
* @return {?}
*/
function patchFunction(elem, params, headers) {
return bind(elemFunction, this)('patch', undefined, params, elem, headers);
}
/**
* @param {?} operation
* @param {?} path
* @param {?} params
* @param {?} headers
* @param {?} elem
* @return {?}
*/
function customFunction(operation, path, params, headers, elem) {
return bind(elemFunction, this)(operation, path, params, elem, headers);
}
/**
* @param {?} name
* @param {?} operation
* @param {?} path
* @param {?} defaultParams
* @param {?} defaultHeaders
* @param {?} defaultElem
* @return {?}
*/
function addRestangularMethodFunction(name, operation, path, defaultParams, defaultHeaders, defaultElem) {
/** @type {?} */
let bindedFunction;
if (operation === 'getList') {
bindedFunction = bind(fetchFunction, this, path);
}
else {
bindedFunction = bind(customFunction, this, operation, path);
}
/** @type {?} */
const createdFunction = (/**
* @param {?} params
* @param {?} headers
* @param {?} elem
* @return {?}
*/
function (params, headers, elem) {
/** @type {?} */
const callParams = defaults({
params: params,
headers: headers,
elem: elem
}, {
params: defaultParams,
headers: defaultHeaders,
elem: defaultElem
});
return bindedFunction(callParams.params, callParams.headers, callParams.elem);
});
if (config.isSafe(operation)) {
this[name] = createdFunction;
}
else {
this[name] = (/**
* @param {?} elem
* @param {?} params
* @param {?} headers
* @return {?}
*/
function (elem, params, headers) {
return createdFunction(params, headers, elem);
});
}
}
/**
* @param {?} configurer
* @return {?}
*/
function withConfigurationFunction(configurer) {
/** @type {?} */
const newConfig = clone(omit(config, 'configuration'));
RestangularConfigurer(newConfig, newConfig);
configurer(newConfig);
return createServiceForConfiguration(newConfig);
}
/**
* @param {?} route
* @param {?} parent
* @return {?}
*/
function toService(route, parent) {
/** @type {?} */
const knownCollectionMethods = values(config.restangularFields);
/** @type {?} */
const serv = {};
/** @type {?} */
const collection = (parent || service).all(route);
serv.one = bind(one, (parent || service), parent, route);
serv.all = bind(collection.all, collection);
serv.post = bind(collection.post, collection);
serv.getList = bind(collection.getList, collection);
serv.withHttpConfig = bind(collection.withHttpConfig, collection);
serv.get = bind(collection.get, collection);
for (const prop in collection) {
if (collection.hasOwnProperty(prop) && isFunction(collection[prop]) && !includes(knownCollectionMethods, prop)) {
serv[prop] = bind(collection[prop], collection);
}
}
return serv;
}
RestangularConfigurer(service, config);
service.copy = bind(copyRestangularizedElement, service);
service.service = bind(toService, service);
service.withConfig = bind(withConfigurationFunction, service);
service.one = bind(one, service, null);
service.all = bind(all, service, null);
service.several = bind(several, service, null);
service.oneUrl = bind(oneUrl, service, null);
service.allUrl = bind(allUrl, service, null);
service.stripRestangular = bind(stripRestangular, service);
service.restangularizeElement = bind(restangularizeElem, service);
service.restangularizeCollection = bind(restangularizeCollectionAndElements, service);
return service;
}
return createServiceForConfiguration(globalConfiguration);
}
}
//# sourceMappingURL=data:application/json;base64,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