spyne 0.16.2 → 0.18.2

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

@@ -0,0 +1,183 @@
+import {SpyneUtilsChannelRoute} from './spyne-utils-channel-route';
+import {SpynePluginsMethods} from './spyne-plugins-methods';
+import {deepMerge} from './deep-merge';
+import {path} from 'ramda';
+
+let _config;
+let _channels;
+let _channelsMap
+let _initialized = false;
+let _debug = true;
+
+const _spynePluginMethods = new SpynePluginsMethods();
+
+
+class SpyneAppPropertiesClass{
+
+  constructor() {
+
+
+  }
+
+  get channelsMap(){
+    return _channelsMap;
+  }
+
+  get initialized(){
+    return _initialized;
+  }
+
+  get config(){
+    return _config;
+  }
+
+  get debug(){
+    return _debug;
+  }
+
+  /**
+   * 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());
+  }
+
+  initialize(defaultConfig={}, config={}, channelsMap){
+    _channels = channelsMap;
+    let userConfig = config;
+    if (config.channels && config.channels.ROUTE) {
+       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;
+     this.setChannelsMap();
+
+
+    return _config;
+
+  }
+
+  conformRouteConfig(add404Props=false){
+    /**
+     * THIS METHOD IS PRIMARILY USED FOR SPA GEN SITE GENERATION
+     */
+
+    _config = SpyneUtilsChannelRoute.conformRouteObject(_config, add404Props);
+
+  }
+
+  setChannelsMap(){
+    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);
+  }
+
+  setChannelConfig(channelName, config){
+    _config.channels[channelName] = config;
+    return _config.channels[channelName];
+  }
+
+  /**
+   * 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);
+  }*/
+
+  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;
+    }
+
+    return channelConfig;
+  }
+
+  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(){
+
+
+  }
+
+
+
+
+}
+
+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,97 @@
+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){
+
+    if (Object.prototype.hasOwnProperty.call(_pluginMethodsObj, 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){
+        return warnStr;
+      }
+      console.warn(warnStr);
+      return;
+
+    }
+
+    const checkEachKeyForValidMethod = (keyStr) => {
+      const methodVal = prop(keyStr, methodsObj);
+
+      const isFunction = typeof(methodVal) === 'function';
+
+
+      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){
+
+  }
+
+
+  get pluginMethodsObj(){
+    return _pluginMethodsObj;
+  }
+
+
+
+
+
+
+}

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

@@ -1,5 +1,5 @@
 import { getAllMethodNames } from './frp-tools';
