spyne 0.14.8 → 0.17.3

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

@@ -1,5 +1,47 @@
-import {is, reject, ifElse, invoker, identity, isNil, allPass, tap, forEachObjIndexed, not, isEmpty, always, compose,  equals, prop, where, defaultTo, path, flatten, any,type, curry} from 'ramda';
+import {
+  is,
+  reject,
+  ifElse,
+  invoker,
+  identity,
+  assoc,
+  isNil,
+    find,
+  allPass,
+  tap,
+  forEachObjIndexed,
+  not,
+  isEmpty,
+  always,
+  compose,
+  equals,
+  prop,
+  where,
+  defaultTo,
+  mergeAll,
+  __,
+  omit,
+  path,
+  call,
+  clone,
+  flatten,
+  any,
+  type,
+  curry,
+  mergeRight, lte,
+} from 'ramda';
+
+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 isObjectFn = compose(allPass([isNotArr, is(Object)]))
+const isNonEmptyObjectFn = compose(allPass([isNotEmpty, isNotArr, is(Object)]))
+
 export class ChannelPayloadFilter {
   /**
    * @module ChannelPayloadFilter
@@ -19,8 +61,8 @@ export class ChannelPayloadFilter {
    *   </ul>
    *
    * @constructor
-   * @param {Object} filters Object that contains the selector, props, and label params.
    * @property {String|Array|HTMLElement} selector The matching element
+   * @param {Object} filters Object that contains the selector, props, and debugLabel params.
    * @property {Object} propFilters A json object containing filtering methods for channel props variables.
    *
    * @property {String|Array|HTMLElement} selector - = ''; The matching element.
@@ -67,43 +109,79 @@ export class ChannelPayloadFilter {
    * .subscribe(myChannelMethod);
    *
    */
-  constructor(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 makeBool = b => Boolean(b);
+
+    debugLabel = compose(find(is(String)))(debugLabelArr);
+
+    let props = omit(['debugLabel', 'label', 'selector', 'props', 'testMode', 'propFilters'], filters)
     if (filters.props!==undefined) {
-      filters['propFilters'] = prop('props', filters);
+      props = mergeAll([filters.props, props])
+
+    } else if (filters.propFilters!==undefined) {
+      props = mergeAll([filters.propFilters, props])
     }
-    let {selector,propFilters,label} = filters;
-    //console.log("VALUES OF FILTERS ",{selector,propFilters,label});
-    const isNotEmpty = compose(not, isEmpty);
-    const isNonEmptyStr = allPass([is(String), isNotEmpty]);
-    const isNonEmptyArr = allPass([is(Array), isNotEmpty]);
-    const addStringSelectorFilter =  isNonEmptyStr(selector) ? ChannelPayloadFilter.filterSelector([selector]) : undefined;
-    const addArraySelectorFilter =   isNonEmptyArr(selector) ? ChannelPayloadFilter.filterSelector(selector) : undefined;
 
+    filters['propFilters'] = props;
+
+    let {propFilters} = filters;
+    //console.log("selector filters ", {selector, filters})
+
+    // let {selector,propFilters,debugLabel} = filters;
+
+    const addStringSelectorFilter =  isNonEmptyStr(selector) ? ChannelPayloadFilter.filterSelector([selector], debugLabel) : undefined;
+    const addArraySelectorFilter =   isNonEmptyArr(selector) ? ChannelPayloadFilter.filterSelector(selector, debugLabel) : undefined;
 
-    const addDataFilter = is(Object, propFilters) ? ChannelPayloadFilter.filterData(propFilters, label) : undefined;
+
+    const addDataFilter = isNonEmptyObjectFn(propFilters) ? ChannelPayloadFilter.filterData(propFilters, debugLabel) : undefined;
 
     //console.log("IS STRING ",{selector, addStringSelectorFilter, addArraySelectorFilter, addDataFilter},isNonEmptyStr(selector))
 
 
 
     let filtersArr = reject(isNil, [addStringSelectorFilter, addArraySelectorFilter, addDataFilter]);
+   // console.log('filtersArr is ',{selector})
 
       // IF ARRAY IS EMPTY ALWAYS RETURN FALSE;
 
-      if (isEmpty(filtersArr)){
-        filtersArr = [always(false)];
+      const filtersAreEmpty = isEmpty(filtersArr);
 
-        if (path(['Spyne', 'config', 'debug'], window) === true){
+      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!`);
         }
 
       }
 
+
+    //console.log(" VALUES OF FILTERS ",{selector,propFilters,filters,debugLabel,testMode, filtersAreEmpty});
+    if (testMode === true){
+        return {selector, propFilters, debugLabel, filters, testMode, filtersAreEmpty};
+      }
+
     return allPass(filtersArr);
   }
 
-  static filterData(filterJson, filterLabel) {
-    const label = filterLabel;
+  static filterData(filterJson, filterdebugLabel) {
+    const debugLabel = filterdebugLabel;
+
+    //console.log('filter data is ',{filterJson, debugLabel})
     let compareData = () => {
       // DO NOT ALLOW AN EMPTY OBJECT TO RETURN TRUEs
       if (isEmpty(filterJson)) {
@@ -138,35 +216,74 @@ export class ChannelPayloadFilter {
       // TAP LOGGER
 
       const tapLogger = (comparedObj)=>{
-        if (label===undefined){
+        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 '${label}': `, "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;
-        };
+      };
 
       // END TAP LOGGER
 
       let fMethod = where(filterJson);
-      const getFilteringObj =  ifElse(prop('props'), invoker(0, 'props'), identity);
+
+      let getFilteringObj =  (v)=>{
+        const {payload, srcElement, event} = v || {};
+        const o = Object.assign({}, v, event, payload);
+        //console.log('o is ',o);
+        return o;
+      }
+
+
       return compose( fMethod, tapLogger, defaultTo({}),  getFilteringObj);
+
     };
+   // const filterLabel = `filtering-${Math.floor(Math.random()*999999)}`;
+    //console.time(filterLabel);
+   // const val = compareData();
 
+    //console.timeEnd(filterLabel);
+    //return val;
     return compareData();
   }
 
