spyne 0.16.2 → 0.18.2

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

@@ -1,17 +1,16 @@
 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,
+  find,
   omit,
   over,
   mergeRight,
-  mergeDeepRight,
   is,
   objOf,
   mergeAll,
@@ -32,7 +31,10 @@ import {
     reverse,
   curryN,
   __,
-  test, replace, fromPairs, toPairs, forEach, reduceRight, reduce
+  test,
+  replace,
+  toPairs,
+  reduce
 } from 'ramda';
 const ramdaFilter = require('ramda').filter;
 const rMerge = require('ramda').mergeRight;
@@ -139,16 +141,15 @@ export class SpyneChannelRoute extends Channel {
     this.bindStaticMethods();
     this.navToStream$ = new ReplaySubject(1);
     this.observer$ = this.navToStream$.pipe(map(info => this.onMapNext(info)));
-    // let compareKeysFn = SpyneUtilsChannelRoute.compareRouteKeywords.bind(this);
     this.compareRouteKeywords = SpyneUtilsChannelRoute.compareRouteKeywords();
   }
 
   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;
     }
 
   }
@@ -178,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();
@@ -194,21 +192,18 @@ 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;
     }
 
     let arr = SpyneUtilsChannelRoute.flattenConfigObject(routeConfig.routes);
-    // console.log("FLATTENED CONFIG ",arr);
     routeConfig['paramsArr'] = arr;
-    //console.log("ROUTE CONFIG IS ",routeConfig);
     return routeConfig;
   }
 
@@ -223,7 +218,6 @@ export class SpyneChannelRoute extends Channel {
   }
 
   onMapNext(data, firstLoaded = false) {
-   // console.log("MAP NEXT ",{firstLoaded, data});
     data['action'] = 'CHANNEL_ROUTE_CHANGE_EVENT';
     return data;
   }
@@ -250,15 +244,11 @@ export class SpyneChannelRoute extends Channel {
 
     let keywordArrs = this.compareRouteKeywords.compare(payload.routeData, payload.paths);
     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$);
 
   }
 
   static checkForRouteParamsOverrides(payload) {
-    // console.log("CHECK FOR OVERRIDES ",payload);
-
     return payload;
   }
 
@@ -283,32 +273,14 @@ export class SpyneChannelRoute extends Channel {
   }
 
 
-
-/*
-  static checkToPreventDefaultEvent(obs) {
-    const checkDataForPreventDefault = pathEq(['viewStreamInfo', 'payload', 'eventPreventDefault'], 'true');
-    const setPreventDefault = (evt) => {
-      if (evt !== undefined) {
-        evt.preventDefault();
-      }
-    };
-    const selectEvtAndPreventDefault = compose(setPreventDefault, prop('event'));
-    const checkForPreventDefault = when(checkDataForPreventDefault, selectEvtAndPreventDefault);
-    checkForPreventDefault(obs);
-  }
-*/
-
-
   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 : compose(equals(true), path(['Spyne','config', 'debug']))(win);
+    const debug = debugBool !== undefined ? debugBool : SpyneAppProperties.debug === true;
      const {payload} = pl;
 
 
@@ -319,7 +291,6 @@ export class SpyneChannelRoute extends Channel {
           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;
 
         }
@@ -350,7 +321,6 @@ export class SpyneChannelRoute extends Channel {
               acc.push(routeName)
             }
           }
-         // compose(reduce(onReduceRoutePaths), toPairs)(nextRoutePath);
         }
         return acc;
 
