spyne 0.19.1 → 0.20.1

package/src/spyne/utils/channel-payload-filter.js

@@ -19,16 +19,15 @@ import {
   any,
   curry,
   lte
-} from 'ramda';
+  , map as rMap
+} from 'ramda'
 
-import {SpyneAppProperties} from './spyne-app-properties';
+import { SpyneAppProperties } from './spyne-app-properties'
 
-const rMap = require('ramda').map;
-
-const isNotArr = compose(not, is(Array));
-const isNotEmpty = compose(not, isEmpty);
-const isNonEmptyStr = allPass([is(String), isNotEmpty]);
-const isNonEmptyArr = allPass([is(Array), isNotEmpty]);
+const isNotArr = compose(not, is(Array))
+const isNotEmpty = compose(not, isEmpty)
+const isNonEmptyStr = allPass([is(String), isNotEmpty])
+const isNonEmptyArr = allPass([is(Array), isNotEmpty])
 const isObjectFn = compose(allPass([isNotArr, is(Object)]))
 const isNonEmptyObjectFn = compose(allPass([isNotEmpty, isNotArr, is(Object)]))
 
@@ -99,170 +98,160 @@ export class ChannelPayloadFilter {
    * .subscribe(myChannelMethod);
    *
    */
-  constructor(selector, filters={}, debugLabel, testMode) {
-
-
-
-    const selectorIsObj = isObjectFn(selector);
-
-    if(selectorIsObj){
-      filters = selector;
-      selector = prop('selector', filters);
-      testMode = testMode || prop("testMode", filters);
+  constructor(selector, filters = {}, debugLabel, testMode) {
+    const selectorIsObj = isObjectFn(selector)
 
+    if (selectorIsObj) {
+      filters = selector
+      selector = prop('selector', filters)
+      testMode = testMode || prop('testMode', filters)
     }
 
+    const debugLabelArr = [debugLabel, prop('debugLabel', filters)]
 
-    const debugLabelArr = [debugLabel,  prop('debugLabel', filters)]
-
-    debugLabel = compose(find(is(String)))(debugLabelArr);
+    debugLabel = compose(find(is(String)))(debugLabelArr)
 
     let props = omit(['debugLabel', 'label', 'selector', 'props', 'testMode', 'propFilters'], filters)
-    if (filters.props!==undefined) {
+    if (filters.props !== undefined) {
       props = mergeAll([filters.props, props])
-
-    } else if (filters.propFilters!==undefined) {
+    } else if (filters.propFilters !== undefined) {
       props = mergeAll([filters.propFilters, props])
     }
 
-    filters['propFilters'] = props;
+    filters.propFilters = props
 
-    let {propFilters} = filters;
+    const { propFilters } = filters
 
+    const addStringSelectorFilter =  isNonEmptyStr(selector) ? ChannelPayloadFilter.filterSelector([selector], debugLabel) : undefined
+    const addArraySelectorFilter =   isNonEmptyArr(selector) ? ChannelPayloadFilter.filterSelector(selector, debugLabel) : undefined
+    const addDataFilter = isNonEmptyObjectFn(propFilters) ? ChannelPayloadFilter.filterData(propFilters, debugLabel) : undefined
 
-    const addStringSelectorFilter =  isNonEmptyStr(selector) ? ChannelPayloadFilter.filterSelector([selector], debugLabel) : undefined;
-    const addArraySelectorFilter =   isNonEmptyArr(selector) ? ChannelPayloadFilter.filterSelector(selector, debugLabel) : undefined;
-    const addDataFilter = isNonEmptyObjectFn(propFilters) ? ChannelPayloadFilter.filterData(propFilters, debugLabel) : undefined;
+    let filtersArr = reject(isNil, [addStringSelectorFilter, addArraySelectorFilter, addDataFilter])
 
-    let filtersArr = reject(isNil, [addStringSelectorFilter, addArraySelectorFilter, addDataFilter]);
+    // IF ARRAY IS EMPTY ALWAYS RETURN FALSE;
 
-      // IF ARRAY IS EMPTY ALWAYS RETURN FALSE;
-
-      const filtersAreEmpty = isEmpty(filtersArr);
-
-      if (filtersAreEmpty){
-        filtersArr = [always(false)];
-        if (SpyneAppProperties.debug === true && testMode!==true){
-          console.warn(`Spyne Warning: The Channel Filter, with selector: ${selector}, and propFilters:${propFilters} appears to be empty!`);
-        }
+    const filtersAreEmpty = isEmpty(filtersArr)
 
+    if (filtersAreEmpty) {
+      filtersArr = [always(false)]
+      if (SpyneAppProperties.debug === true && testMode !== true) {
+        console.warn(`Spyne Warning: The Channel Filter, with selector: ${selector}, and propFilters:${propFilters} appears to be empty!`)
       }
-      if (testMode === true){
-        return {selector, propFilters, debugLabel, filters, testMode, filtersAreEmpty};
-      }
+    }
+    if (testMode === true) {
+      return { selector, propFilters, debugLabel, filters, testMode, filtersAreEmpty }
+    }
 
-    return allPass(filtersArr);
+    return allPass(filtersArr)
   }
 
   static filterData(filterJson, filterdebugLabel) {
-    const debugLabel = filterdebugLabel;
+    const debugLabel = filterdebugLabel
 
-    let compareData = () => {
+    const compareData = () => {
       // DO NOT ALLOW AN EMPTY OBJECT TO RETURN TRUEs
       if (isEmpty(filterJson)) {
-        return always(false);
+        return always(false)
       }
 
       //  CHECKS ALL VALUES IN JSON TO DETERMINE IF THERE ARE FILTERING METHODS
 
-      const createCurryComparator = compareStr => (str)=>{
-        return str===compareStr;
-      };
-      const checkToConvertToFn = (val, key, obj)=>val = is(String, val)===true ? createCurryComparator(val) : val;
-      filterJson = rMap(checkToConvertToFn, filterJson);
+      const createCurryComparator = compareStr => (str) => {
+        return str === compareStr
+      }
+      const checkToConvertToFn = (val, key, obj) => {
+        const fnVal = is(String, val) === true ? createCurryComparator(val) : val
+        return fnVal
+      }
+      filterJson = rMap(checkToConvertToFn, filterJson)
 
       // TAP LOGGER
-      const tapLogger = (comparedObj)=>{
-        if (debugLabel===undefined){
-          return comparedObj;
+      const tapLogger = (comparedObj) => {
+        if (debugLabel === undefined) {
+          return comparedObj
         }
-          const propsBooleans = {};
-          const mapBools = (value,key)=>propsBooleans[key] = value(prop(key, comparedObj));
-          forEachObjIndexed(mapBools, filterJson);
-          console.log(`%c CHANNEL PAYLOAD FILTER DEBUGGER ["${debugLabel}"] - values:    `, "color:orange;",{propsBooleans, comparedObj});
+        const propsBooleans = {}
+        const mapBools = (value, key) => {
+          propsBooleans[key] = value(prop(key, comparedObj))
+        }
+        forEachObjIndexed(mapBools, filterJson)
+        console.log(`%c CHANNEL PAYLOAD FILTER DEBUGGER ["${debugLabel}"] - values:    `, 'color:orange;', { propsBooleans, comparedObj })
 
-        return comparedObj;
-      };
+        return comparedObj
+      }
 
       // END TAP LOGGER
-      let fMethod = where(filterJson);
+      const fMethod = where(filterJson)
 
-      let getFilteringObj =  (v)=>{
-        const {payload, srcElement, event} = v || {};
-        const o = Object.assign({}, v, event, payload);
-        //console.log('o is ',o);
-        return o;
+      const getFilteringObj =  (v) => {
+        const { payload, srcElement, event } = v || {}
+        const o = Object.assign({}, v, srcElement, event, payload)
+        // console.log('o is ',o);
+        return o
       }
 
+      return compose(fMethod, tapLogger, defaultTo({}), getFilteringObj)
+    }
 
-      return compose( fMethod, tapLogger, defaultTo({}),  getFilteringObj);
-
-    };
-
-    return compareData();
+    return compareData()
   }
 
-
   static checkPayloadSelector(arr, debugLabel, srcPayload) {
-
     // ELEMENT FROM PAYLOADs
-    const {payload, srcElement, event} = srcPayload || {};
+    const { payload, srcElement, event } = srcPayload || {}
 
     const reduceFindEl = (acc, src) => {
-      const el = prop('el', src);
-      if (ChannelPayloadFilter.elIsDomElement(el) && acc===undefined){
-        acc = el;
+      const el = prop('el', src)
+      if (ChannelPayloadFilter.elIsDomElement(el) && acc === undefined) {
+        acc = el
       }
-      return acc;
+      return acc
     }
 
-    const el = [srcElement, payload, prop('srcElement', event), srcPayload].reduce(reduceFindEl, undefined);
-
+    const el = [srcElement, payload, prop('srcElement', event), srcPayload].reduce(reduceFindEl, undefined)
 
     // RETURN BOOLEAN MATCH WITH PAYLOAD EL
-    const compareEls = (elCompare) => elCompare.isEqualNode((el));
+    const compareEls = (elCompare) => elCompare.isEqualNode((el))
 
     // LOOP THROUGH NODES IN querySelectorAll()
     const mapNodeArrWithEl = (sel) => {
       // convert nodelist to array of els
-      let nodeArr = flatten(document.querySelectorAll(sel));
+      const nodeArr = flatten(document.querySelectorAll(sel))
       // els array to boolean array
-      return rMap(compareEls, nodeArr);
-    };
+      return rMap(compareEls, nodeArr)
+    }
 
-    if (debugLabel!==undefined){
-      let nodeArrResultsDebugger = compose(flatten, rMap(mapNodeArrWithEl))(arr);
-      const selectorsArr = arr;
-      console.log(`%c CHANNEL PAYLOAD FILTER DEBUGGER ["${debugLabel}"] - selectors: `, "color:orange;",{el, selectorsArr, nodeArrResultsDebugger});
+    if (debugLabel !== undefined) {
+      const nodeArrResultsDebugger = compose(flatten, rMap(mapNodeArrWithEl))(arr)
+      const selectorsArr = arr
+      console.log(`%c CHANNEL PAYLOAD FILTER DEBUGGER ["${debugLabel}"] - selectors: `, 'color:orange;', { el, selectorsArr, nodeArrResultsDebugger })
     }
 
     // CHECK IF PAYLOAD EL EXISTS
     if (typeof (el) !== 'object') {
-      return false;
+      return false
     }
 
     // LOOP THROUGH ALL SELECTORS IN MAIN ARRAY
-    let nodeArrResult = compose(flatten, rMap(mapNodeArrWithEl))(arr);
+    const nodeArrResult = compose(flatten, rMap(mapNodeArrWithEl))(arr)
     if (isEmpty(nodeArrResult) === true) {
-      return false;
+      return false
     }
 
-    return any(equals(true), nodeArrResult);
+    return any(equals(true), nodeArrResult)
   }
 
   static elIsDomElement(o) {
-    if (is(String,o)){
-      o = document.querySelector(o);
+    if (is(String, o)) {
+      o = document.querySelector(o)
     }
 
-
-    return compose(lte(0), defaultTo(-1), prop('nodeType'))(o);
+    return compose(lte(0), defaultTo(-1), prop('nodeType'))(o)
   }
 
-
   static filterSelector(selectorArr, debugLabel) {
-    let arr = reject(isEmpty, selectorArr);
-    let payloadCheck = curry(ChannelPayloadFilter.checkPayloadSelector);
-    return payloadCheck(arr, debugLabel);
+    const arr = reject(isEmpty, selectorArr)
+    const payloadCheck = curry(ChannelPayloadFilter.checkPayloadSelector)
+    return payloadCheck(arr, debugLabel)
   }
 }

package/src/spyne/utils/deep-merge.js

@@ -1,73 +1,75 @@
 function isMergeableObject(val) {
-  let nonNullObject = val && typeof val === 'object';
-  return nonNullObject && Object.prototype.toString.call(val) !== '[object RegExp]' && Object.prototype.toString.call(val) !== '[object Date]';
+  const nonNullObject = val && typeof val === 'object'
+  return nonNullObject && Object.prototype.toString.call(val) !== '[object RegExp]' && Object.prototype.toString.call(val) !== '[object Date]'
 }
 
 function emptyTarget(val) {
-  return Array.isArray(val) ? [] : {};
+  return Array.isArray(val) ? [] : {}
 }
 
 function cloneIfNecessary(value, optionsArgument) {
-  let clone = optionsArgument && optionsArgument.clone === true;
-  return (clone && isMergeableObject(value)) ? deepMerge(emptyTarget(value),
-    value, optionsArgument) : value;
+  const clone = optionsArgument && optionsArgument.clone === true
+  return (clone && isMergeableObject(value))
+    ? deepMerge(emptyTarget(value),
+      value, optionsArgument)
+    : value
 }
 
 function defaultArrayMerge(target, source, optionsArgument) {
-  let destination = target.slice();
+  const destination = target.slice()
   source.forEach(function(e, i) {
     if (typeof destination[i] === 'undefined') {
-      destination[i] = cloneIfNecessary(e, optionsArgument);
+      destination[i] = cloneIfNecessary(e, optionsArgument)
     } else if (isMergeableObject(e)) {
-      destination[i] = deepMerge(target[i], e, optionsArgument);
+      destination[i] = deepMerge(target[i], e, optionsArgument)
     } else if (target.indexOf(e) === -1) {
-      destination.push(cloneIfNecessary(e, optionsArgument));
+      destination.push(cloneIfNecessary(e, optionsArgument))
     }
-  });
-  return destination;
+  })
+  return destination
 }
 
 function mergeObject(target, source, optionsArgument) {
-  let destination = {};
+  const destination = {}
   if (isMergeableObject(target)) {
     Object.keys(target).forEach(function(key) {
-      destination[key] = cloneIfNecessary(target[key], optionsArgument);
-    });
+      destination[key] = cloneIfNecessary(target[key], optionsArgument)
+    })
   }
   Object.keys(source).forEach(function(key) {
     if (!isMergeableObject(source[key]) || !target[key]) {
-      destination[key] = cloneIfNecessary(source[key], optionsArgument);
+      destination[key] = cloneIfNecessary(source[key], optionsArgument)
     } else {
-      destination[key] = deepMerge(target[key], source[key], optionsArgument);
+      destination[key] = deepMerge(target[key], source[key], optionsArgument)
     }
-  });
-  return destination;
+  })
+  return destination
 }
 
 function deepMerge(target, source, optionsArgument) {
-  let array = Array.isArray(source);
-  let options = optionsArgument || { arrayMerge: defaultArrayMerge };
-  let arrayMerge = options.arrayMerge || defaultArrayMerge;
+  const array = Array.isArray(source)
+  const options = optionsArgument || { arrayMerge: defaultArrayMerge }
+  const arrayMerge = options.arrayMerge || defaultArrayMerge
 
   if (array) {
     return Array.isArray(target)
       ? arrayMerge(target, source, optionsArgument)
-      : cloneIfNecessary(source, optionsArgument);
+      : cloneIfNecessary(source, optionsArgument)
   } else {
-    return mergeObject(target, source, optionsArgument);
+    return mergeObject(target, source, optionsArgument)
   }
 }
 
 deepMerge.all = function deepmergeAll(array, optionsArgument) {
   if (!Array.isArray(array) || array.length < 2) {
     throw new Error(
-      'first argument should be an array with at least two elements');
+      'first argument should be an array with at least two elements')
   }
 
   // we are sure there are at least 2 values, so it is safe to have no initial value
   return array.reduce(function(prev, next) {
-    return deepMerge(prev, next, optionsArgument);
-  });
-};
+    return deepMerge(prev, next, optionsArgument)
+  })
+}
 
