spyne 0.14.8 → 0.17.3

package/src/spyne/channels/{channels-delegator.js → channels-map.js}

@@ -4,16 +4,17 @@ import { SpyneChannelRoute } from './spyne-channel-route';
 import { SpyneChannelUI } from './spyne-channel-ui';
 import { SpyneChannelWindow } from './spyne-channel-window';
 import { SpyneChannelLifecycle } from './spyne-channel-lifecycle';
-import { validate } from '../utils/channel-config-validator';
+//import { validate } from '../utils/channel-config-validator';
 
 import { Subject } from 'rxjs';
 import { ChannelProxy } from './channel-proxy';
-import {propEq, pluck, prop, filter, reject, compose, join} from 'ramda';
+import {propEq, pluck, prop, filter, pathEq, clone, reject, compose, join} from 'ramda';
 const rMap = require('ramda').map;
+const _map = new Map();
 
 // import * as R from 'ramda';
 
-export class ChannelsDelegator {
+export class ChannelsMap {
   /**
    * @module ChannelsDelegator
    * @type internal
@@ -28,14 +29,17 @@ export class ChannelsDelegator {
 
   constructor() {
     this.addMixins();
-    this.map = new Map();
+    //_map = new Map();
 
     // console.log('Rx is ',Rx);
     // console.log('RX IS ', Subject);
-    this.map.set('DISPATCHER', new Subject());
-    this.listRegisteredChannels = ChannelsDelegator.listRegisteredChannels.bind(this);
-    this.getChannelsList = ChannelsDelegator.getChannelsList.bind(this);
-    //window.setTimeout(this.checkForMissingChannels.bind(this), 8000);
+    _map.set('DISPATCHER', new Subject());
+    this.listRegisteredChannels = ChannelsMap.listRegisteredChannels.bind(this);
+    this.getChannelsList = ChannelsMap.getChannelsList.bind(this);
+  }
+
+  get map(){
+    return _map;
   }
 
   static getChannelsList() {
@@ -44,7 +48,7 @@ export class ChannelsDelegator {
       let val = k[1].constructor.name;
       return { key, val };
     };
-    return Array.from(window.Spyne.channels.map, proxyMapFn);
+    return Array.from(_map, proxyMapFn);
   }
 
   static listRegisteredChannels(showOnlyProxies = false) {
@@ -79,59 +83,71 @@ export class ChannelsDelegator {
     this.createMainStreams();
   }
 
+/*
   createObserver(obj) {
     // RIGHT NOW THIS CREATES THE DISPATCHER STREAM
     validate(obj.validations, obj.init);
-    this.map.set(obj.init.name, obj.init.observable());
+    _map.set(obj.init.name, obj.init.observable());
   }
+*/
 
   createMainStreams() {
     this.routeStream = new SpyneChannelRoute();
-    this.map.set('CHANNEL_ROUTE', this.routeStream);
+    _map.set('CHANNEL_ROUTE', this.routeStream);
 
     this.uiStream = new SpyneChannelUI();
-    this.map.set('CHANNEL_UI', this.uiStream);
+    _map.set('CHANNEL_UI', this.uiStream);
 
     this.domStream = new SpyneChannelWindow();
-    this.map.set('CHANNEL_WINDOW', this.domStream);
+    _map.set('CHANNEL_WINDOW', this.domStream);
 
     this.viewStreamLifecycle = new SpyneChannelLifecycle();
-    this.map.set('CHANNEL_LIFECYCLE', this.viewStreamLifecycle);
+    _map.set('CHANNEL_LIFECYCLE', this.viewStreamLifecycle);
 
     this.routeStream.initializeStream();
     this.domStream.initializeStream();
   }
 
   addKeyEvent(key) {
-    this.map.get('UI').addKeyEvent(key);
+    _map.get('UI').addKeyEvent(key);
   }
 
   registerStream(val) {
     let name = val.channelName;
-    this.map.set(name, val);
+    const nameExists = _map.has(name);
+    if (nameExists){
+      const isAlreadyRegisterd = compose(pathEq(['props', 'isRegistered'], true))(_map.get(name));
+      if(isAlreadyRegisterd){
+        console.warn(`Spyne Warning: The Channel, ${name}, has already been registered!`);
+        return;
+      }
+    }
+
+
+    _map.set(name, val);
     val.initializeStream();
   }
 
   getChannelActions(str) {
-    return this.map.get(str).addRegisteredActions();
+    return _map.get(str).addRegisteredActions();
   }
 
   getProxySubject(name, isReplaySubject = false) {
     let subjectType = isReplaySubject === true ? 'replaySubject' : 'subject';
 
-    return this.map.get(name)[subjectType];
+    return _map.get(name)[subjectType];
   }
 
   testStream(name) {
-    return this.map.get(name) !== undefined;
+    return _map.get(name) !== undefined;
   }
 
   getStream(name) {
     if (this.testStream(name) === false) {
-      this.map.set(name, new ChannelProxy(name));
+      _map.set(name, new ChannelProxy(name));
     }
 
-    return this.map.get(name);
+    return _map.get(name);
   }
 
   addMixins() {

package/src/spyne/channels/spyne-channel-lifecycle.js

@@ -30,7 +30,7 @@ export class SpyneChannelLifecycle extends Channel {
   }
 
   onViewStreamInfo(obj) {
-    let {data, action, srcElement} = obj.props();
+    let {data, action, srcElement} = obj;
     let payload = srcElement;
     payload['action'] = action;
     this.onSendEvent(action, payload);

package/src/spyne/channels/spyne-channel-route.js

@@ -1,12 +1,14 @@
 import { Channel } from './channel';
 import { SpyneUtilsChannelRouteUrl } from '../utils/spyne-utils-channel-route-url';
 import { SpyneUtilsChannelRoute } from '../utils/spyne-utils-channel-route';
+import {SpyneAppProperties} from '../utils/spyne-app-properties';
 import { ReplaySubject, merge } from 'rxjs';
 import { map } from 'rxjs/operators';
 
 import {
   clone,
   pick,
+    find,
   omit,
   over,
   mergeRight,
@@ -28,9 +30,10 @@ import {
   concat,
   when,
   complement,
+    reverse,
   curryN,
   __,
-  test, replace,
+  test, replace, fromPairs, toPairs, forEach, reduceRight, reduce
 } from 'ramda';
 const ramdaFilter = require('ramda').filter;
 const rMerge = require('ramda').mergeRight;
@@ -143,10 +146,10 @@ export class SpyneChannelRoute extends Channel {
 
   checkConfigForHash(){
     // LEGACY CHECK TO SIMPLIFY CONFIG FOR HASH;
-    let isHashType = window.Spyne.config.channels.ROUTE.type==='hash';
+    let isHashType = SpyneAppProperties.config.channels.ROUTE.type==='hash';
     if (isHashType === true){
-      window.Spyne.config.channels.ROUTE.type = 'slash';
-      window.Spyne.config.channels.ROUTE.isHash = true;
+      SpyneAppProperties.config.channels.ROUTE.type = 'slash';
+      SpyneAppProperties.config.channels.ROUTE.isHash = true;
     }
 
   }
@@ -176,13 +179,10 @@ export class SpyneChannelRoute extends Channel {
 
     const newRoutesObj  = pick(['isHash', 'isHidden', 'routes','type'], e.payload);
 
-    window.Spyne.config.channels.ROUTE =  mergeRight(window.Spyne.config.channels.ROUTE, newRoutesObj);
+    SpyneAppProperties.config.channels.ROUTE =  mergeRight(SpyneAppProperties.config.channels.ROUTE, newRoutesObj);
 
-    const clonedRoute = clone(window.Spyne.config.channels.ROUTE);
 
-    // ADD 404S, EMPTY REGEX AND CONVERT ARRAYS
-
-    window.Spyne.config = SpyneUtilsChannelRoute.conformRouteObject(window.Spyne.config);
+    SpyneAppProperties.conformRouteConfig();
 
 
      const routeConfig = this.getRouteConfig();
@@ -192,12 +192,11 @@ export class SpyneChannelRoute extends Channel {
     this.bindStaticMethodsWithConfigData();
 
 
-    this.sendChannelPayload(action, routeConfig, {}, {},
-        this.navToStream$);
+    this.sendChannelPayload(action, routeConfig, {}, {}, this.navToStream$);
   }
 
   getRouteConfig() {
-    const spyneConfig = window.Spyne.config;
+    const spyneConfig = SpyneAppProperties.config;
     let routeConfig = path(['channels', 'ROUTE'], spyneConfig);
     if (routeConfig.type === 'query') {
       routeConfig.isHash = false;
@@ -250,7 +249,7 @@ export class SpyneChannelRoute extends Channel {
     payload = rMerge(payload, keywordArrs);
     // console.log("SEND STREAM onIncomingDomEvent", payload, keywordArrs);;
    // payload = SpyneChannelRoute.removeSSID(payload);
-      this.sendChannelPayload(action, payload, undefined, undefined, this.navToStream$);
+      this.sendChannelPayload(action, payload, undefined, evt, this.navToStream$);
 
   }
 
@@ -297,10 +296,88 @@ export class SpyneChannelRoute extends Channel {
 */
 
 
+  static checkForEndRoute(pl, routeConfigJson = this.routeConfigJson, debugBool){
+
+    const endRoute = compose(equals("true"), path(['payload', 'endRoute']))(pl);
+    //console.log('pl and aend route',{endRoute, pl})
+
+    if (endRoute!==true){
+      return pl;
+    }
+    const win = window || {};
+    const debug = debugBool !== undefined ? debugBool : SpyneAppProperties.debug === true;
+     const {payload} = pl;
+
+
+      const getPropVal = (routePath) => {
+        const routeName = prop('routeName', routePath);
+        if (routeName){
+          const keysArr = compose(keys, omit(['routeName']))(routePath);
+          let routeNameVal = payload[routeName]
+          const pred = arrStr => new RegExp(`^${arrStr}$`).test(routeNameVal);
+          const routeVal = find(pred, keysArr);
+           // console.log('route val is ',{routeVal, keysArr})
+          return routeVal;
+
+        }
+      }
+
+      let iter = 0;
+      const onReduceRoutePaths = (acc=[], arr)=>{
+        const [key, val] = arr;
+        const {routePath} = val;
+        const routeName = prop('routeName', routePath);
+        const routeNameVal = getPropVal(routePath);
+        const isObj = is(Object, val);
+        const isArr = is(Array, val);
+        const iterObj = isObj === true && isArr === false;
+        iter = iter+1;
+        if (iterObj) {
+          const nextRoutePath = routePath[routeNameVal];
+          //console.log('key is ',{iter,acc,key, routeName, routeNameVal, iterObj, nextRoutePath});
+          if (nextRoutePath){
+              compose(reverse, reduce(onReduceRoutePaths, acc), toPairs)({nextRoutePath})
+          } else{
+            //console.log("KEY IS ",{iter,key, routeName, routeNameVal})
+            if (iter===1){
+              if (debug) {
+                console.warn(`Spyne Warning: use of end route method should add start route value of "${routeName}".`)
+              }
+            } else {
+              acc.push(routeName)
+            }
+          }
+         // compose(reduce(onReduceRoutePaths), toPairs)(nextRoutePath);
+        }
+        return acc;
+
+      }
+
+      const {routes} = routeConfigJson;
+
+      const endRouteValArr = compose(reverse, reduce(onReduceRoutePaths, []), toPairs)({routes});
+        //console.log('end route val arr ',endRouteValArr);
+        if(endRouteValArr.length===1){
+          const endRouteVal = endRouteValArr[0];
+          pl.payload[endRouteVal] = "";
+        } else{
+          if (debug) {
+           // console.warn(`Spyne Warning: the end route param did not yield any results for ${JSON.stringify(payload)} `);
+          }
+        }
+
+    return pl;
+
+  }
+
   onViewStreamInfo(pl) {
     let action = this.channelActions.CHANNEL_ROUTE_CHANGE_EVENT;
     SpyneChannelRoute.checkForEventMethods(pl);
+    pl = this.checkForEndRoute(pl);
     let payload = this.getDataFromParams(pl);
+    const {routeConfigJson} = this;
+    //console.log("LOADING ROUTE FROM LINK ", {pl, payload,routeConfigJson})
+
     let srcElement = prop('srcElement', pl);
     let event = prop('event', pl);
     let changeLocationBool = !payload.isHidden;
@@ -353,7 +430,7 @@ export class SpyneChannelRoute extends Channel {
     let isHash = config.isHash;
     let isHidden = config.isHidden;
     let routeType = config.type;
-    return { routeCount, isDeepLink, isHash, isHidden, routeType };
+    return { routeCount, isDeepLink, isHash,isHistory, isHidden, routeType };
   }
 
   static getDataFromParams(pl, config = this.routeConfigJson) {
@@ -373,7 +450,7 @@ export class SpyneChannelRoute extends Channel {
 
     routeData = rMerge(dataFromStr.routeData, routeData);
 
-    let { routeCount, isDeepLink, isHash, isHidden, routeType } = this.getExtraPayloadParams(
+    let { routeCount, isDeepLink, isHash,isHistory, isHidden, routeType } = this.getExtraPayloadParams(
       config);
     return {
       isDeepLink,
@@ -384,6 +461,7 @@ export class SpyneChannelRoute extends Channel {
       routeValue,
       isHash,
       isHidden,
+      isHistory,
       routeType
     };
   }
@@ -407,6 +485,7 @@ export class SpyneChannelRoute extends Channel {
       routeValue,
       isHash,
       isHidden,
+      isHistory,
       routeType
     };
     return obj;
@@ -496,6 +575,7 @@ export class SpyneChannelRoute extends Channel {
   }
 
   bindStaticMethods() {
+    this.checkForEndRoute = SpyneChannelRoute.checkForEndRoute.bind(this);
     this.getIsDeepLinkBool = SpyneChannelRoute.getIsDeepLinkBool.bind(this);
     this.getDataFromLocationStr = SpyneChannelRoute.getDataFromLocationStr.bind(
       this);

package/src/spyne/channels/spyne-channel-ui.js

@@ -44,6 +44,7 @@ export class SpyneChannelUI extends Channel {
       'CHANNEL_UI_CHECKBOXSTATECHANGE_EVENT',
       'CHANNEL_UI_CLICK_EVENT',
       'CHANNEL_UI_COMPLETE_EVENT',
+      'CHANNEL_UI_CONTEXTMENU_EVENT',
       'CHANNEL_UI_COPY_EVENT',
       'CHANNEL_UI_CUT_EVENT',
       'CHANNEL_UI_DBLCLICK_EVENT',

package/src/spyne/channels/spyne-channel-window.js

@@ -1,9 +1,10 @@
 import { Channel } from './channel';
 import { checkIfObjIsNotEmptyOrNil } from '../utils/frp-tools';
+import {SpyneAppProperties} from '../utils/spyne-app-properties';
 import { SpyneUtilsChannelWindow } from '../utils/spyne-utils-channel-window';
 import { merge } from 'rxjs';
 import { map, debounceTime, skipWhile } from 'rxjs/operators';
-import {curry, pathEq, pick, partialRight, mapObjIndexed, apply} from 'ramda';
+import {curry, pathEq, path, pick, partialRight, mapObjIndexed, apply} from 'ramda';
 import {deepMerge} from '../utils/deep-merge';
 
 const rMap = require('ramda').map;
@@ -37,11 +38,13 @@ export class SpyneChannelWindow extends Channel {
     super(CHANNEL_NAME);
     this.bindStaticMethods();
     this.currentScrollY=0;
+
+    //this.spyneScrollLock = SpyneAppProperties.scrollLock;
     // this.props.name = 'WINDOW';
   }
 
   initializeStream() {
-    this.domChannelConfig = window.Spyne.config.channels.WINDOW;
+    this.domChannelConfig = SpyneAppProperties.config.channels.WINDOW;
     let obs$Arr = this.getActiveObservables();
     let dom$ = merge(...obs$Arr);
     this.dom$ = dom$;
@@ -140,10 +143,12 @@ export class SpyneChannelWindow extends Channel {
     return { action, payload, srcElement, scrollDistance, event };
   }
 
-  createScrollObservable(config, scrollElement=window) {
+  createScrollObservable(config, scrollElement=window, isPassive = true) {
     const skipWhenDirIsMissing = evt => evt.scrollDistance === 0;
     const dTime = config.debounceMSTimeForScroll;
 
+    const element = scrollElement;
+
 
     const isWindow = scrollElement === window;
 
@@ -153,20 +158,19 @@ export class SpyneChannelWindow extends Channel {
 
     const scrollDataFn =SpyneChannelWindow.getScrollData();
      // console.log("SCROLL ELEMENT ",action,scrollElement, scrollElForVals);
-    const scrollMapFn =partialRight(SpyneChannelWindow.getScrollMapFn, [action, scrollDataFn, scrollElForVals]).bind(this);
+    const scrollMapFn =partialRight(SpyneChannelWindow.getScrollMapFn, [action, scrollDataFn, scrollElForVals, isPassive, element]).bind(this);
+
+   // console.log("createScrollObservable ", {scrollMapFn, scrollDataFn, action, config, scrollElement, element})
+
 
-    /**
-     * TODO: curry createDomObservableFromEvent so that element can be other than window.
-     *
-     */
 
     return SpyneUtilsChannelWindow.createDomObservableFromEvent('scroll',
-        scrollMapFn)
+        scrollMapFn, isPassive, element)
       .pipe(
          /* map(p=>{
             if (pathEq(['Spyne', 'config', 'scrollLock'], true)(scrollElement)){
-              let x = window.Spyne.config.scrollLockX
-              let y = window.Spyne.config.scrollLockY;
+              let x = SpyneAppProperties.config.scrollLockX
+              let y = SpyneAppProperties.config.scrollLockY;
               window.scrollTo(x,y);
             }
             return p;
@@ -174,7 +178,8 @@ export class SpyneChannelWindow extends Channel {
         debounceTime(dTime),
         skipWhile(skipWhenDirIsMissing),
         map(p=>{
-          const newScrollY = SpyneChannelWindow.getScrollY(window);
+          const newScrollY = SpyneChannelWindow.getScrollY(element);
+          //console.log("SCROLL P IS ",{p});
           p.payload['scrollDistanceAbs'] = Math.abs(this.currentScrollY-newScrollY);
           this.currentScrollY=newScrollY;
           return p;
@@ -213,7 +218,8 @@ export class SpyneChannelWindow extends Channel {
     // CHECK TO ADD MEDIA QUERY OBSERVABLE
     // ==========================================
     config['listenForMediaQueries'] = checkIfObjIsNotEmptyOrNil(
-      config.mediqQueries);
+      config.mediaQueries) || checkIfObjIsNotEmptyOrNil(
+        config.mediqQueries);
 
     // =========================================
 
@@ -317,6 +323,7 @@ export class SpyneChannelWindow extends Channel {
       'CHANNEL_WINDOW_RESET_EVENT',
       'CHANNEL_WINDOW_RESIZE_EVENT',
       'CHANNEL_WINDOW_ELEMENT_SCROLL_EVENT',
+      'CHANNEL_WINDOW_SCROLL_ELEMENT_ADDED_EVENT',
       ['CHANNEL_WINDOW_SET_ELEMENT_TO_SCROLL_EVENT', 'onSetElementToScroll'],
       'CHANNEL_WINDOW_SCROLL_EVENT',
       'CHANNEL_WINDOW_SCROLL_LOCK_EVENT',
@@ -333,23 +340,56 @@ export class SpyneChannelWindow extends Channel {
 
   onScrollLockEvent(e){
     const setScrollPos = ()=>{
-      window.Spyne.config.scrollLockX = window.scrollX;
-      window.Spyne.config.scrollLockY = window.scrollY;
+      SpyneAppProperties.config.scrollLockX = window.scrollX;
+      SpyneAppProperties.config.scrollLockY = window.scrollY;
+      this.spyneScrollLock.setScroll();
     };
-    let {action, scrollLock} = e.props();
-    window.Spyne.config.scrollLock = scrollLock;
+    let {action, scrollLock, el} = e.payload;
+    SpyneAppProperties.config.scrollLock = scrollLock;
+    el = el || window;
     if (scrollLock === true){
-      setScrollPos();
+     // setScrollPos();
+
+      this.spyneScrollLock.disableBodyScroll();
+      const id = path(['srcElement', 'id'], e);
+      /**
+       * TODO: ADD EL TO Scroll lock --- this is hard coded .scroll-lock class
+       *
+       * */
+       //el = document.querySelector(`#${id} .card-scroll`);
+      //console.log("E TO SCROLL IS ",{id,el,e});
+     // this.onSetElementToScroll({}, el);
+
+      this.createScrollObservable(this.domChannelConfig, el, true)
+      .subscribe(p => {
+        let { action, payload, srcElement, event } = p;
+        //console.log("SCROLL OBS IS ",p)
+        this.sendChannelPayload(action, payload, srcElement, event);
+      });
+
+
+
+    } else {
+      this.spyneScrollLock.enableBodyScroll();
     }
 
-    this.sendChannelPayload(action, {scrollLock});
+    //console.log('scroll lock window channel ',{action,scrollLock});
+
+    this.sendChannelPayload(action, {scrollLock}, el);
   }
 
   onSetElementToScroll(e){
 
-    let {config, scrollElement} = e.props();
+    let {config, el, scrollElement} = e.payload;
+    config = config || {};
     config = deepMerge(this.domChannelConfig, config);
 
+    scrollElement = scrollElement || el;
+    //console.log('set elemenet to scroll ',{scrollElement})
+
+    const action = "CHANNEL_WINDOW_SCROLL_ELEMENT_ADDED_EVENT";
+    this.sendChannelPayload(action, {el}, el);
+
     this.createScrollObservable(config, scrollElement)
     .subscribe(p => {
       let { action, payload, srcElement, event } = p;