laravel-request 1.0.0

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "laravel-request",
+  "productName": "laravel-request",
+  "version": "1.0.0",
+  "description": "laravel-request",
+  "main": "src/index.js",
+  "scripts": {},
+  "keywords": [],
+  "author": {
+    "name": "Abramov Oleg",
+    "email": "olegstan1@gmail.com"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.3.2"
+  }
+}

package/readme.md

@@ -0,0 +1,34 @@
+Usage get data
+
+```
+Api.get('active-trade', 'index')
+      .where('active_id', 115)
+      .with('currency')
+      .with('to_account', 'to_account.currency')
+      .with('from_account', 'from_account.currency')
+      .orderBy('trade_at', 'DESC')
+      .all((response) => {
+        
+      })
+      .bind(this, 'trades')
+}}     
+```
+    
+You can use
+
+all or first or paginate
+
+usage POST data
+
+```
+Api.post('active', 'store', {
+      user_id: this.props.client.id,
+      type: 2,
+      type_id: item.type_id
+    })
+      .call((response) => {
+        //success
+      }, (response) => {
+        //error
+      });
+```

package/src/Api.js

@@ -0,0 +1,171 @@
+import ApiRequest from "./ApiRequest";
+import $ from 'jquery';
+
+export default class Api {
+  /**
+   *
+   * @param target
+   * @param focus
+   * @param data
+   * @param method
+   * @return {ApiRequest}
+   */
+  static create(target, focus, data = {}, method = 'GET') {
+    return new ApiRequest(target, focus, data, method);
+  }
+
+  /**
+   *
+   * @param target
+   * @param focus
+   * @param arg
+   * @param data
+   * @param method
+   * @return {ApiRequest}
+   */
+  static createArg(target, focus, arg, data = {}, method = 'GET') {
+    return new ApiRequest(target, focus, data, method).addArg(arg);
+  }
+
+  /**
+   *
+   * @param target
+   * @param focus
+   * @param arg
+   * @param data
+   * @return {ApiRequest}
+   */
+  static getArg(target, focus, arg, data = {}) {
+    return Api.get(target, focus, data).addArg(arg);
+  }
+
+  /**
+   *
+   * @param target
+   * @param focus
+   * @param arg
+   * @param data
+   * @return {ApiRequest}
+   */
+  static postArg(target, focus, arg, data = {}) {
+    return Api.post(target, focus, data).addArg(arg);
+  }
+
+  /**
+   *
+   * @param target
+   * @param focus
+   * @param arg
+   * @param data
+   * @return {ApiRequest}
+   */
+  static putArg(target, focus, arg, data = {}) {
+    return Api.put(target, focus, data).addArg(arg);
+  }
+
+  /**
+   *
+   * @param url
+   * @param data
+   * @return {ApiRequest}
+   */
+  static getUrl(url, data = {})
+  {
+    return (new ApiRequest('', '', data, 'GET')).setUrl(url);
+  }
+
+  /**
+   *
+   * @param url
+   * @param data
+   * @return {ApiRequest}
+   */
+  static postUrl(url, data = {})
+  {
+    return (new ApiRequest('', '', data, 'POST')).setUrl(url);
+  }
+
+  /**
+   *
+   * @param url
+   * @param data
+   * @return {ApiRequest}
+   */
+  static putUrl(url, data = {})
+  {
+    return (new ApiRequest('', '', data, 'PUT')).setUrl(url);
+  }
+
+  /**
+   *
+   * @param target
+   * @param focus
+   * @param data
+   * @returns {ApiRequest}
+   */
+  static get(target, focus, data = {}) {
+    return new ApiRequest(target, focus, data, 'GET');
+  }
+  /**
+   *
+   * @param target
+   * @param focus
+   * @param data
+   * @returns {ApiRequest}
+   */
+  static post(target, focus, data = {}) {
+    return new ApiRequest(target, focus, data, 'POST');
+  }
+  /**
+   *
+   * @param target
+   * @param focus
+   * @param data
+   * @returns {ApiRequest}
+   */
+  static put(target, focus, data = {}) {
+    return new ApiRequest(target, focus, data, 'PUT');
+  }
+
+  /**
+   *
+   * @param target
+   * @param focus
+   * @param id
+   * @param data
+   * @return {ApiRequest}
+   */
+  static delete(target, focus, id, data = {}) {
+    return new ApiRequest(target, focus, data, 'DELETE').addArg(id);
+  }
+
+  static makeRequest(obj) {
+    obj.xhrFields = {withCredentials: true};
+
+    if (typeof obj["data"] === 'undefined') {
+      obj["data"] = {};
+    }
+    if (typeof obj["headers"] === 'undefined') {
+      obj["headers"] = {};
+    }
+
+
+    let api_token = localStorage.getItem('api_token');
+
+    if (api_token)
+    {
+      obj["headers"]["Authorization"] = api_token;
+    }
+
+    let one_time_token = localStorage.getItem('token');
+
+    if (one_time_token)
+    {
+      obj["data"]['token'] = one_time_token;
+    }
+
+    // obj["data"]['debug'] = true;
+
+    return $.ajax(obj)
+  }
+}