-export { deepMerge };
+export { deepMerge }

package/src/spyne/utils/frp-tools.js

@@ -1,92 +1,85 @@
-import{defaultTo, match, forEach, test, includes, without,complement, isEmpty, values, isNil, filter, __, keys, compose, head, map, cond, T, allPass, concat, uniq} from 'ramda';
+import { defaultTo, match, forEach, test, includes, without, complement, isEmpty, values, isNil, filter, __, keys, compose, head, map, cond, T, allPass, concat, uniq } from 'ramda'
 const isIOS = () => {
-  let userAgent = window.navigator.userAgent.toLowerCase();
+  const userAgent = window.navigator.userAgent.toLowerCase()
   // let safari = /safari/.test(userAgent);
-  let ios = /iphone|ipod|ipad/.test(userAgent);
-  return ios === true;
-};
-
-
-const delayCall = async(fn, time)=>{
+  const ios = /iphone|ipod|ipad/.test(userAgent)
+  return ios === true
+}
 
-  function sleep (ms) {
+const delayCall = async(fn, time) => {
+  function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms))
   }
 
   const timeoutHandler = async() => {
-    await sleep(1);
-    window.requestAnimationFrame(fn);
+    await sleep(1)
+    window.requestAnimationFrame(fn)
   }
 
   window.setTimeout(timeoutHandler, time)