-import {reject, test, curryN, __, map} from 'ramda';
+import {reject, curryN, __, map} from 'ramda';
 
 export class SpyneTrait {
   /**
@@ -63,13 +63,10 @@ export class SpyneTrait {
     this.checkForMalformedMethods(methodsObj.allMethods);
       let obj = {};
     const bindMethodsToParentViewStream = (str, isStatic = false) => {
-      const addMethod = s =>  {
-        return context[s] = constructorType[s].bind(context);
-      };
       let constructorType = isStatic === true ? this.constructor : this;
       let propertyType = typeof (constructorType[str]);
       if (propertyType === 'function') {
-         obj[str] = addMethod(str);
+         obj[str] = context[str] = constructorType[str].bind(context);
       }
     };
 

package/src/spyne/utils/spyne-utils-channel-route-url.js

@@ -1,4 +1,5 @@
 import {isEmpty, head, values, compose, prop, complement, isNil, allPass, reduce, filter, equals, toPairs, replace, either, propEq, __,invert,path,zipObj, reject, keys, find, assoc, is,has, when, split, always, concat, join, flatten, map, ifElse, test, findLastIndex,last, defaultTo,fromPairs } from 'ramda';
+import {SpyneAppProperties} from './spyne-app-properties';
 
 export class SpyneUtilsChannelRouteUrl {
   constructor() {
@@ -61,7 +62,6 @@ export class SpyneUtilsChannelRouteUrl {
       let keyword = routeObj.routeName; // PARAM FORM SPYNE CONFIG
       let paramValFromData = data[keyword] !== undefined ? data[keyword] : prop(keyword, paramsFromLoc); // PULL VALUE FOR THIS PARAM FROM DATA
       const paramValType = typeof (routeObj[paramValFromData]);
-      // console.log({routeObj, paramValType, paramValFromData, keyword})
 
       if (paramValType === 'string') {
         paramValFromData = routeObj[paramValFromData];
@@ -71,12 +71,9 @@ export class SpyneUtilsChannelRouteUrl {
 
       urlObj[keyword] = paramValFromData;
 
-      // console.log("URL OBJ ",urlObj);
       if (this.checkIfObjIsNotEmptyOrNil(urlObj)) {
-        // console.log("FOUND ",{paramValFromData, paramValType, urlObj, routeObj});
         urlArr.push(urlObj);
       } else {
-        // console.log("NOT FOUND ",paramValFromData, paramValType, urlObj, routeObj);
 
       }
 
@@ -84,10 +81,8 @@ export class SpyneUtilsChannelRouteUrl {
       const objectParamExists = has(paramValFromData, routeObj);
       const objectContainsRoute = has('routePath', routeObj);
       const recursivelyCallLoopBool = objectParamExists && isObject;
-      // console.log("CHECKS ", {isObject, objectParamExists, objectContainsRoute, recursivelyCallLoopBool})
       if (recursivelyCallLoopBool === true) {
         let newObj = routeObj[paramValFromData];
-        // console.log("NEW OBJ ",{paramValFromData, routeObj, newObj});
         if (has('routePath', newObj)) {
           loopThroughParam(newObj.routePath);
         }
@@ -163,7 +158,7 @@ export class SpyneUtilsChannelRouteUrl {
     return map(mapUrlProps, urlsArr);
   }
 
-  static convertParamsToRoute(data, r = window.Spyne.config.channels.ROUTE, t, locStr) {
+  static convertParamsToRoute(data, r = SpyneAppProperties.config.channels.ROUTE, t, locStr) {
     const urlType = t !== undefined ? t : r.type;
     const isHash = r.isHash;
     let route = r.routes.routePath;
@@ -239,7 +234,7 @@ export class SpyneUtilsChannelRouteUrl {
       let getParamInverted = compose(head, defaultTo([]), prop(param));
       let paramInverted = getParamInverted(invertedObj);
       // spyne 11.0.1;
-      let re =  /^([-\$\w]*)$/;
+      let re =  /^([-$\w]*)$/;
       let keyMatch =  re.test(paramInverted);
 
       if (keyMatch === true && is(String, paramInverted) === true) {

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

@@ -1,7 +1,6 @@
 import { fromEventPattern } from 'rxjs';
-import {last, mapObjIndexed, flatten, clone, pick, prop, propOr, pickAll, path, equals, compose, keys, filter, propEq, uniq, map, __, chain,is, includes, fromPairs, reject, mergeDeepRight, mergeRight, reverse, test, omit, reduceRight, nth, toPairs, values} from 'ramda';
+import {last, flatten, clone, pick, prop, pickAll, path, equals, compose, keys, filter, propEq, uniq, map, __, chain,is, includes, fromPairs, reject, mergeDeepRight, mergeRight, test, toPairs, values} from 'ramda';
 import {SpyneUtilsChannelRouteUrl} from './spyne-utils-channel-route-url';
-import {RouteDataForTests} from '../../tests/mocks/utils-data';
 
 export class SpyneUtilsChannelRoute {
   constructor() {
@@ -102,7 +101,7 @@ export class SpyneUtilsChannelRoute {
     // create href and check to see if need to convert to hash href links
     const getHREF = (obj)=>{
       const santizeHREF = str => {
-        const hrefRE = /^(.*\/)([\w\-]*\/?)(.*)$/gm
+        const hrefRE = /^(.*\/)([\w-]*\/?)(.*)$/gm
         //const hrefRE = /^(.*\/)([\w-]*)(.*)$/gm;
        str = str.replace(hrefRE, "$1$2");
        // str = String(str).replace('^$', "");
@@ -119,7 +118,7 @@ export class SpyneUtilsChannelRoute {
 
 
     // test whether to use key or val
-    const isValidStrRE = /^([A-Za-z0-9_\-])+$/m;
+    const isValidStrRE = /^([A-Za-z0-9_-])+$/m;
 
     const createInitialValFn = (accMain=[], routePathObj, objAcc={})=>{
       let {routeName} = routePathObj;
@@ -129,7 +128,9 @@ export class SpyneUtilsChannelRoute {
         const [key, val] = arrPair;
         const isObject = is(Object, val);
 
-        const getLinkText = str => test(isValidStrRE, str) ? String(str).toUpperCase() : key;
+        const createTitle = (str)=>String(str).replace(/([-_])/g, " ").toUpperCase();
+
+        const getLinkText = str => test(isValidStrRE, str) ? createTitle(str) : key;
 
         if (key === 'routeName' || key === '404'){
           return acc;
@@ -177,7 +178,6 @@ export class SpyneUtilsChannelRoute {
       return getMainKeys(datasetsArr);
     }
     const routeNamesArr = getNavProps(routeDatasetsArr);
-    //console.log('validate route names arr is ',routeNamesArr);
 
     return {routeDatasetsArr, routeNamesArr};
   }
@@ -187,7 +187,6 @@ export class SpyneUtilsChannelRoute {
     const channelsRoutePath = path(['channels', 'ROUTE'], channelRouteObj);
     let {add404s} = channelsRoutePath !== undefined ? channelsRoutePath : channelRouteObj;
     add404s = add404s || add404Props;
-    //console.log("add 404s is1 ",{add404s, channelsRoutePath})
     const parseRoutePath = (a) => {
       let val = a[1];
       const isArr = is(Array, val);
@@ -217,24 +216,17 @@ export class SpyneUtilsChannelRoute {
     }
 
     const configMapperFn = compose(fromPairs, map(transduceConfig), toPairs);
-    //console.log('route obj ',channelRouteObj);
 
 
     if (channelsRoutePath !== undefined){
       channelRouteObj.channels.ROUTE = configMapperFn(channelRouteObj.channels.ROUTE)
       const extraRouteData = SpyneUtilsChannelRoute.addRouteDatasets(channelRouteObj.channels.ROUTE);
       channelRouteObj.channels.ROUTE = mergeRight(channelRouteObj.channels.ROUTE, extraRouteData);
-      //console.log("CHANNEL ROUTE OBJ ",channelRouteObj.channels.ROUTE);
-      //channelRouteObj.channels.ROUTE.linkDatasets = SpyneUtilsChannelRoute.addRouteDatasets(channelRouteObj.channels.ROUTE);
       return channelRouteObj;
     }
 
-
-
     return configMapperFn(channelRouteObj);
 
-
-
   }
 
   static getLocationData() {

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

@@ -66,7 +66,7 @@ export class SpyneUtilsChannelWindow {
   }
 
   static createMergedObsFromObj(config) {
-    let mediaQueriesObj = config.mediqQueries;
+    let mediaQueriesObj = config.mediaQueries || config.mediqQueries;
     let arr = [];
 
     const loopQueries = (val, key, obj) => {
@@ -78,8 +78,6 @@ export class SpyneUtilsChannelWindow {
     };
 
     mapObjIndexed(loopQueries, mediaQueriesObj);
-    // let obs$ = Observable.merge(...arr);
-    // console.log('arr is ',arr);
     return arr;
   }
 }

package/src/spyne/utils/viewstream-observables.js

@@ -65,12 +65,11 @@ export class ViewStreamObservable {
 
     const raw$ =  obs$
       .pipe(filter((payload) => payload !== undefined && payload.action !== undefined));
-    // .filter(p => p.$dir !== undefined)
-    // .do(p => console.log('payload : ', p.$dir, p));
+
     const toInternal$ = obs$.pipe(filter(filterInternal), map(addInternalfrom$));
     const toParent$ = obs$.pipe(filter(filterParent), map(addParentfrom$));
     const toChild$ = obs$.pipe(filter(filterChild), map(addChildfrom$));
-    // const upObs$ = obs$.do(p => console.log('UP: ', p));
+
     const streamObj = {
       parent: toParent$,
       internal: toInternal$,

package/src/spyne/views/dom-element-template.js

@@ -1,5 +1,5 @@
-import {includes, __, ifElse, compose,path,split,prop, reject, is, defaultTo, isNil, isEmpty} from 'ramda';
-import {testDomTemplateForTableTags} from "../utils/viewstream-dom-utils";
+import {includes, __, ifElse, path, prop, reject, is, isNil, isEmpty} from 'ramda';
+
 /**
  * @module DomElTemplate
  * @type util
@@ -136,9 +136,6 @@ export class DomElementTemplate {
   constructor(template, data) {
     this.template = this.formatTemplate(template);
 
-    //const tempL = `template-${Math.floor(Math.random()*99999)}`
-   // this.tempL=tempL
-
     const checkForArrayData = ()=>{
       if (is(Array, data) === true) {
         data = {spyneData:data};
@@ -206,8 +203,6 @@ export class DomElementTemplate {
 
 
   renderDocFrag() {
-
-
     const html = this.finalArr.join('');
     const isTableSubTag =   /^([^>]*?)(<){1}(\b)(thead|col|colgroup|tbody|td|tfoot|tr|th)(\b)([^\0]*)$/.test(html);
     const el = isTableSubTag ? html : document.createRange().createContextualFragment(html);

package/src/spyne/views/dom-element.js

@@ -1,12 +1,7 @@
-// import {createElement} from '../utils/dom-methods';
 import { baseCoreMixins } from '../utils/mixins/base-core-mixins';
 import { DomElementTemplate } from './dom-element-template';
 import { deepMerge } from '../utils/deep-merge';
-// import {DomElementTemplate} from './template-renderer';
-
 import {is, defaultTo, pick, mapObjIndexed, forEachObjIndexed, pipe} from 'ramda';
-//import {ViewStreamElement} from './view-stream-element';
-//import {getConstructorName} from '../utils/frp-tools';
 
 class DomElement {
   /**
@@ -31,35 +26,21 @@ class DomElement {
    */
 
   constructor(props={}) {
-    //let isSimpleView = both(is(String), complement(isEmpty))(attributes);
-   // if (isSimpleView === true) {
-    //  data = attributes;
-      // attributes = {};
 
-   // }
     const checkDefault = (dflt, val)=>defaultTo(dflt)(val);
 
     props.tagName = checkDefault('div', props.tagName);
 
-
     props.attributes = props.attributes!==undefined ? props.attributes : this.getDomAttributes(props);
     props.attrs = this.updateAttrs(props.attributes);
 
     props.fragment =  document.createDocumentFragment()
     this.props = props;
 
-    //this.setProp('tagName', tagName);
-    //this.setProp('attrs', this.updateAttrs(attributes));
-    //this.setProp('data', data);
-   // this.setProp('template', template);
-
-   // this.setProp('fragment', document.createDocumentFragment());
-
     this.addMixins();
   }
 
   setProp(key, val) {
-    //this.props.set(key, val);
     this.props[key] = val;
   }
 

package/src/spyne/views/view-stream-broadcaster.js

@@ -1,9 +1,9 @@
 import { baseStreamsMixins } from '../utils/mixins/base-streams-mixins';
 import { convertDomStringMapToObj } from '../utils/frp-tools';
-
+import {SpyneAppProperties} from '../utils/spyne-app-properties';
 import { fromEvent } from 'rxjs';
 import { map } from 'rxjs/operators';
-import {clone, omit, path} from 'ramda';
+import {clone, omit} from 'ramda';
 
 export class ViewStreamBroadcaster {
   /**
@@ -47,9 +47,7 @@ export class ViewStreamBroadcaster {
     };
     // spread operator to select variables from arrays
     let [selector, event, local] = args;
-    // console.log('args is ',args);
     // btn query
-    // let query = this.props.el.querySelectorAll(selector);
     let channel; // hoist channel and later check if chnl exists
     let query = this.props.el.querySelectorAll(selector);
 
@@ -85,8 +83,6 @@ export class ViewStreamBroadcaster {
       data['channel'] = channel;
       // payload needs vsid# to pass verification
 
-      // data['event'] = event;
-      // data['el'] = q;
       data['srcElement'] = {};// pick(['vsid','viewName'], data);
       data.srcElement['id'] = this.props.id;
       data.srcElement['vsid'] = this.props.vsid;
@@ -99,11 +95,11 @@ export class ViewStreamBroadcaster {
       // run payload
       channelPayload(observable, data);
     };
-    let isDevMode = path(['Spyne', 'config', 'debug'], window) === true;
+    let isDevMode = SpyneAppProperties.debug === true;
     let queryIsNil = query === undefined || query.length <= 0;
     if (queryIsNil === true && isDevMode === true) {
-      console.warn(`Spyne Warning: The item ${selector}, does not appear to exist!`);
-      // query = this.props.el;
+      console.warn(`Spyne Warning: The item ${selector}, does not appear to exist in ${this.props.name} --> vsid:${this.props.vsid}!`);
+
       // addObservable(query, event);
     } else {
       query.forEach = Array.prototype.forEach;
@@ -124,6 +120,5 @@ export class ViewStreamBroadcaster {
     let streamMixins = baseStreamsMixins();
     this.sendUIPayload = streamMixins.sendUIPayload;
     this.sendRoutePayload = streamMixins.sendRoutePayload;
-    //this.createLifeStreamPayload = streamMixins.createLifeStreamPayload;
   }
 }

package/src/spyne/views/view-stream-element.js

@@ -1,6 +1,4 @@
-//import { baseCoreMixins } from '../utils/mixins/base-core-mixins';
 import { DomElement } from './dom-element';
-//import { ifNilThenUpdate, convertDomStringMapToObj } from '../utils/frp-tools';
 import { fadein, fadeout } from '../utils/viewstream-animations';
 import { ViewStreamObservable } from '../utils/viewstream-observables';
 import { deepMerge } from '../utils/deep-merge';
@@ -108,7 +106,6 @@ export class ViewStreamElement {
 
     let fadeOutObs = bindCallback(animateOut);
     let onFadeoutCompleted = (e) => {
-      // console.log('fade out completed ', e, d);
       this._source$.next(gcData);
     };
 
@@ -139,7 +136,6 @@ export class ViewStreamElement {
   }
 
   onGarbageCollect(p) {
-    // console.log('MEDIATOR onGarbageCollect ', this.vsid, this.vsName, p);
     if (this.domItem!==undefined) {
       this.domItem.unmount();
     }
@@ -161,9 +157,7 @@ export class ViewStreamElement {
     let append = (node, item) => node.appendChild(item);
     // DETERMINE WHETHER TO USE APPEND OR PREPEND
     // ON CONNECTING DOM ITEMS TO EACH OTHER
-    // this.domItemEl = this.domItem.render();
     let attachFunc = d.attachType === 'appendChild' ? append : prepend;
-    // d.node = isNil(d.query) ? d.node : d.query;
     attachFunc(container, this.domItem.render());
     this.setAnimateIn(d);
   }
@@ -177,7 +171,6 @@ export class ViewStreamElement {
   onAttachChildToSelf(p) {
     let data = p.childRenderData;
     this.combineDomItems(data);
-    //console.log("ATTACHING CHID TO SELF ===============")
     return {
       action: 'CHILD_ATTACHED',
       $dir: this.$dirs.PI
@@ -201,13 +194,8 @@ export class ViewStreamElement {
   }
 
   renderDomItem(d) {
-    let tagName, attributes, data, template;
-    [tagName,attributes,data,template]=d;
-    //console.log("RENDER DOM EL ",{tagName, attributes, data,template,d});
-
-    //this.domItem = new DomElement(...d);
+    const [tagName,attributes,data,template]=d;
     this.domItem = new DomElement({tagName,attributes,data,template});
-
     return this.domItem;
   }
 
@@ -232,7 +220,6 @@ export class ViewStreamElement {
    */
   onRenderAndAttachToDom(d) {
     let getEl = (data) => this.renderDomItem(data);
-    // let getEl = (data) => new DomElement(...data);
     d.attachData['el'] = getEl(props(['tagName', 'domAttributes', 'data', 'template'], d));
     this.combineDomItems(d.attachData);
     return {
@@ -252,13 +239,9 @@ export class ViewStreamElement {
     let action = payload.action;
     let defaultToFn = defaultTo((data) => this.extendedMethods(data));
     let fn = defaultToFn(this.options.hashMethods[action]);
-    // console.log('MEDIATOR onObsSinkSubscribe before ', this.vsid, action, payload);
     let data = fn(payload);
-    // data = this.addDefaultDir(data);
-    // console.log('add default dir ', data);
     let sendData = (d) => this._source$.next(d);
     if (data !== undefined) {
-      // console.log('MEDIATOR onObsSinkSubscribe ', this.vsid, data, payload);
       sendData(Object.freeze(data));
     }
   }