-  static checkPayloadSelector(arr, payload) {
+
+  static checkPayloadSelector(arr, debugLabel, srcPayload) {
     // ELEMENT FROM PAYLOADs
 
-    let payloadIsNotProps = compose(equals('Function'),type, prop('props')  )(payload);
-    payload = payloadIsNotProps === true ? payload.props() : payload;
 
+    const {payload, srcElement, event} = srcPayload || {};
+    //console.log('payload before ',{srcPayload, payload, srcElement, event})
+
+    const reduceFindEl = (acc, src) => {
+      const el = prop('el', src);
+      //console.log("EL IS ",{el, src, acc})
+      if (ChannelPayloadFilter.elIsDomElement(el) && acc===undefined){
+        acc = el;
+       // return acc;
+      }
+      return acc;
+    }
+
+    const el = [srcElement, payload, prop('srcElement', event), srcPayload].reduce(reduceFindEl, undefined);
+
+
+    //console.log('el check ',{debugLabel, srcElement, payload, event, el})
+
+    //const o = Object.assign({}, srcPayload, event,srcElement, payload);
+
+    //console.log('o is ',o);
 
-    let el = path(['el'], payload);
+
+    //let payloadIsNotProps = compose(equals('Function'),type, prop('props')  )(payload);
+    //payload = payloadIsNotProps === true ? payload.payload : payload;
+   // console.log('payload after ',{o})
+
+   // let el = path(['el'], o);
 
     // RETURN BOOLEAN MATCH WITH PAYLOAD EL
     const compareEls = (elCompare) => elCompare.isEqualNode((el));
@@ -179,6 +296,15 @@ export class ChannelPayloadFilter {
       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});
+
+
+    }
+
     // CHECK IF PAYLOAD EL EXISTS
     if (typeof (el) !== 'object') {
       return false;
@@ -193,9 +319,19 @@ export class ChannelPayloadFilter {
     return any(equals(true), nodeArrResult);
   }
 
-  static filterSelector(selectorArr) {
+  static elIsDomElement(o) {
+    if (is(String,o)){
+      o = document.querySelector(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);
+    return payloadCheck(arr, debugLabel);
   }
 }

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

@@ -6,6 +6,26 @@ const isIOS = () => {
   return ios === true;
 };
 
+
+const delayCall = async(fn, time)=>{
+
+  function sleep (ms) {
+    return new Promise(resolve => setTimeout(resolve, ms))
+  }
+
+  const timeoutHandler = async() => {
+    await sleep(1);
+    window.requestAnimationFrame(fn);
+  }
+
+  window.setTimeout(timeoutHandler, time)
+
+
+}
+
+
+
+
 const getConstructorName = (obj) => {
   if (obj.constructor.name !== undefined) {
     return obj.constructor.name;
@@ -142,4 +162,4 @@ 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 };
+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 };

package/src/spyne/utils/mixins/base-streams-mixins.js

@@ -6,6 +6,7 @@ export function baseStreamsMixins() {
       console.log('stream mixin is ', str);
     },
     sendRoutePayload: function(obs, data) {
+      /**TODO: ADD A CHECK FOR END ROUTE AND TRANSFORM TO EMPTY*/
       return new ViewStreamPayload('CHANNEL_ROUTE', obs, data, 'subscribe');
     },
     sendUIPayload: function(obs, data) {

package/src/spyne/utils/spyne-app-properties.js

@@ -0,0 +1,213 @@
+import {SpyneUtilsChannelRoute} from './spyne-utils-channel-route';
+import {SpyneScrollLock} from './spyne-scroll-lock';
+import {SpynePluginsMethods} from './spyne-plugins-methods';
+import {ChannelsMap} from '../channels/channels-map';
+import {deepMerge} from './deep-merge';
+import {prop, path} from 'ramda';
+
+let _config;
+let _channels;
+let _channelsMap
+let _initialized = false;
+let _debug = true;
+
+const _spyneScrollLock = new SpyneScrollLock();
+const _spynePluginMethods = new SpynePluginsMethods();
+
+
+class SpyneAppPropertiesClass{
+
+  constructor() {
+
+
+  }
+
+
+
+  initialize(defaultConfig={}, config={}, channelsMap){
+    _channels = channelsMap;
+    const userConfig = SpyneUtilsChannelRoute.conformRouteObject(config);
+    _config = deepMerge(defaultConfig, userConfig);
+    _debug = _config.debug!== undefined ? _config.debug : _debug;
+    this.getChannelActions = _channels.getChannelActions.bind(_channels);
+    this.listRegisteredChannels = _channels.listRegisteredChannels.bind(_channels);
+    _initialized = true;
+   // if (channelsMap!==undefined) {
+      this.setChannelsMap();
+    //}
+
+    return _config;
+
+  }
+
+  conformRouteConfig(add404Props=false){
+    /**
+     * THIS METHOD IS PRIMARILY USED FOR SPA GEN SITE GENERATION
+     */
+
+    _config = SpyneUtilsChannelRoute.conformRouteObject(_config, add404Props);
+
+  }
+
+
+
+  setChannelsMap(){
+    let obj = {};
+
+
+
+    const getStream = _channels.getStream.bind(_channels);
+    const testStream =  _channels.testStream.bind(_channels);
+    const getProxySubject = _channels.getProxySubject.bind(_channels);
+
+
+    _channelsMap = {getStream, testStream, getProxySubject}
+
+
+
+  }
+
+  setProp(key, val){
+    _config.tmp[key]=val;
+  }
+
+  getProp(key){
+    return path(['tmp', key], _config);
+  }
+
+  get channelsMap(){
+    return _channelsMap;
+  }
+
+  get initialized(){
+    return _initialized;
+  }
+
+  get scrollLock(){
+    return _spyneScrollLock;
+  }
+
+
+
+
+  setChannelConfig(channelName, config){
+    _config.channels[channelName] = config;
+    return _config.channels[channelName];
+  }
+
+
+  getChannelConfig(channelName, config=_config){
+    if (channelName === 'CHANNEL_ROUTE'){
+      channelName = "ROUTE";
+    } else if (channelName === 'CHANNEL_WINDOW'){
+      channelName = "WINDOW";
+    }
+
+    if (config === undefined || _config.channels === undefined){
+      console.warn('Spyne warning: Spyne config object is empty!')
+      return;
+    }
+
+    const channelConfig = _config.channels[channelName];
+
+    if (channelConfig === undefined){
+      console.warn(`Spyne warning: Spyne configuration for channel, ${channelName} is empty!`)
+      return;
+    }
+
+    //console.log("MAIN CONFIG IS ",{channelName, channelConfig, config});
+
+    return channelConfig;
+  }
+
+
+
+
+  get config(){
+    return _config;
+  }
+
+  /**
+   * This is mostly used for debugging purposes
+   *
+   * @example
+   * TITLE['<h4>Listing the registereed Channels in the browser console</h4>']
+   * SpyneApp.listChannels();
+   *
+   * @returns A list of all registered channels
+   */
+  static listChannels() {
+    return Array.from(_channels.map.keys());
+  }
+
+  /**
+   * This method is useful to check in the console or in the code what actions are available to be listened to.
+   * @param {String} channelName
+   * @returns {Array} An array of Actions that can be listened to
+   */
+/*  getChannelActions(channelName) {
+    return _channels.getChannelActions(channelName);
+  }*/
+
+
+  registerChannel(){
+
+
+  }
+
+  addPluginConfig(pluginName, pluginConfig={}){
+    if (_config['plugins']===undefined){
+      _config['plugins'] = {};
+    }
+    this.addPluginMethods(pluginConfig['pluginMethods'])
+
+    _config.plugins[pluginName]=pluginConfig;
+
+  }
+
+  getPluginsMethodObj(pluginMethodsObj){
+    if(pluginMethodsObj){
+      this.addPluginMethods(pluginMethodsObj);
+    }
+
+    return _spynePluginMethods.pluginMethodsObj;
+  }
+
+  addPluginMethods(pluginMethods){
+
+    if (pluginMethods){
+
+      _spynePluginMethods.addMethods(pluginMethods);
+
+    }
+
+
+  }
+
+  getPluginConfigByPluginName(pluginName){
+    return _config.plugins[pluginName];
+  }
+
+
+
+
+  tempGetChannelsInstance(){
+
+  }
+
+  tempGetConfig(){
+
+
+  }
+
+  get debug(){
+    return _debug;
+    //return _config['debug']===true;
+  }
+
+
+
+
+}
+
+export let SpyneAppProperties = new SpyneAppPropertiesClass();

package/src/spyne/utils/spyne-logger.js

@@ -0,0 +1,18 @@
+class SpyneLoggerClass{
+
+  constructor(props) {
+
+    this._warnings = [];
+  }
+
+  static warn(){
+
+
+
+  }
+
+
+
+}
+
+export let SpyneLogger = new SpyneLoggerClass();

package/src/spyne/utils/spyne-plugins-methods.js

@@ -0,0 +1,105 @@
+const _pluginMethodsObj = Object.create({});
+
+_pluginMethodsObj['foo'] = ()=>console.log("used for testing purposes.");
+
+import {allPass, compose, is, isEmpty, keys, not, prop} from 'ramda';
+
+
+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)]))
+
+
+export class SpynePluginsMethods{
+
+
+  constructor(){
+
+
+
+  }
+
+
+
+  addMethod(key, fn, test=false){
+    //console.log('has method is 2',typeof(_pluginMethodsObj),{_pluginMethodsObj})
+
+    if (_pluginMethodsObj.hasOwnProperty(key)===true){
+      const warnStr = `Spyne Warning: the method name, ${key}, already exists.`;
+
+      if (test){
+        return warnStr;
+      }
+      console.warn(warnStr);
+    } else {
+      _pluginMethodsObj[key] = fn;
+    }
+
+  }
+
+
+  addMethods(methodsObj={}, test=false){
+
+    let warnStr;
+
+    const isObj = isObjectFn(methodsObj);
+
+    if (isObj === false){
+      warnStr = `Spyne Warning: the pluginMethods property, ${JSON.stringify(methodsObj)} needs to be an object.`
+      if (test){
+        //console.log('this is a test ',{methodsObj})
+        return warnStr;
+      }
+      console.warn(warnStr);
+      return;
+
+    }
+
+    const checkEachKeyForValidMethod = (keyStr) => {
+      const methodVal = prop(keyStr, methodsObj);
+
+      const isFunction = typeof(methodVal) === 'function';
+
+      //console.log('method to add ',{keyStr, isFunction})
+
+      if (isFunction){
+        this.addMethod(keyStr, methodVal, test);
+      } else{
+        warnStr = `the value for ${keyStr} is not a valid function.`
+        if (test){
+          return warnStr;
+        } else {
+          console.warn(warnStr);
+        }
+      }
+
+    }
+
+    const methodKeys = keys(methodsObj);
+
+    return methodKeys.map(checkEachKeyForValidMethod).join(',');
+
+  }
+
+  checkIfMethodExists(key){
+
+  }
+
+  test1(){
+    //console.log('test 1 is ');
+  }
+
+
+  get pluginMethodsObj(){
+    return _pluginMethodsObj;
+  }
+
+
+
+
+
+
+}