package/src/ApiProxy.js

@@ -0,0 +1,6 @@
+import Api from "#app/helpers/api/Api";
+
+export default class ApiProxy extends Api
+{
+
+}

package/src/ApiRequest.js

@@ -0,0 +1,394 @@
+import Builder from "./Builder";
+import Binding from "./Binding";
+import Api from "./Api";
+import NotifyManager from "../../interface/notify/NotifyManager";
+
+/**
+ *
+ */
+export default class ApiRequest {
+  /**
+   *
+   * @type {string}
+   */
+  url = '';
+
+  /**
+   *
+   * @type {XMLHttpRequest|null}
+   */
+  xhr = null;
+
+  /**
+   *
+   * @param target
+   * @param focus
+   * @param data
+   * @param method
+   */
+  constructor(target, focus, data = {}, method = 'GET') {
+    let self = this;
+    this.domain = process.env.REACT_APP_API_URL;
+    this.target = target;
+    this.focus = focus;
+    this.method = method;
+    this.data = data;
+    this.arguments = [];
+    this.builder = new Builder();
+    this.notifyCallback = (status) => {return true};
+    this.responseBinding = null;
+    this.responseBindingErrors = null;
+
+    this.callSuccess = () => {
+
+    };
+    this.callError = () => {
+
+    };
+
+    Builder.availableMethod.map(function (val) {
+      self[val] = function () {
+        self.builder.add(val, Array.prototype.slice.call(arguments));
+        return self;
+      }
+
+      return;
+    });
+  }
+
+  setUrl(url)
+  {
+    this.url = url;
+
+    return this;
+  }
+
+  setDomain(domain)
+  {
+    this.domain = domain;
+
+    return this;
+  }
+
+  /**
+   *
+   * @param arg
+   * @returns {ApiRequest}
+   */
+  addArg(arg) {
+    if (Array.isArray(arg)) {
+      this.arguments = this.arguments.concat(arg);
+    } else {
+      this.arguments.push(arg);
+    }
+    return this;
+  }
+
+  /**
+   *
+   * @param successCallback
+   * @param errorCallback
+   * @returns {*}
+   */
+  first(successCallback = (r) => {
+  }, errorCallback = () => {
+  }) {
+    this.data['paginateType'] = 'first';
+    return this.call(successCallback, errorCallback);
+  }
+
+  /**
+   *
+   * @param successCallback
+   * @param errorCallback
+   * @returns {*}
+   */
+  all(successCallback = (r) => {
+  }, errorCallback = () => {
+  }) {
+    this.data['paginateType'] = 'all';
+    return this.call(successCallback, errorCallback);
+  }
+
+  /**
+   *
+   * @param page
+   * @param perPage
+   * @param successCallback
+   * @param errorCallback
+   * @returns {*}
+   */
+  paginate(page = 1, perPage = 10, successCallback = (r) => {
+  }, errorCallback = () => {
+  }) {
+    this.data['paginateType'] = 'paginate';
+    this.data['page'] = page;
+    this.data['perPage'] = perPage;
+    return this.call(successCallback, errorCallback);
+  }
+
+  getUrl()
+  {
+    return this.domain + '/api/v1/call/' + this.target + '/' + this.focus;
+  }
+
+  /**
+   *
+   * @param successCallback
+   * @param errorCallback
+   * @param params
+   * @param dataKey
+   * @param argumentsKey
+   * @param queryKey
+   * @return {ApiRequest}
+   */
+  call(successCallback = (r) => {
+  }, errorCallback = () => {
+  }, params = {}, dataKey = 'data', argumentsKey = 'arguments', queryKey = 'query') {
+    let self = this;
+    this.callSuccess = successCallback;
+    this.callError = errorCallback;
+
+    let notify = null;
+
+    let data = {};
+
+    if(argumentsKey)
+    {
+      data[argumentsKey] = this.arguments;
+    }
+
+    if(queryKey)
+    {
+      data[queryKey] = this.builder.toArray();
+    }
+
+    if(dataKey)
+    {
+      data[dataKey] = this.data;
+    }else{
+      data = this.data;
+    }
+
+
+    this.xhr = Api.makeRequest({
+      url: this.domain + '/api/v1/call/' + this.target + '/' + this.focus,
+      method: this.method,
+      data: data,
+      ...params,
+      dataType: "json",
+      success: (response, status, xhr) => {
+        if(response && response.result === 'success')
+        {
+          if (response.meta && response.meta.text)
+          {
+            let result = this.notifyCallback(xhr.status);
+
+            if(result)
+            {
+              notify = NotifyManager.info('Успешно', response.meta.text)
+            }
+          }
+          self.toBind(response);
+          self.resetBindErrors();
+          successCallback(response, status, xhr);
+        }
+      },
+      error: (xhr, status, errorText) => {
+        this.handleError(notify, errorCallback, xhr, status, errorText);
+      }
+    });
+
+    return this;
+  }
+
+  handleError(notify, errorCallback, xhr, status, errorText)
+  {
+    if (xhr.readyState === 4) {
+      try {
+        let result = this.notifyCallback(xhr.status);
+
+        if(result)
+        {
+          switch (xhr.status) {
+            case 0://точно ошибка
+              notify = NotifyManager.error('Ошибка', errorText);
+              break;
+            case 404:
+
+              break;
+            default:
+              if(xhr?.responseJSON?.meta.text)
+              {
+                notify = NotifyManager.error('Ошибка', xhr.responseJSON.meta.text);
+              }else if(xhr?.responseJSON?.meta.message)
+              {
+                notify = NotifyManager.error('Ошибка', xhr.responseJSON.meta.message);
+              }else{
+                if(typeof errorText === 'string')
+                {
+                  notify = NotifyManager.error('Ошибка', errorText);
+                }else if(errorText?.message && typeof errorText.message === 'string'){
+                  notify = NotifyManager.error('Ошибка', errorText.message);
+                }
+              }
+              break;
+          }
+        }
+      } catch (e) {
+        console.error(e);
+        notify = this.notify ? NotifyManager.error('Ошибка') : null;
+      }
+    }
+    else if (xhr.readyState === 0) {
+      notify = NotifyManager.errorOnce('network_error', 'Ошибка', ' (Network Error) или невозможность получения доступа к сети');
+    }
+    else {
+      if(typeof errorText === 'string')
+      {
+        notify = NotifyManager.error('Ошибка', errorText);
+      }else if(errorText?.message && typeof errorText.message === 'string'){
+        notify = NotifyManager.error('Ошибка', errorText.message);
+      }
+    }
+
+    this.toBindErrors(xhr);
+    errorCallback(xhr);
+  }
+
+  callSync(successCallback = (r) => {
+  }, errorCallback = () => {
+  }) {
+    return this.call(successCallback, errorCallback, {async: false});
+  }
+
+  callUrl(successCallback = (r) => {
+  }, errorCallback = () => {
+  }, params = {}, dataKey = 'data', argumentsKey = 'arguments', queryKey = 'query')
+  {
+    let self = this;
+    this.callSuccess = successCallback;
+    this.callError = errorCallback;
+
+    let data = {};
+
+    if(argumentsKey)
+    {
+      data[argumentsKey] = this.arguments;
+    }
+
+    if(queryKey)
+    {
+      data[queryKey] = this.builder.toArray();
+    }
+
+    if(dataKey)
+    {
+      data[dataKey] = this.data;
+    }else{
+      data = this.data;
+    }
+
+    let notify = null;
+    Api.makeRequest({
+      url: this.url,
+      method: this.method,
+      data: data,
+      ...params,
+      success: (response, status, xhr) => {
+        if(response && response.result === 'success')
+        {
+          if (response.meta && response.meta.text)
+          {
+            notify = this.notify ? NotifyManager.info('Успешно', response.meta.text) : null
+          }
+          self.toBind(response);
+          self.resetBindErrors();
+          successCallback(response, status, xhr);
+        }
+      },
+      error: (xhr, status, errorText) => {
+        this.handleError(notify, errorCallback, xhr, status, errorText);
+      }
+    });
+
+    return this;
+  }
+
+  /**
+   *
+   * @param obj
+   * @param item
+   * @param rerender
+   * @param cb
+   */
+  bind(obj, item, rerender = false, cb) {
+    let key = 'data';
+    let self = this;
+    if (typeof item == 'object') {
+      this.responseBinding = [];
+      item.map(function (data)
+      {
+        self.responseBinding[self.responseBinding.length] = new Binding(obj, data[0], data[1], rerender, cb);
+
+        return;
+      })
+    } else {
+      this.responseBinding = new Binding(obj, item, key, rerender, cb);
+    }
+
+    return this;
+  }
+
+  /**
+   *
+   * @param response
+   */
+  toBind(response) {
+    if (this.responseBinding !== null) {
+      if (Array.isArray(this.responseBinding)) {
+        this.responseBinding.map(function (data)
+        {
+          data.fire(response);
+
+          return;
+        })
+      } else {
+        this.responseBinding.fire(response);
+      }
+    }
+  }
+
+  resetBindErrors() {
+    if (this.responseBindingErrors !== null) {
+      this.responseBindingErrors.fire({});
+    }
+  }
+
+  toBindErrors(response = {})
+  {
+    if (this.responseBindingErrors !== null && 'responseJSON' in response && typeof response.responseJSON === 'object')
+    {
+      this.responseBindingErrors.fire(response.responseJSON.meta.errors);
+    }
+  }
+
+  withValidateForm(obj, item = 'formErrors', key = 'meta') {
+    this.responseBindingErrors = new Binding(obj, item, key);
+    return this;
+  }
+
+  withoutNotify(callback)
+  {
+    //callback(status){} будем проверять статус и по условию если true не показывать уведомление
+
+    if(typeof callback === "undefined")
+    {
+      this.notifyCallback = (status) => {return false};
+    }else{
+      this.notifyCallback = callback;
+    }
+
+    return this;
+  }
+};