-
-
 }
 
-
-
-
 const getConstructorName = (obj) => {
   if (obj.constructor.name !== undefined) {
-    return obj.constructor.name;
+    return obj.constructor.name
   }
-  const re = /^(function\s)(\w+)(\(.*)$/;
-  let str = obj.toString();
-  return defaultTo(String(str).substr(0, 12), match(re, str)[2]);
-};
+  const re = /^(function\s)(\w+)(\(.*)$/
+  const str = obj.toString()
+  return defaultTo(String(str).substr(0, 12), match(re, str)[2])
+}
 
 const arrFromMapKeys = (map) => {
-  let arr = [];
-  const addKeysToArr = (v, k, i) => arr.push(k);
-  forEach(addKeysToArr, map);
-  return arr;
-};
+  const arr = []
+  const addKeysToArr = (v, k, i) => arr.push(k)
+  forEach(addKeysToArr, map)
+  return arr
+}
 
 const findStrFromRegexArr = (obj, str) => {
   if (obj[str] !== undefined) {
-    return str;
+    return str
   }
-  const checkIfMatch = s => test(new RegExp(s), str);
-  const checkStrMatch = includes(str);
-  const checkIfRegExMatch = compose(includes(true), map(checkIfMatch));
+  const checkIfMatch = s => test(new RegExp(s), str)
+  const checkStrMatch = includes(str)
+  const checkIfRegExMatch = compose(includes(true), map(checkIfMatch))
   const runMatchChecks = cond([
     [checkStrMatch, () => str],
     [checkIfRegExMatch, () => str],
     [T, () => undefined]
-  ]);
-  return runMatchChecks(obj);
-};
+  ])
+  return runMatchChecks(obj)
+}
 
 const findStrOrRegexMatchStr = (obj, str) => {
   if (obj[str] !== undefined) {
-    return str;
+    return str
   }
-  const createRe = s => new RegExp(s);
-  let checkerIfRegexMatchExists = compose(head, filter(compose(test(__, str), createRe)));
-  return checkerIfRegexMatchExists(keys(obj));
-};
+  const createRe = s => new RegExp(s)
+  const checkerIfRegexMatchExists = compose(head, filter(compose(test(__, str), createRe)))
+  return checkerIfRegexMatchExists(keys(obj))
+}
 
 const closest = (array, num) => {
-  let i = 0;
-  let minDiff = 1000;
-  let ans;
+  let i = 0
+  let minDiff = 1000
+  let ans
   for (i in array) {
-    let m = Math.abs(num - array[i]);
+    const m = Math.abs(num - array[i])
     if (m < minDiff) {
-      minDiff = m;
-      ans = array[i];
+      minDiff = m
+      ans = array[i]
     }
   }
-  return ans;
-};
+  return ans
+}
 
 const convertDomStringMapToObj = (domMap) => {
-  let obj = {};
-  for (let d in domMap) {
-    obj[d] = domMap[d];
+  const obj = {}
+  for (const d in domMap) {
+    obj[d] = domMap[d]
   }
-  return obj;
-};
+  return obj
+}
 
 // const passPageData = pick(['params', 'routeId', 'data'], __);
 