@@ -378,17 +348,15 @@ export class SpyneChannelRoute extends Channel {
     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;
     let keywordArrs = this.compareRouteKeywords.compare(payload.routeData, payload.paths);
+
     payload = rMerge(payload, keywordArrs);
-    // this.checkForRouteParamsOverrides(payload);
     this.sendRouteStream(payload, changeLocationBool);
-     //console.log("SEND STREAM onViewStreamInfo", payload);
+
     payload = SpyneChannelRoute.removeSSID(payload);
 
     this.sendChannelPayload(action, payload, srcElement, event,
@@ -429,11 +397,10 @@ export class SpyneChannelRoute extends Channel {
   static getExtraPayloadParams(config = this.routeConfigJson, isHistory=false) {
     let routeCount = this.getRouteCount(isHistory);
     let isDeepLink = this.getIsDeepLinkBool(isHistory);
-    //console.log("GETTING DEEP LINK ", {routeCount, isDeepLink,isHistory, config})
     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) {
@@ -448,12 +415,11 @@ export class SpyneChannelRoute extends Channel {
     let nextWindowLoc = SpyneUtilsChannelRouteUrl.formatStrAsWindowLocation(routeValue);
     let dataFromStr = this.getDataFromLocationStr(typeForStr, isHashForStr, nextWindowLoc);
 
-    // console.log(" DATA FROM STRING ",{routeValue, pl, dataFromStr});
     let { pathInnermost, paths } = dataFromStr;
 
     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,
@@ -464,6 +430,7 @@ export class SpyneChannelRoute extends Channel {
       routeValue,
       isHash,
       isHidden,
+      isHistory,
       routeType
     };
   }
@@ -471,7 +438,6 @@ export class SpyneChannelRoute extends Channel {
   static getDataFromString(config = this.routeConfigJson, isHistory=false) {
     const type = config.type;
     const hashIsTrue = config.isHash === true;
-    // type = config.isHash === true ? ''
     const str = SpyneUtilsChannelRouteUrl.getLocationStrByType(type, hashIsTrue);
     let { paths, pathInnermost, routeData, routeValue } = SpyneChannelRoute.getParamsFromRouteStr(
       str, config, type);
@@ -487,6 +453,7 @@ export class SpyneChannelRoute extends Channel {
       routeValue,
       isHash,
       isHidden,
+      isHistory,
       routeType
     };
     return obj;
@@ -497,7 +464,6 @@ export class SpyneChannelRoute extends Channel {
       ? this.routeConfigJson.type
       : t;
 
-    // console.log("DATA CHECK STRING ",loc);
     const str = SpyneUtilsChannelRouteUrl.getLocationStrByType(type, isHash, loc);
     let { paths, pathInnermost, routeData, routeValue } = this.getParamsFromRouteStr(
       str, this.routeConfigJson, type);
@@ -522,15 +488,12 @@ export class SpyneChannelRoute extends Channel {
   static getRouteStrFromParams(paramsData, routeConfig, t) {
     const type = t !== undefined ? t : routeConfig.type;
     let obj = SpyneUtilsChannelRouteUrl.convertParamsToRoute(paramsData, routeConfig, type);
-
-    // console.log("ROUTE getRouteStrFromParams ",paramsData,obj);
     return obj;
   }
 
   static getParamsFromRouteStr(str, routeConfig, t) {
     const type = t !== undefined ? t : routeConfig.type;
     let obj = SpyneUtilsChannelRouteUrl.convertRouteToParams(str, routeConfig, type);
-    // console.log("ROUTE getParamsFromRouteStr ",obj);
     return obj;
   }
 
@@ -540,7 +503,6 @@ export class SpyneChannelRoute extends Channel {
     const hashNameIsEmptyBool = isEmptyBool === true && isHash === true;
     const hashNameBool = isEmptyBool === false && isHash === true;
 
-    // console.log('ROUTE STR CHECK ', {str, isHash});
     if (pathNameIsEmptyBool === true || hashNameIsEmptyBool === true) {
       return '/';
     } else if (hashNameBool === true) {
@@ -560,11 +522,8 @@ export class SpyneChannelRoute extends Channel {
     if (isHash === true) {
       let pathName = SpyneChannelRoute.removeLastSlash(window.location.pathname);
       routeValue = pathName + routeValue;
-      // window.location.hash = routeValue;
-      // console.log('ROUTE STR FOR HASH ', routeValue);
       window.history.pushState({routeCount}, '', routeValue);
     } else {
-      // routeValue =  when(isEmpty, always('/'))(routeValue);
       const checkForSlash = when(
         compose(complement(equals('/')), head), concat('/', __));
       window.history.pushState({routeCount}, '', checkForSlash(routeValue));

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

@@ -25,7 +25,6 @@ export class SpyneChannelUI extends Channel {
     super(name, props);
     this.keyEventsLoaded = false;
     this.keyCodeArr = [];
-    // this.addKeyEvent(13);
   }
 
   addRegisteredActions() {
@@ -44,6 +43,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',
@@ -136,7 +136,6 @@ export class SpyneChannelUI extends Channel {
   onIncomingObservable(obj) {
     let eqsName = equals(obj.name, this.props.name);
     obj.data = SpyneChannelUI.removeSSID(obj.data);
-    //console.log("OBJECT DATA ",obj.data);
     let {payload, srcElement} = obj.data;
     let dataObj = obsVal => ({ payload, srcElement, event: obsVal });
     let onSuccess = (obj) => obj.observable.pipe(map(dataObj))

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, pick, partialRight, mapObjIndexed, apply} from 'ramda';
 import {deepMerge} from '../utils/deep-merge';
 
 const rMap = require('ramda').map;
@@ -37,11 +38,11 @@ export class SpyneChannelWindow extends Channel {
     super(CHANNEL_NAME);
     this.bindStaticMethods();
     this.currentScrollY=0;
-    // 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 +141,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,28 +156,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;
-              window.scrollTo(x,y);
-            }
-            return p;
-          }),*/
         debounceTime(dTime),
         skipWhile(skipWhenDirIsMissing),
         map(p=>{
-          const newScrollY = SpyneChannelWindow.getScrollY(window);
+          const newScrollY = SpyneChannelWindow.getScrollY(element);
           p.payload['scrollDistanceAbs'] = Math.abs(this.currentScrollY-newScrollY);
           this.currentScrollY=newScrollY;
           return p;
@@ -213,13 +207,11 @@ export class SpyneChannelWindow extends Channel {
     // CHECK TO ADD MEDIA QUERY OBSERVABLE
     // ==========================================
     config['listenForMediaQueries'] = checkIfObjIsNotEmptyOrNil(
-      config.mediqQueries);
+      config.mediaQueries) || checkIfObjIsNotEmptyOrNil(
+        config.mediqQueries);
 
     // =========================================
 
-    // config.listenForResize = false;
-    // config.listenForMouseWheel = true;
-    // config.listenForScroll = false;
     let methods = {
       'listenForResize': this.createResizeObservable.bind(this),
       'listenForOrientation': this.createOrientationObservable.bind(this),
@@ -317,6 +309,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',
@@ -332,24 +325,20 @@ export class SpyneChannelWindow extends Channel {
   }
 
   onScrollLockEvent(e){
-    const setScrollPos = ()=>{
-      window.Spyne.config.scrollLockX = window.scrollX;
-      window.Spyne.config.scrollLockY = window.scrollY;
-    };
-    let {action, scrollLock} = e.payload;
-    window.Spyne.config.scrollLock = scrollLock;
-    if (scrollLock === true){
-      setScrollPos();
-    }
-
-    this.sendChannelPayload(action, {scrollLock});
+    // DEPRECATED -- MOVED TO spyne-plugin-scroll-lock;
   }
 
   onSetElementToScroll(e){
 
-    let {config, scrollElement} = e.payload;
+    let {config, el, scrollElement} = e.payload;
+    config = config || {};
     config = deepMerge(this.domChannelConfig, config);
 
+    scrollElement = scrollElement || el;
+
+    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;

package/src/spyne/spyne-app.js

@@ -0,0 +1,165 @@
+import {ChannelsMap} from './channels/channels-map';
+import {ViewStream} from './views/view-stream';
+import {SpyneAppProperties} from './utils/spyne-app-properties';
+import {deepMerge} from './utils/deep-merge';
+const _channels = new ChannelsMap();
+const version = '0.18.2';
+
+class SpyneApplication {
+  /**
+   *
+   * SpyneApp creates the global Spyne object, and creates the following items
+   * <ul>
+   *
+   * <li>LINK['ChannelsMap', 'channels-controller'] that directs the flow of data to all Channels</li>
+   * <li>LINK['SpyneChannelUI', 'spyne-channel-u-i'], that broadcast all user interaction events</li>
+   * <li>LINK['SpyneChannelRoute', 'spyne-channel-route'], that broadcast window location changes and is the only other channel that can be bound to user events</li>
+   * <li>LINK['SpyneChannelWindow', 'spyne-channel-window'], that broadcast all requested window and document events, such as scrolling, resizing and media queries</li>
+   * <li>LINK['SpyneChannelLifecycle', 'spyne-channel-lifecycle'], that broadcasts rendering and removing of ViewStream elements that have been directed to broadcast their lifecycle events</li>
+   * </ul>
+   *
+   *
+   * @module SpyneApp
+   * @type core
+   *
+   * @constructor
+   * @param {Object} config
+   * @property {Object} config - = {}; This global config object is mainly used to provide configuration details for two SpyneChannels, CHANNEL_ROUTE and CHANNEL_WINDOW.
+   */
+
+  constructor() {
+    this.version = version
+
+    //console.log('spyne app created')
+
+
+  }
+  get channels(){
+    return _channels;
+  }
+
+  init(config = {}, testMode=false) {
+    //this.channels = new ChannelsMap();
+    /*!
+     * Spyne 0.18.2
+     * https://spynejs.org
+     *
+     * @license Copyright 2017-2021, Frank Batista, Relevant Context, LLC. All rights reserved.
+     * Spyne is licensed under the GNU Lesser General Public License v3.0
+     *
+     * @author: Frank Batista,
+     * @email:  frbatista.nyc@gmail.com
+    */
+    /* eslint-disable */
+
+
+    if(SpyneAppProperties.initialized === true){
+      if (testMode){
+        return 'The Spyne Application has already been initialized!';
+      } else {
+        console.warn('The Spyne Application has already been initialized!');
+      }
+      return
+    }
+
+
+    let defaultConfig = {
+      scrollLock: false,
+      scrollLockX: 31,
+      scrollLockY: 0,
+      debug: true,
+      plugins:{
+
+      },
+      tmp: {},
+      channels: {
+        WINDOW: {
+          mediqQueries: {
+
+          },
+          events: [],
+          listenForResize: true,
+          listenForOrientation: true,
+          listenForScroll: false,
+          listenForMouseWheel: false,
+          debounceMSTimeForResize: 200,
+          debounceMSTimeForScroll: 150
+        },
+
+        ROUTE: {
+          type: 'slash',
+          isHash: false,
+          isHidden: false,
+          add404s: false,
+          routes: {
+            'routePath' : {
+              'routeName' : 'change'
+            }
+          }
+
+        }
+      }
+    };
+    if (config !== undefined) {
+       config = SpyneAppProperties.initialize(defaultConfig, config, _channels);
+      window.Spyne = this;
+      window.Spyne['config'] = deepMerge(defaultConfig, config)
+    }
+
+    this.pluginsFn = SpyneAppProperties.getPluginsMethodObj(config['pluginMethods']);
+    this.getChannelActions = (str) => _channels.getChannelActions(str);
+    this.registerChannel = (val) => _channels.registerStream(val);
+    this.registerDataChannel = (obs$) => _channels.registerStream(obs$);
+    this.listChannels = () => Array.from(_channels.map.keys());
+    let nullHolder = new ViewStream({ id:'spyne-null-views' });
+    nullHolder.appendToDom(document.body);
+    nullHolder.props.el.style.cssText = 'display:none; opacity:0; pointer-events:none;';
+    _channels.init();
+
+    if (SpyneAppProperties.config.debug===true){
+       //window.Spyne = {version};
+    }
+
+
+  }
+
+  /**
+   * 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} str
+   * @returns {Array} An array of Actions that can be listened to
+   */
+  static getChannelActions(str) {
+    return _channels.getChannelActions(str);
+  }
+
+  /**
+   *
+   * This method will add the channel to the registered list so that it can subscribed by all ViewStream and Channel instances.
+   * @param {Channel} c
+   *
+   *
+   */
+  static registerChannel(c) {
+    if (SpyneAppProperties.initialized === false) {
+      console.warn('Spyne has not been initialized');
+    } else {
+      return _channels.registerStream(c);
+    }
+  }
+}
+
+
+export let SpyneApp = new SpyneApplication();