package/src/Binding.js

@@ -0,0 +1,56 @@
+export default class Binding {
+
+    constructor(target, pathTarget, pathData, rerender, onSuccess)
+    {
+        this.target = target;
+        this.pathTarget = pathTarget.split('.');
+        this.pathData = pathData.split('.');
+        this.callback = onSuccess;
+        this.rerender = rerender;
+    }
+
+    fire(data) {
+        let self = this;
+        let value = this.getData(data);
+        let obj = this.target.state;
+
+        if (this.pathTarget.length === 1) {
+            this.target.setState((prv) => {
+              obj[self.pathTarget[0]] = value
+
+              // if(this.rerender)//TODO
+              // {
+                  return prv;
+              // }
+
+            }, self.callback);
+        } else {
+            for (let i = 0; i < this.pathTarget.length - 1; i++) {
+                obj = obj[this.pathTarget[i]];
+            }
+            this.target.setState(function (prv) {
+                obj[self.pathTarget[self.pathTarget.length - 1]] = value;
+
+                // if(this.rerender)//TODO
+                // {
+                    return prv;
+                // }
+            }, self.callback);
+        }
+    }
+
+    getData(value) {
+        this.pathData.map(function (data)
+        {
+            for (let i in value) {
+                if (i == data) {
+                    value = value[data];
+                }
+            }
+
+          return;
+        });
+
+        return value;
+    }
+};