@@ -94,72 +87,95 @@ const subscribeFn = {
   next:     x => console.log(`next      ${x}`),
   error:    x => console.log(`error     ${x}`),
   complete: x => console.log(`complete  ${x}`)
-};
+}
 
 const right = x => ({
   map: f => right(f(x)),
   fold: (f, g) => g(x),
   inspect: () => `right(${x})`
 
-});
+})
 
 const ifNilThenUpdate = (val, newVal) => {
-  let isNilBool = isNil(val);
-  return isNilBool ? newVal : val;
-};
+  const isNilBool = isNil(val)
+  return isNilBool ? newVal : val
+}
 
 const left = x => ({
   map: f => left(x),
   fold: (f, g) => f(x),
   inspect: () => `left(${x})`
-});
+})
 
 const checkIfObjIsNotEmptyOrNil = (obj) => {
-  const isNotEmpty = compose(complement(isEmpty), head, values);
-  const isNotNil = compose(complement(isNil), head, values);
-  const isNotNilAndIsNotEmpty = allPass([isNotEmpty, isNotNil]);
-  return isNotNilAndIsNotEmpty(obj);
-};
+  const isNotEmpty = compose(complement(isEmpty), head, values)
+  const isNotNil = compose(complement(isNil), head, values)
+  const isNotNilAndIsNotEmpty = allPass([isNotEmpty, isNotNil])
+  return isNotNilAndIsNotEmpty(obj)
+}
 
