spyne 0.19.0 → 0.20.0

package/src/spyne/spyne-plugins.js

@@ -1,117 +1,102 @@
-import {SpyneApp, DomElement, SpyneAppProperties} from './spyne';
-import {is, clone, pathSatisfies} from 'ramda';
+import { DomElement } from './views/dom-element'
+import { SpyneAppProperties } from './utils/spyne-app-properties'
+import { is, clone, pathSatisfies } from 'ramda'
 export class SpynePlugin {
+  constructor(props = {}) {
+    let { name, config, parentEl } = props
+    this.props = props
 
-  constructor(props={}) {
-    let {name, config, parentEl} = props;
-    this.props = props;
-
-
-    if (config===undefined){
-      config = clone(props);
+    if (config === undefined) {
+      config = clone(props)
     }
 
-    this.name = name || 'empty';
-    this.props.name = name;
-    config = SpynePlugin.mergeDefaultConfig(config, this.defaultConfig());
-    this.props.parentEl = parentEl || SpynePlugin.createParentEl();
-    SpynePlugin.getSpyneApp(name, config);
+    this.name = name || 'empty'
+    this.props.name = name
+    config = SpynePlugin.mergeDefaultConfig(config, this.defaultConfig())
+    this.props.parentEl = parentEl || SpynePlugin.createParentEl()
+    SpynePlugin.getSpyneApp(name, config)
 
-    if (this.props.traits!==undefined){
-      this.addTraits(this.props.traits);
+    if (this.props.traits !== undefined) {
+      this.addTraits(this.props.traits)
     }
 
-    this.onBeforeRegistered();
-    this.onRegistered();
-    this.onRender();
+    this.onBeforeRegistered()
+    this.onRegistered()
+    this.onRender()
   }
 
-  static mergeDefaultConfig(config={}, defaultConfig=this.defaultConfig()){
-    return Object.assign(defaultConfig, config);
+  static mergeDefaultConfig(config = {}, defaultConfig = this.defaultConfig()) {
+    return Object.assign(defaultConfig, config)
   }
 
-  static getSpyneApp(name, config){
-    if(SpyneAppProperties.initialized===false){
-
-      console.warn(`Spyne Warning: Unable to install plugin, ${name}! SpyneApp has not been initialized!`);
-       //SpyneApp.init()
-    } else{
-      SpyneAppProperties.addPluginConfig(name, config);
+  static getSpyneApp(name, config) {
+    if (SpyneAppProperties.initialized === false) {
+      console.warn(`Spyne Warning: Unable to install plugin, ${name}! SpyneApp has not been initialized!`)
+      // SpyneApp.init()
+    } else {
+      SpyneAppProperties.addPluginConfig(name, config)
     }
-
   }
 
+  static updateSpyneConfig(spyneApp, pluginName, pluginConfig) {
+    const pathExists = pathSatisfies(is(Object), ['config', 'plugins', pluginName])(spyneApp)
 
-  static updateSpyneConfig(spyneApp, pluginName, pluginConfig){
-    const pathExists = pathSatisfies(is(Object), ['config', 'plugins', pluginName])(spyneApp);
-
-    if (pathExists===true){
-      if (spyneApp.config.debug===true) {
+    if (pathExists === true) {
+      if (spyneApp.config.debug === true) {
         console.warn(`Spyne Warning: The plugin, ${pluginName}, already exists`)
       }
-       return false;
+      return false
     }
-    spyneApp.config.plugins[pluginName] = pluginConfig;
-    return spyneApp.config.plugins[pluginName];
+    spyneApp.config.plugins[pluginName] = pluginConfig
+    return spyneApp.config.plugins[pluginName]
   }
 
-  static createParentEl(el){
-
-    const createPluginParentEl = ()=>{
+  static createParentEl(el) {
+    const createPluginParentEl = () => {
       const pluginEl = document.getElementById('spyne-plugins')
 
-      const createPluginEl = ()=>{
+      const createPluginEl = () => {
         const pluginEl = new DomElement({
           id: 'spyne-plugins'
-        });
-        document.body.appendChild(pluginEl.render());
+        })
+        document.body.appendChild(pluginEl.render())
         const el = document.getElementById('spyne-plugins')
-        el.style.cssText="position:absolute; top:0;left:0;width:100%;height:100%;min-height:100vh;z-index:1000000; pointer-events:none";
-        return el;
+        el.style.cssText = 'position:absolute; top:0;left:0;width:100%;height:100%;min-height:100vh;z-index:1000000; pointer-events:none'
+        return el
       }
-      return pluginEl || createPluginEl();
+      return pluginEl || createPluginEl()
     }
 
-    return el || createPluginParentEl();
+    return el || createPluginParentEl()
   }
 
-  addTraits(traits){
-    if (traits.constructor.name!=='Array'){
-      traits = [traits];
+  addTraits(traits) {
+    if (traits.constructor.name !== 'Array') {
+      traits = [traits]
+    }
+    const addTrait = (TraitClass) => {
+      return new TraitClass(this)
     }
-    const addTrait=(TraitClass)=>{
-      return new TraitClass(this);
-    };
-
-    traits.forEach(addTrait);
 
+    traits.forEach(addTrait)
   }
 
-  onBeforeRegistered(){
-    this.props.pluginName = this.props.name;
-    this.props.config = SpyneAppProperties.getPluginConfigByPluginName(this.props.pluginName);
+  onBeforeRegistered() {
+    this.props.pluginName = this.props.name
+    this.props.config = SpyneAppProperties.getPluginConfigByPluginName(this.props.pluginName)
   }
 
-  defaultConfig(){
-
+  defaultConfig() {
     return {
 
-
     }
-
   }
 
-  onRegistered(){
-
+  onRegistered() {
 
   }
 
-  onRender(){
-
+  onRender() {
 
   }
-
-
-
 }
-

package/src/spyne/spyne.js

@@ -1,36 +1,36 @@
-import { ChannelsMap } from './channels/channels-map';
-import { DomElement } from './views/dom-element';
-import {DomElementTemplate} from './views/dom-element-template';
-import { ViewStreamElement } from './views/view-stream-element';
-import { ViewStreamSelector} from './views/view-stream-selector';
-import { ViewStream } from './views/view-stream';
-import { ViewStreamBroadcaster } from './views/view-stream-broadcaster';
-import { SpyneTrait } from './utils/spyne-trait';
-import { ViewStreamPayload } from './views/view-stream-payload';
-import { Channel } from './channels/channel';
-import { ChannelFetch } from './channels/channel-fetch-class';
-import {ChannelFetchUtil} from './utils/channel-fetch-util';
-import { ChannelPayload } from './channels/channel-payload-class';
-import {ChannelPayloadFilter} from './utils/channel-payload-filter';
-import {SpynePlugin} from './spyne-plugins';
-import { deepMerge } from './utils/deep-merge';
-import {safeClone} from './utils/safe-clone';
-import {SpyneAppProperties} from './utils/spyne-app-properties';
-import {SpyneApp} from './spyne-app';
+import { ChannelsMap } from './channels/channels-map'
+import { DomElement } from './views/dom-element'
+import { DomElementTemplate } from './views/dom-element-template'
+import { ViewStreamElement } from './views/view-stream-element'
+import { ViewStreamSelector } from './views/view-stream-selector'
+import { ViewStream } from './views/view-stream'
+import { ViewStreamBroadcaster } from './views/view-stream-broadcaster'
+import { SpyneTrait } from './utils/spyne-trait'
+import { ViewStreamPayload } from './views/view-stream-payload'
+import { Channel } from './channels/channel'
+import { ChannelFetch } from './channels/channel-fetch-class'
+import { ChannelFetchUtil } from './utils/channel-fetch-util'
+import { ChannelPayload } from './channels/channel-payload-class'
+import { ChannelPayloadFilter } from './utils/channel-payload-filter'
+import { SpynePlugin } from './spyne-plugins'
+import { deepMerge } from './utils/deep-merge'
+import { safeClone } from './utils/safe-clone'
+import { SpyneAppProperties } from './utils/spyne-app-properties'
+import { SpyneApp } from './spyne-app'
 
 export {
   ViewStreamElement,
   Channel,
   ChannelFetch,
-    ChannelFetchUtil,
+  ChannelFetchUtil,
   ChannelsMap,
   ViewStreamPayload,
   ChannelPayload,
-    ChannelPayloadFilter,
+  ChannelPayloadFilter,
   DomElement,
   DomElementTemplate,
   ViewStream,
-    ViewStreamSelector,
+  ViewStreamSelector,
   ViewStreamBroadcaster,
   SpyneTrait,
   SpyneApp,
@@ -38,4 +38,4 @@ export {
   SpynePlugin,
   deepMerge,
   safeClone
-};
+}

package/src/spyne/utils/channel-config-validator.js

@@ -1,14 +1,14 @@
-import Validation from 'data.validation';
-import {curry, curryN, length, always, reduce} from 'ramda';
-const success = Validation.Success;
-const failure = Validation.Failure;
-let validate = () => {};
+import Validation from 'data.validation'
+import { curry, curryN, length, always, reduce } from 'ramda'
+const success = Validation.Success
+const failure = Validation.Failure
+let validate = () => {}
 if (curry !== undefined) {
   validate = curry((validations, thing) => {
-    const initial = success(curryN(length(validations), always(thing)));
+    const initial = success(curryN(length(validations), always(thing)))
     const run = (acc, v) =>
-      acc.ap(v.predicate(thing) ? success(thing) : failure([v.error]));
-    return reduce(run, initial, validations);
-  });
+      acc.ap(v.predicate(thing) ? success(thing) : failure([v.error]))
+    return reduce(run, initial, validations)
+  })
 }
-export { validate };
+export { validate }

package/src/spyne/utils/channel-fetch-util.js

@@ -1,6 +1,6 @@
-import { from } from 'rxjs';
-import { flatMap, map, publish, tap } from 'rxjs/operators';
-import {compose, prop, defaultTo, over, lensProp, has, propEq, when, propIs, allPass, assoc, pick, mergeDeepRight} from 'ramda';
+import { from } from 'rxjs'
+import { flatMap, map, publish, tap } from 'rxjs/operators'
+import { compose, prop, defaultTo, over, lensProp, has, propEq, when, propIs, allPass, assoc, pick, mergeDeepRight } from 'ramda'
 export class ChannelFetchUtil {
   /**
    * @module ChannelFetchUtil
@@ -46,115 +46,132 @@ export class ChannelFetchUtil {
    *
    */
 
-
   constructor(options, subscriber, testMode, CHANNEL_NAME) {
+    const testSubscriber = (p) => console.log('FETCH RETURNED ', p)
 
-    const testSubscriber = (p) => console.log('FETCH RETURNED ', p);
-
-    this._mapFn = ChannelFetchUtil.setMapFn(options);
-    this._url = ChannelFetchUtil.setUrl(options);
-    this._responseType = ChannelFetchUtil.setResponseType(options);
-    this._serverOptions = ChannelFetchUtil.setServerOptions(options);
-    this._subscriber = subscriber !== undefined ? subscriber : testSubscriber;
-    this.debug = options.debug !== undefined ? options.debug : false;
-    this.channelName = CHANNEL_NAME;
+    this._mapFn = ChannelFetchUtil.setMapFn(options)
+    this._url = ChannelFetchUtil.setUrl(options)
+    this._responseType = ChannelFetchUtil.setResponseType(options)
+    this._serverOptions = ChannelFetchUtil.setServerOptions(options)
+    this._subscriber = subscriber !== undefined ? subscriber : testSubscriber
+    this.debug = options.debug !== undefined ? options.debug : false
+    this.channelName = CHANNEL_NAME
 
-    let fetchProps = {
+    const fetchProps = {
       mapFn: this.mapFn,
       url: this.url,
       serverOptions: this.serverOptions,
       responseType: this.responseType,
       debug: this.debug
-    };
+    }
     if (testMode !== true) {
-      ChannelFetchUtil.startWindowFetch(fetchProps, this._subscriber, this.channelName);
+      ChannelFetchUtil.startWindowFetch(fetchProps, this._subscriber, this.channelName)
     }
   }
 
   static startWindowFetch(props, subscriber, channelName) {
-    let { mapFn, url, serverOptions, responseType, debug } = props;
-    const tapLogDebug = p => console.log('DEBUG FETCH :', p, {url, serverOptions, responseType, channelName});
-    const tapLog = debug === true ? tapLogDebug : () => {};
+    const { mapFn, url, serverOptions, responseType, debug } = props
+    const tapLogDebug = p => console.log('DEBUG FETCH :', p, { url, serverOptions, responseType, channelName })
+    const tapLog = debug === true ? tapLogDebug : () => {}
 
-    const mapWrapper = (mapMethod)=>{
-      const metadata = {channelName, url, responseType, serverOptions}
+    const mapWrapper = (mapMethod) => {
+      const metadata = { channelName, url, responseType, serverOptions }
 
-      return (data)=>{
-        return mapMethod(data, metadata);
+      return (data) => {
+        return mapMethod(data, metadata)
       }
-
     }
 
-    let response$ = from(window.fetch(url, serverOptions))
-    .pipe(tap(tapLog), flatMap(r => from(r[responseType]())),
+    const response$ = from(window.fetch(url, serverOptions))
+      .pipe(tap(tapLog), flatMap(r => from(r[responseType]())),
         map(mapWrapper(mapFn)),
-        publish());
+        publish())
 
-    response$.connect();
+    response$.connect()
 
-    response$.subscribe(subscriber);
+    response$.subscribe(subscriber)
   }
 
   static setMapFn(opts) {
-    const getFn = compose(defaultTo((p) => p), prop('mapFn'));
-    return getFn(opts);
+    const getFn = compose(defaultTo((p) => p), prop('mapFn'))
+    return getFn(opts)
   }
 
   static setUrl(opts) {
-    let url = prop('url', opts);
+    const url = prop('url', opts)
     if (url === undefined) {
-      console.warn(`SPYNE WARNING: URL is undefined for data channel`);
+      console.warn('SPYNE WARNING: URL is undefined for data channel')
     }
-    return url;
+    return url
   }
 
   static setResponseType(opts) {
-    return defaultTo('json', prop('responseType', opts));
+    return defaultTo('json', prop('responseType', opts))
   }
 
   get mapFn() {
-    return this._mapFn;
+    return this._mapFn
   }
 
   get url() {
-    return this._url;
+    return this._url
   }
 
   get serverOptions() {
-    return this._serverOptions;
+    return this._serverOptions
   }
 
   get responseType() {
-    return this._responseType;
+    return this._responseType
   }
 
   static stringifyBodyIfItExists(obj) {
-    const convertToJSON = when(propIs(Object, 'body'), compose(over(lensProp('body'), JSON.stringify)));
+    const convertToJSON = when(propIs(Object, 'body'), compose(over(lensProp('body'), JSON.stringify)))
 
-    return convertToJSON(obj);
+    return convertToJSON(obj)
   }
 
   static updateMethodWhenBodyExists(opts) {
-    const hasBody = has('body');
-    const methodIsGet = propEq('GET', 'method');
-    const pred = allPass([hasBody, methodIsGet]);
-    return when(pred, assoc('method', 'POST'))(opts);
+    const hasBody = has('body')
+    const methodIsGet = propEq('GET', 'method')
+    const pred = allPass([hasBody, methodIsGet])
+    return when(pred, assoc('method', 'POST'))(opts)
   }
 
   static setServerOptions(opts) {
-    let options = pick(['header', 'body', 'mode', 'method'], opts);
-    let mergedOptions = mergeDeepRight(ChannelFetchUtil.baseOptions(), options);
-    mergedOptions = ChannelFetchUtil.updateMethodWhenBodyExists(mergedOptions);
-    mergedOptions = ChannelFetchUtil.stringifyBodyIfItExists(mergedOptions);
-    return mergedOptions;
+    const options = pick([
+      'method',
+      'headers',
+      'body',
+      'mode',
+      'credentials',
+      'cache',
+      'redirect',
+      'referrer',
+      'referrerPolicy',
+      'integrity',
+      'keepalive'
+    ], opts)
+    let mergedOptions = mergeDeepRight(ChannelFetchUtil.baseOptions(), options)
+    mergedOptions = ChannelFetchUtil.updateMethodWhenBodyExists(mergedOptions)
+    mergedOptions = ChannelFetchUtil.stringifyBodyIfItExists(mergedOptions)
+    return mergedOptions
   }
 
   static baseOptions() {
     return {
-      method: 'GET',
-      headers: {
-        "Accept": "application/json, text/plain, */*"
-      }
-    };
+      method: 'GET', // Default method
+      headers: new Headers({
+        Accept: 'application/json, text/plain, */*'
+      }),
+      mode: 'cors', // Default mode
+      credentials: 'same-origin', // Default credentials policy
+      cache: 'default', // Default cache policy
+      redirect: 'follow', // Default redirect policy
+      referrer: 'client', // Default referrer policy
+      referrerPolicy: 'no-referrer-when-downgrade', // Default referrer policy
+      integrity: '', // Default integrity
+      keepalive: false // Default keepalive
+    }
   }
 }