package/src/Builder.js

@@ -0,0 +1,85 @@
+export default class Builder {
+
+    static availableMethod = [
+        'select',
+        'where',
+        'whereDate',
+        'whereYear',
+        'whereMonth',
+        'has',
+        'whereIn',
+        'whereNotIn',
+        'whereHas',
+        'orWhereHas',
+        'whereHasMorph',
+        'orWhereHasMorph',
+        'whereDoesntHave',
+        'orWhereDoesntHave',
+        'orWhere',
+        'orderBy',
+        'groupBy',
+        'whereNull',
+        'orWhereNull',
+        'whereNotNull',
+        'orWhereNotNull',
+        /**
+         *@property Builder.availableMethod.with array
+         */
+        'with',
+        'withCount',
+        'offset',
+        'limit',
+        'distinct',
+        'owner',
+        'whereAbs',
+
+        'whereAccount',
+        'whereDate',
+        'whereYear',
+        'whereMonth',
+
+        'whereIncomeType',
+        'whereSalaryType',
+        'whereSpendingType',
+        'whereObligationType',
+        'wherePropertyType',
+        'whereInvestType',
+        'whereCurrencyType',
+        'whereAccountType',
+        'whereInsuranceType'
+    ];
+
+    constructor() {
+        var self = this;
+        this.query = [];
+        Builder.availableMethod.map(function (val)
+        {
+            self[val] = function () {
+                self.add(val, Array.prototype.slice.call(arguments));
+                return self;
+            }
+
+          return;
+        });
+    }
+
+    add(method, args) {
+        this.query.push({});
+        args.map(function (val, key)
+        {
+            if (typeof val == 'function') {
+                var func = val;
+                args[key] = {query: new Builder()};
+                args[key].query = func(args[key].query).toArray();
+            }
+
+          return;
+        });
+        this.query[this.query.length - 1][method] = args;
+        return this;
+    }
+
+    toArray() {
+        return this.query;
+    }
+};