-const fromNullable = x => x !== null ? right(x) : left(null);
+const fromNullable = x => x !== null ? right(x) : left(null)
 
 const findInObj = (obj, val, error = null) => {
-  const found = obj[val];
-  return found ? right(found) : left(error);
-};
+  const found = obj[val]
+  return found ? right(found) : left(error)
+}
 const pullRouteInfo = () => {
-  let str = pullHashAndSlashFromPath(window.location.hash);
-  let routeId = pullMainRoute(str);
-  let params = pullParams(str);
-  return { routeId, params };
-};
+  const str = pullHashAndSlashFromPath(window.location.hash)
+  const routeId = pullMainRoute(str)
+  const params = pullParams(str)
+  return { routeId, params }
+}
+
+function getAllMethodNames(instance, omittedMethods = []) {
+  // Optionally rename `instance` to something more descriptive:
+  const baseClassMethodsArr = ['length', 'name', 'prototype', 'constructor']
+  const combinedOmittedMethods = concat(baseClassMethodsArr, omittedMethods)
+
+  // Filter out omitted
+  const omitPropsFromArr = compose(without(combinedOmittedMethods), uniq)
 
-const getAllMethodNames = (_this = this, omittedMethods = []) => {
+  // Pull out instance methods
+  const methods = omitPropsFromArr(
+    Object.getOwnPropertyNames(instance.constructor.prototype)
+  )
+
+  // Pull out static methods
+  const staticMethods = omitPropsFromArr(
+    Object.getOwnPropertyNames(instance.constructor)
+  )
+
+  const allMethods = concat(methods, staticMethods)
+
+  return { methods, staticMethods, allMethods }
+}
+
+/* const getAllMethodNames3 = (_this = this, omittedMethods = []) => {
   const getPropNamesArr = (obj = this, omittedMethods = []) => {
-    return Object.getOwnPropertyNames(obj);
-  };
+    return Object.getOwnPropertyNames(obj)
+  }
   // Filter Methods
-  let baseClassMethodsArr = ['length', 'name', 'prototype', 'constructor'];
-  omittedMethods = concat(baseClassMethodsArr, omittedMethods);
-  let omitPropsFromArr = compose(without(omittedMethods), uniq);
+  const baseClassMethodsArr = ['length', 'name', 'prototype', 'constructor']
+  omittedMethods = concat(baseClassMethodsArr, omittedMethods)
+  const omitPropsFromArr = compose(without(omittedMethods), uniq)
 
   // PULL OUT METHOD NAMES
-  let methods = omitPropsFromArr(Object.getOwnPropertyNames(_this.constructor.prototype));
-  let staticMethods = omitPropsFromArr(getPropNamesArr(_this.constructor));
-  let allMethods = concat(methods, staticMethods);
+  const methods = omitPropsFromArr(Object.getOwnPropertyNames(_this.constructor.prototype))
+  const staticMethods = omitPropsFromArr(getPropNamesArr(_this.constructor))
+  const allMethods = concat(methods, staticMethods)
 
-  return { methods, staticMethods, allMethods };
+  return { methods, staticMethods, allMethods }
   // return 'fn';
-};
+} */
 
 // ROUTE REGEX EXPRESSIONS
-const removeSlashes = str => str.replace(/^(\/)(.*)/g, '$2');
-const routeRE = /^(\/?)(\w*)(\/?)(.*)/g;
-const pullHashAndSlashFromPath = (str) => str.replace(/^(#\/?)(.*)/, '$2');
-const pullSlashFromPath = (str) => str.replace(/^(\/?)(.*)/, '$2');
-const pullMainRoute = (str) => str.replace(routeRE, '$2');
-const pullParams =    (str) => str.replace(routeRE, '$4');
-const pullTranslateX = str => str.replace(/^(matrix)(.*\d*,)(.*\d*,)(.*\d*,)(.*\d*,)(.*\d*)(,.*)/, '$6');
-const pullTranslateY = str => str.replace(/^(matrix)(.*\d*,)(.*\d*,)(.*\d*,)(.*\d*,)(.*\d*,)(.*\d)(.*)/, '$7');
-const pullTranslateYFromHeader = str => str.replace(/^(transform: matrix)(.*\d*,)(.*\d*,)(.*\d*,)(.*\d*,)(.*\d*)(\).*;)/, '$6');
-export { getConstructorName, arrFromMapKeys, getAllMethodNames, findStrOrRegexMatchStr, findStrFromRegexArr, checkIfObjIsNotEmptyOrNil, isIOS, pullRouteInfo, pullTranslateYFromHeader, pullSlashFromPath, pullHashAndSlashFromPath, closest, pullTranslateY, pullTranslateX, pullMainRoute, pullParams, right, left, fromNullable, findInObj, ifNilThenUpdate, removeSlashes, subscribeFn, convertDomStringMapToObj, delayCall };
+const removeSlashes = str => str.replace(/^(\/)(.*)/g, '$2')
+const routeRE = /^(\/?)(\w*)(\/?)(.*)/g
+const pullHashAndSlashFromPath = (str) => str.replace(/^(#\/?)(.*)/, '$2')
+const pullSlashFromPath = (str) => str.replace(/^(\/?)(.*)/, '$2')
+const pullMainRoute = (str) => str.replace(routeRE, '$2')
+const pullParams =    (str) => str.replace(routeRE, '$4')
+const pullTranslateX = str => str.replace(/^(matrix)(.*\d*,)(.*\d*,)(.*\d*,)(.*\d*,)(.*\d*)(,.*)/, '$6')
+const pullTranslateY = str => str.replace(/^(matrix)(.*\d*,)(.*\d*,)(.*\d*,)(.*\d*,)(.*\d*,)(.*\d)(.*)/, '$7')
+const pullTranslateYFromHeader = str => str.replace(/^(transform: matrix)(.*\d*,)(.*\d*,)(.*\d*,)(.*\d*,)(.*\d*)(\).*;)/, '$6')
+export { getConstructorName, arrFromMapKeys, getAllMethodNames, findStrOrRegexMatchStr, findStrFromRegexArr, checkIfObjIsNotEmptyOrNil, isIOS, pullRouteInfo, pullTranslateYFromHeader, pullSlashFromPath, pullHashAndSlashFromPath, closest, pullTranslateY, pullTranslateX, pullMainRoute, pullParams, right, left, fromNullable, findInObj, ifNilThenUpdate, removeSlashes, subscribeFn, convertDomStringMapToObj, delayCall }