spyne 0.16.0 → 0.18.0

package/src/spyne/channels/channel-fetch-class.js

@@ -1,6 +1,6 @@
 import { Channel } from './channel';
 import { ChannelFetchUtil } from '../utils/channel-fetch-util';
-import {path, pick, mergeDeepRight, defaultTo, reject, compose, isNil} from 'ramda';
+import {path, pick, mergeDeepRight, all, allPass, either, values, defaultTo, reject, compose, isNil} from 'ramda';
 
 export class ChannelFetch extends Channel {
   /**
@@ -50,7 +50,11 @@ export class ChannelFetch extends Channel {
   constructor(name, props = {}) {
 
     // ALLOW FOR GENERIC MAP PROPERTY
+
+    ChannelFetch.validateMapMethod(props, name);
+
     if (props.map!==undefined){
+
       props.mapFn = props.map;
     }
     props.extendedActionsArr = [
@@ -61,6 +65,25 @@ export class ChannelFetch extends Channel {
     super(name, props);
   }
 
+  static validateMapMethod(props, name, testMode=false){
+    const isNotEmpty = arr=>arr.length>=1
+    const isNotFunction = val => typeof(val)!=='function';
+    const isUndefinedOrWrongType = either(isNil, isNotFunction)
+    const isUndefined = all(isUndefinedOrWrongType);
+    const isNotUndefinedAndIsNotEmpty = allPass([isUndefined, isNotEmpty])
+    const mapMethodIsInvalid = compose(isNotUndefinedAndIsNotEmpty,values, pick(['map', 'mapFn']))(props)
+
+    if (mapMethodIsInvalid){
+      if(testMode===false) {
+        console.warn(`Spyne Warning: The map method for ChannelFetch, ${name}, appears to be invalid`);
+      }
+      return false;
+    }
+
+    return true;
+
+  }
+
   onRegistered() {
     this.startFetch();
   }
@@ -86,12 +109,10 @@ export class ChannelFetch extends Channel {
   }
 
   onFetchReturned(streamItem) {
-    let payload = this.createChannelPayloadItem(streamItem);
+    return this.createChannelPayloadItem(streamItem);
   }
 
   createChannelPayloadItem(payload, action = `${this.props.name}_DATA_EVENT`) {
-   // console.log("FETCH ",this.props.name, {action,payload});
-    // return new ChannelPayload(this.props.name, action, payload);
     this.sendChannelPayload(action, payload);
   }
 
@@ -101,7 +122,6 @@ export class ChannelFetch extends Channel {
   }
 
   consolidateAllFetchProps(options, props = this.props) {
-    // let currentOptions = mergeRight({url}, options);
     let propsOptions = pick(['mapFn', 'url', 'header', 'body', 'mode', 'method', 'responseType', 'debug'], props);
     const mergeOptions = (o1, o2) => mergeDeepRight(o1, o2);
     const filterOutUndefined = reject(isNil);

package/src/spyne/channels/channel-payload-class.js

@@ -4,14 +4,14 @@ import {
   fromPairs,
   toPairs,
   compose,
-  mergeDeepRight,
-  mergeRight,
-  pathEq,
   includes,
   pickAll,
-  __,
-  lte, defaultTo, prop, is, mapObjIndexed,
+  lte,
+  defaultTo,
+  prop,
+  is
 } from 'ramda';
+import {SpyneAppProperties} from '../utils/spyne-app-properties';
 
 export class ChannelPayload {
   /**
@@ -44,7 +44,8 @@ export class ChannelPayload {
 
     let channelPayloadItemObj = { channelName, action, srcElement, event };
    // Object.defineProperty(channelPayloadItemObj, 'payload', {get: () => clone(payload)});
-    channelPayloadItemObj['payload'] = ChannelPayload.deepFreeze(payload);
+    const frozenPayload = ChannelPayload.deepFreeze(payload);
+    channelPayloadItemObj['payload'] = frozenPayload;
     /**
      * This is a convenience method that helps with destructuring by merging all properties.
      *
@@ -59,45 +60,57 @@ export class ChannelPayload {
      */
 
 
-    const isDebugMode =  pathEq(['Spyne','config', 'debug'], true)(window);
 
-    if (isDebugMode === true){
-      if (payload.hasOwnProperty('payload')){
+    if (SpyneAppProperties.debug === true){
+      if (Object.prototype.hasOwnProperty.call(payload, 'payload')){
         let payloadStr = JSON.stringify(payload);
         console.warn(`Spyne Warning: the following payload contains a nested payload property which may create conflicts: Action: ${action}, ${payloadStr}`);
       }
+
+      const channelActionsArr = SpyneAppProperties.getChannelActions(channel);
+
+      ChannelPayload.validateAction(action, channel, channelActionsArr);
+
+
     }
 
 
 
-    channelPayloadItemObj.props = () => clone(mergeAll([
+    channelPayloadItemObj.clone = () => clone(mergeAll([
         {payload:ChannelPayload.deepClone(channelPayloadItemObj.payload)},
       channelPayloadItemObj.payload,
         { channel },
         { event: event },
+        {srcElement: srcElement},
                 channelPayloadItemObj.srcElement, {
         action: channelPayloadItemObj.action }
          ]));
 
 
-    const channelActionsArr = window.Spyne.getChannelActions(channel);
 
-    ChannelPayload.validateAction(action, channel, channelActionsArr);
+    const channelPayloadItemObjProps = {
+      $dir: {
+        get: () => channelPayloadItemObj._dir,
+        set: (val) => channelPayloadItemObj._dir=val
+      }
+    }
+
+
 
     if (channel === 'CHANNEL_ROUTE') {
-      channelPayloadItemObj['location'] = ChannelPayload.getLocationData();
+      //channelPayloadItemObj['location'] = ChannelPayload.getLocationData();
+      channelPayloadItemObjProps['location'] = {
+        get: ()=>ChannelPayload.getLocationData()
+      }
+     /* channelPayloadItemObjProps['routeData'] = {
+        get: ()=>prop('routeData', frozenPayload)
+      }
+*/
     }
-   // return window.Spyne.createDataPacket(channelPayloadItemObj, ['channelName', 'action']);
 
     channelPayloadItemObj._dir = undefined;
 
-    Object.defineProperties(channelPayloadItemObj, {
-      $dir: {
-        get: () => channelPayloadItemObj._dir,
-        set: (val) => channelPayloadItemObj._dir=val
-      }
-
-    })
+    Object.defineProperties(channelPayloadItemObj, channelPayloadItemObjProps)
 
     if(timeLabel){
       console.timeEnd(timeLabel);
@@ -107,7 +120,7 @@ export class ChannelPayload {
 
   static validateAction(action, channel, arr) {
     let isInArr = includes(action, arr);
-    if (isInArr === false && window.Spyne !== undefined) {
+    if (isInArr === false && SpyneAppProperties.initialized === true) {
       console.warn(`warning: Action: '${action}' is not registered within the ${channel} channel!`);
     }
     return isInArr;
@@ -150,7 +163,7 @@ export class ChannelPayload {
     try {
       Object.freeze(o);
       Object.getOwnPropertyNames(o).forEach(function(prop) {
-        if (o.hasOwnProperty(prop)
+        if (Object.prototype.hasOwnProperty.call(o,prop)
             && elIsDomElement(o[prop]) === false
             && o[prop] !== null
             && (typeof o[prop] === "object" || typeof o[prop] === "function")

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

@@ -1,6 +1,8 @@
 import { Channel } from './channel';
+import {SpyneAppProperties} from '../utils/spyne-app-properties';
 import { Subject, ReplaySubject, merge } from 'rxjs';
-import {includes, path} from 'ramda';
+import {includes} from 'ramda';
+import {delayCall} from '../utils/frp-tools';
 
 export class ChannelProxy extends Channel {
   /**
@@ -22,7 +24,7 @@ export class ChannelProxy extends Channel {
     this.subject$ = new Subject();
     this.replaySub$ = new ReplaySubject(1);
     this.observer$ = merge(this.subject$, this.replaySub$);
-	const isDevMode = path(['Spyne', 'config', 'debug'], window) === true;
+	const isDevMode = SpyneAppProperties.debug;
     if (isDevMode === true){
       this.checkIfChannelIsStillProxy(name);
     }
@@ -36,14 +38,14 @@ export class ChannelProxy extends Channel {
     let name = channelName;
 
     const checkIfProxy=()=>{
-      //console.log("CHANNELS ",window.Spyne.channels.listRegisteredChannels());
-      let bool = includes(name, window.Spyne.channels.listRegisteredChannels());
+      let bool = includes(name, SpyneAppProperties.listRegisteredChannels());
       if (bool!==true){
         console.warn(`Spyne Warning: The channel, ${name} does not appear to be registered!`);
       }
     };
 
-    window.setTimeout(checkIfProxy, 1000);
+    delayCall(checkIfProxy, 1000);
+
   }
 
   get replaySubject() {

package/src/spyne/channels/channel.js

@@ -1,6 +1,6 @@
 import { registeredStreamNames } from './channels-config';
 import { ChannelPayload } from './channel-payload-class';
-import { ChannelPayloadFilter} from '../utils/channel-payload-filter';
+import {SpyneAppProperties} from '../utils/spyne-app-properties';
 import {RouteChannelUpdater} from '../utils/route-channel-updater';
 import { ReplaySubject, Subject } from 'rxjs';
 import {filter} from 'rxjs/operators';
@@ -18,10 +18,10 @@ import {
   always,
   fromPairs,
   path,
- assocPath,
+  isEmpty,
   equals,
   prop,
-  apply,
+  propEq
 } from 'ramda';
 const rMap = require('ramda').map;
 
@@ -71,21 +71,28 @@ export class Channel {
     this.addRegisteredActions.bind(this);
     this.createChannelActionsObj(CHANNEL_NAME, props.extendedActionsArr);
     props.name = CHANNEL_NAME;
+    props.defaultActions = props.data!==undefined ? [`${props.name}_EVENT`] : [];
     this.props = props;
     this.props.isRegistered = false;
     this.props.isProxy = this.props.isProxy === undefined ? false : this.props.isProxy;
-    this.props.sendCachedPayload = this.props.sendCachedPayload === undefined ? false : this.props.sendCachedPayload;
+    const defaultCachedPayloadBool = this.props['data']!==undefined;
+    this.props.sendCachedPayload = this.props.sendCachedPayload === undefined ? defaultCachedPayloadBool : this.props.sendCachedPayload;
     this.sendPayloadToRouteChannel = new RouteChannelUpdater(this);
     this.createChannelActionMethods();
-    this.streamsController = window.Spyne.channels;// getGlobalParam('streamsController');
+    this.streamsController = SpyneAppProperties.channelsMap;
     let observer$ = this.getMainObserver();
-
+    this.checkForPersistentDataMode = Channel.checkForPersistentDataMode.bind(this);
     this.observer$ = this.props['observer'] = observer$;
     let dispatcherStream$ = this.streamsController.getStream('DISPATCHER');
-    dispatcherStream$.subscribe((val) => this.onReceivedObservable(val));
+    const payloadPredByChannelName = propEq('name', props.name)
+    dispatcherStream$.pipe(filter(payloadPredByChannelName)).subscribe((val) => this.onReceivedObservable(val));
   }
 
   getMainObserver() {
+    if (this.streamsController === undefined){
+      console.warn(`Spyne Warning: The following channel, ${this.props.name}, appears to be registered before Spyne has been initialized.`)
+    }
+
     let proxyExists = this.streamsController.testStream(this.props.name);
 
     if (proxyExists === true) {
@@ -109,7 +116,13 @@ export class Channel {
    * <p>This method is empty and is called as soon as the Channel has been registered.</p>
    * <p>Tasks such as subscribing to other channels, and sending initial payloads can be added here.</p>
    */
-  onRegistered(){
+  onRegistered(props=this.props){
+      if(props.data!==undefined){
+        const action = Object.keys(this.channelActions)[0];
+          //console.log("CHANNELS ACTIONS IS ",this.channelActions);
+        //Object(this.channelActions).keys[0];
+        this.sendChannelPayload(action, props.data);
+      }
 
   }
 
@@ -136,7 +149,7 @@ export class Channel {
         traits = [traits];
       }
       const addTrait=(TraitClass)=>{
-        new TraitClass(this);
+        return new TraitClass(this);
       };
 
       traits.forEach(addTrait);
@@ -151,12 +164,39 @@ export class Channel {
   initializeStream() {
     this.checkForTraits();
     this.onChannelInitialized();
+    this.checkForPersistentDataMode();
     this.onRegistered();
     this.props.isRegistered = true;
 
 
   }
 
+  static checkForPersistentDataMode(props=this.props, actionsObj=this.channelActions){
+    const actionsObjIsEmpty = isEmpty(actionsObj);
+    const dataIsAdded = prop('data', props) !== undefined;
+    const autoSetToCachedPayload = actionsObjIsEmpty === true && dataIsAdded === true;
+    const setDefaultActionsObj = ()=>{
+      const {name} = props;
+      const actionStr = `${name}_EVENT`;
+      return {
+        [actionStr] : actionStr
+      }
+    }
+
+    if (autoSetToCachedPayload){
+      props.sendCachedPayload = true;
+      actionsObj = setDefaultActionsObj();
+
+      if (this.channelActions!==undefined){
+        this.channelActions = actionsObj;
+      }
+    }
+
+
+    //console.log("PROPS IS ",{actionsObjIsEmpty, dataIsAdded, props, actionsObj}, this.channelActions)
+    return {props, actionsObj};
+  }
+
   setTrace(bool) {
   }
 
@@ -219,7 +259,11 @@ export class Channel {
    *
    */
   addRegisteredActions() {
-    return [];
+    let arr = []
+    if (path(['props','data'], this)){
+      arr = [`${this.props.name}_EVENT`];
+    }
+    return arr;
   }
 
   onReceivedObservable(obj) {
@@ -356,24 +400,6 @@ export class Channel {
     return fn(CHANNEL_NAME);
   }
 
-  /**
-   *
-   * Wraps window.setTimeout with a check to see if "this" ViewStream element and its props property still exists
-   * @property {function} fn - = 'function'; The local method that is to be called.
-   * @property {number} ms - = 0;  The time, in milleseconds, for the timeout.
-   * @property {boolean} bind - = false;  When true, will bind the method to 'this'.
-   *
-   */
-
-  setTimeout(fn, ms=0, bind=false){
-    const timeoutMethod = (...args)=>{
-      if (this!==undefined && this.props!==undefined){
-        const methodFn = bind===true ? fn.bind(this) : fn;
-        apply(methodFn, args);
-      }
-    }
-    window.setTimeout(timeoutMethod, ms);
-  }
 
 
 

package/src/spyne/channels/channels-config.js

@@ -1,13 +1,11 @@
-// import Spyne from '../spyne';
-import { arrFromMapKeys } from '../utils/frp-tools';
-
+import {SpyneAppProperties} from '../utils/spyne-app-properties';
 import {compose, path, is} from 'ramda';
 const Observable = require('rxjs');
 const Subject = require('rxjs');
 
 // console.log('channels config loaded ',R,Rx);
 let registeredStreamNames = () => ({
-  includes:  () => window.Spyne !== undefined ? arrFromMapKeys(window.Spyne.channels.map) : ['CHANNEL_ROUTE', 'CHANNEL_UI', 'CHANNEL_WINDOW', 'DISPATCHER']
+  includes:  () => SpyneAppProperties.initialized === true ? SpyneAppProperties.listRegisteredChannels() : ['CHANNEL_ROUTE', 'CHANNEL_UI', 'CHANNEL_WINDOW', 'DISPATCHER']
 
 });
 

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

@@ -1,19 +1,16 @@
-// import {baseCoreMixins}    from '../utils/mixins/base-core-mixins';
-// import {BaseStreamsMixins} from '../utils/mixins/base-streams-mixins';
 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 { Subject } from 'rxjs';
 import { ChannelProxy } from './channel-proxy';
-import {propEq, pluck, prop, filter, pathEq, clone, reject, compose, join} from 'ramda';
+import {propEq, pluck, prop, filter, pathEq, 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 +25,13 @@ export class ChannelsDelegator {
 
   constructor() {
     this.addMixins();
-    this.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 +40,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) {
@@ -69,84 +65,72 @@ export class ChannelsDelegator {
       let channels = compose(join(', '), rMap(prop('key')))(filterProxyArr);
       let filterPrefixWarning = `Spyne Warning: The following ${channelStr} not been initialized: ${channels}`;
       console.warn(filterPrefixWarning);
-      // console.log("FILTER PROXY WARNING ",filterProxyArr);
     }
 
-    // console.log(filterProxy(proxyMap),' proxyMap ', proxyMap);
   }
 
   init() {
     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());
-  }
 
   createMainStreams() {
     this.routeStream = new SpyneChannelRoute();
-    this.map.set('CHANNEL_ROUTE', this.routeStream);
-    window.Spyne.config.channels['CHANNEL_ROUTE'] = {};
+    _map.set('CHANNEL_ROUTE', this.routeStream);
 
     this.uiStream = new SpyneChannelUI();
-    this.map.set('CHANNEL_UI', this.uiStream);
-    window.Spyne.config.channels['CHANNEL_UI'] = {};
+    _map.set('CHANNEL_UI', this.uiStream);
 
     this.domStream = new SpyneChannelWindow();
-    this.map.set('CHANNEL_WINDOW', this.domStream);
-    window.Spyne.config.channels['CHANNEL_WINDOW'] = {};
-    
+    _map.set('CHANNEL_WINDOW', this.domStream);
+
     this.viewStreamLifecycle = new SpyneChannelLifecycle();
-    this.map.set('CHANNEL_LIFECYCLE', this.viewStreamLifecycle);
-    window.Spyne.config.channels['CHANNEL_LIFECYCLE'] = {};
+    _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;
-    const nameExists = this.map.has(name);
+    const nameExists = _map.has(name);
     if (nameExists){
-      const isAlreadyRegisterd = compose(pathEq(['props', 'isRegistered'], true))(this.map.get(name));
+      const isAlreadyRegisterd = compose(pathEq(['props', 'isRegistered'], true))(_map.get(name));
       if(isAlreadyRegisterd){
         console.warn(`Spyne Warning: The Channel, ${name}, has already been registered!`);
         return;
       }
     }
 
-    window.Spyne.config.channels[name] = {};
 
-    this.map.set(name, val);
+    _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

@@ -1,5 +1,4 @@
 import { Channel } from './channel';
-import {prop} from 'ramda';
 
 export class SpyneChannelLifecycle extends Channel {
   /**
@@ -30,7 +29,7 @@ export class SpyneChannelLifecycle extends Channel {
   }
 
   onViewStreamInfo(obj) {
-    let {data, action, srcElement} = obj;
+    let {action, srcElement} = obj;
     let payload = srcElement;
     payload['action'] = action;
     this.onSendEvent(action, payload);