package/src/NewApi.js

@@ -0,0 +1,170 @@
+import NewApiRequest from "./NewApiRequest";
+import axios from 'axios';
+
+export default class NewApi {
+  /**
+   * 
+   * @param target
+   * @param focus
+   * @param data
+   * @param method
+   * @return {NewApiRequest}
+   */
+  static create(target, focus, data = {}, method = 'GET') {
+    return new NewApiRequest(target, focus, data, method);
+  }
+
+  /**
+   *
+   * @param target
+   * @param focus
+   * @param arg
+   * @param data
+   * @param method
+   * @return {NewApiRequest}
+   */
+  static createArg(target, focus, arg, data = {}, method = 'GET') {
+    return new NewApiRequest(target, focus, data, method).addArg(arg);
+  }
+
+  /**
+   *
+   * @param target
+   * @param focus
+   * @param arg
+   * @param data
+   * @return {NewApiRequest}
+   */
+  static getArg(target, focus, arg, data = {}) {
+    return NewApi.get(target, focus, data).addArg(arg);
+  }
+
+  /**
+   *
+   * @param target
+   * @param focus
+   * @param arg
+   * @param data
+   * @return {NewApiRequest}
+   */
+  static postArg(target, focus, arg, data = {}) {
+    return NewApi.post(target, focus, data).addArg(arg);
+  }
+
+  /**
+   *
+   * @param target
+   * @param focus
+   * @param arg
+   * @param data
+   * @return {NewApiRequest}
+   */
+  static putArg(target, focus, arg, data = {}) {
+    return NewApi.put(target, focus, data).addArg(arg);
+  }
+
+  /**
+   *
+   * @param url
+   * @param data
+   * @return {NewApiRequest}
+   */
+  static getUrl(url, data = {})
+  {
+    return (new NewApiRequest('', '', data, 'GET')).setUrl(url);
+  }
+
+  /**
+   *
+   * @param url
+   * @param data
+   * @return {NewApiRequest}
+   */
+  static postUrl(url, data = {})
+  {
+    return (new NewApiRequest('', '', data, 'POST')).setUrl(url);
+  }
+
+  /**
+   *
+   * @param url
+   * @param data
+   * @return {NewApiRequest}
+   */
+  static putUrl(url, data = {})
+  {
+    return (new NewApiRequest('', '', data, 'PUT')).setUrl(url);
+  }
+
+  /**
+   *
+   * @param target
+   * @param focus
+   * @param data
+   * @returns {NewApiRequest}
+   */
+  static get(target, focus, data = {}) {
+    return new NewApiRequest(target, focus, data, 'GET');
+  }
+  /**
+   *
+   * @param target
+   * @param focus
+   * @param data
+   * @returns {NewApiRequest}
+   */
+  static post(target, focus, data = {}) {
+    return new NewApiRequest(target, focus, data, 'POST');
+  }
+  /**
+   *
+   * @param target
+   * @param focus
+   * @param data
+   * @returns {NewApiRequest}
+   */
+  static put(target, focus, data = {}) {
+    return new NewApiRequest(target, focus, data, 'PUT');
+  }
+
+  /**
+   *
+   * @param target
+   * @param focus
+   * @param id
+   * @param data
+   * @return {ApiRequest}
+   */
+  static delete(target, focus, id, data = {}) {
+    return new NewApiRequest(target, focus, data, 'DELETE').addArg(id);
+  }
+
+  static makeRequest({url, method, data, params, headers})
+  {
+    if (typeof headers === 'undefined') {
+      headers = {};
+    }
+
+    headers['Content-Type'] = 'application/json';
+
+    let api_token = localStorage.getItem('api_token');
+    if (api_token)
+    {
+      headers["Authorization"] = api_token;
+    }
+
+    return axios({
+      url: url,
+      method: method,
+      data: data,
+      params: params,
+      headers: headers
+    })
+      .then(response => {
+        return response.data;
+      })
+      .catch(error => {
+        throw new Error(`API request to ${url} failed: ${error}`);
+      });
+  }
+}

package/src/NewApiRequest.js

@@ -0,0 +1,48 @@
+import Api from "./Api";
+import ApiRequest from "./ApiRequest";
+import NotifyManager from "../../interface/notify/NotifyManager";
+
+/**
+ *
+ */
+export default class NewApiRequest extends ApiRequest
+{
+
+  callUrl(success = function () {
+  }, error = function () {
+  }, params = {})
+  {
+    let self = this;
+    this.callSuccess = success;
+    this.callError = error;
+
+    let notify = null;
+    Api.makeRequest({
+      url: this.url,
+      method: this.method,
+      data: {
+        arguments: this.arguments,
+        query: this.builder.toArray(),
+        data: this.data,
+      },
+      ...params,
+      success: (response, status, xhr) => {
+        if(response && response.result === 'success')
+        {
+          if (response.meta && response.meta.text)
+          {
+            notify = this.notify ? NotifyManager.info('Успешно', response.meta.text) : null
+          }
+          self.toBind(response);
+          self.resetBindErrors();
+          success(response, status, xhr);
+        }
+      },
+      error: (xhr, status, errorText) => {
+        this.handleError(notify, error, xhr, status, errorText);
+      }
+    });
+
+    return this;
+  }
+};

package/src/UrlBind.js

@@ -0,0 +1,91 @@
+import QueryString from "query-string";
+
+export default class UrlBind {
+
+    static parse = false;
+
+
+    static order(query, options) {
+        if (options.value != '') {
+            var order = options.value.split('.');
+            query.orderBy(order[0], order[1]);
+        } else {
+        }
+        return query;
+    }
+
+    static filter(query, options) {
+        for (var key in options) {
+            var data = options[key];
+            if (typeof data === 'object') {
+                if (data.value !== '') {
+                    if (!data.hasOwnProperty('method')) {
+                        query.where(
+                            data.hasOwnProperty('field') ? data.field : key,
+                            data.hasOwnProperty('operator') ? data.operator : '=',
+                            data.operator === 'LIKE' ? '%' + data.value + '%' : data.value
+                        );
+                    } else if (typeof data.method === 'function') {
+                        data.method(query, data.value);
+                    }
+
+                    const parsed = QueryString.parse(History.location.search);
+                    parsed[key] = data.value;
+
+                } else {
+                    const parsed = QueryString.parse(History.location.search);
+                    if (key in parsed) {
+                        delete parsed[key];
+                    }
+                }
+            }
+        }
+
+        return query;
+    }
+
+    static getParams(query, options)
+    {
+        let parsed = [];
+
+        for (var key in options) {
+            var data = options[key];
+            if (typeof data === 'object') {
+                if (data.value !== '') {
+                    if (!data.hasOwnProperty('method')) {
+                        query.where(
+                            data.hasOwnProperty('field') ? data.field : key,
+                            data.hasOwnProperty('operator') ? data.operator : '=',
+                            data.operator === 'LIKE' ? '%' + data.value + '%' : data.value
+                        );
+                    } else if (typeof data.method === 'function') {
+                        data.method(query, data.value);
+                    }
+
+                    parsed = QueryString.parse(History.location.search);
+                    parsed[key] = data.value;
+                } else {
+                    parsed = QueryString.parse(History.location.search);
+                    if (key in parsed) {
+                        delete parsed[key];
+                    }
+                }
+            }
+        }
+
+        return query;
+    }
+
+    static urlParse(obj) {
+
+        UrlBind.parse = true;
+
+        for (var key in obj) {
+            var data = obj[key];
+            if (typeof data === 'object') {
+                if (data.value === '') {}
+            }
+
+        }
+    }
+};