spyne 0.18.3 → 0.19.0

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

@@ -12,6 +12,7 @@ import {
   is
 } from 'ramda';
 import {SpyneAppProperties} from '../utils/spyne-app-properties';
+import {safeClone} from '../utils/safe-clone';
 
 export class ChannelPayload {
   /**
@@ -76,15 +77,15 @@ export class ChannelPayload {
 
 
 
-    channelPayloadItemObj.clone = () => clone(mergeAll([
-        {payload:ChannelPayload.deepClone(channelPayloadItemObj.payload)},
+    channelPayloadItemObj.clone = () => mergeAll([
+        {payload:safeClone(channelPayloadItemObj.payload)},
       channelPayloadItemObj.payload,
-        { channel },
-        { event: event },
+        { channel: clone(channel) },
+        { event: clone(event) },
         {srcElement: srcElement},
-                channelPayloadItemObj.srcElement, {
-        action: channelPayloadItemObj.action }
-         ]));
+                clone(channelPayloadItemObj.srcElement), {
+        action: clone(channelPayloadItemObj.action) }
+         ]);
 
 
 

package/src/spyne/channels/channel.js

@@ -84,7 +84,7 @@ export class Channel {
     this.checkForPersistentDataMode = Channel.checkForPersistentDataMode.bind(this);
     this.observer$ = this.props['observer'] = observer$;
     let dispatcherStream$ = this.streamsController.getStream('DISPATCHER');
-    const payloadPredByChannelName = propEq('name', props.name)
+    const payloadPredByChannelName = propEq(props.name, 'name')
     dispatcherStream$.pipe(filter(payloadPredByChannelName)).subscribe((val) => this.onReceivedObservable(val));
   }
 
@@ -295,7 +295,7 @@ export class Channel {
     //console.log("INCOMING ",{action, payload, srcElement}, {obj});
     const mergeProps = (d) => mergeAll([d, { action: prop('action', d) }, prop('payload', d), prop('srcElement', d)]);
     let dataObj = obsVal => ({
-      props: () => mergeProps(obj.data),
+      clone: () => mergeProps(obj.data),
       action, payload, srcElement,
       event: obsVal
     });
@@ -401,6 +401,13 @@ export class Channel {
   }
 
 
+  static checkForNotTrackFlag(props={}){
+    if (props.doNotTrack === true){
+      SpyneAppProperties.doNotTrackChannel(props.channelName);
+    }
+
+
+  }
 
 
 

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

@@ -45,8 +45,8 @@ export class ChannelsMap {
 
   static listRegisteredChannels(showOnlyProxies = false) {
     let proxyMap = this.getChannelsList();
-    let rejectProxyFn = reject(propEq('val', 'ChannelProxy'));
-    let filterProxyFn = filter(propEq('val', 'ChannelProxy'));
+    let rejectProxyFn = reject(propEq('ChannelProxy', 'val'));
+    let filterProxyFn = filter(propEq('ChannelProxy', 'val' ));
     let fn = showOnlyProxies === true ? filterProxyFn : rejectProxyFn;
     let removedProxyArr = fn(proxyMap);
     return pluck(['key'], removedProxyArr);
@@ -57,7 +57,7 @@ export class ChannelsMap {
 
   checkForMissingChannels() {
     let proxyMap = this.getChannelsList();
-    let filterProxyFn = filter(propEq('val', 'ChannelProxy'));
+    let filterProxyFn = filter(propEq('ChannelProxy', 'val'));
     let filterProxyArr = filterProxyFn(proxyMap);
 
     if (filterProxyArr.length >= 1) {

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

@@ -295,9 +295,18 @@ export class SpyneChannelWindow extends Channel {
       'CHANNEL_WINDOW_FOCUS_EVENT',
       'CHANNEL_WINDOW_FULLSCREENCHANGE_EVENT',
       'CHANNEL_WINDOW_FULLSCREENERROR_EVENT',
+      'CHANNEL_WINDOW_KEYUP_EVENT',
+      'CHANNEL_WINDOW_KEYDOWN_EVENT',
       'CHANNEL_WINDOW_LOAD_EVENT',
       'CHANNEL_WINDOW_MEDIA_QUERY_EVENT',
       'CHANNEL_WINDOW_MESSAGE_EVENT',
+      'CHANNEL_WINDOW_MOUSEDOWN_EVENT',
+      'CHANNEL_WINDOW_MOUSEENTER_EVENT',
+      'CHANNEL_WINDOW_MOUSELEAVE_EVENT',
+      'CHANNEL_WINDOW_MOUSEMOVE_EVENT',
+      'CHANNEL_WINDOW_MOUSEOUT_EVENT',
+      'CHANNEL_WINDOW_MOUSEOVER_EVENT',
+      'CHANNEL_WINDOW_MOUSEUP_EVENT',
       'CHANNEL_WINDOW_MOUSEWHEEL_EVENT',
       'CHANNEL_WINDOW_OFFLINE_EVENT',
       'CHANNEL_WINDOW_ONLINE_EVENT',

package/src/spyne/spyne-app.js

@@ -3,7 +3,7 @@ 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.3';
+const version = '0.19.0';
 
 class SpyneApplication {
   /**
@@ -41,7 +41,7 @@ class SpyneApplication {
   init(config = {}, testMode=false) {
     //this.channels = new ChannelsMap();
     /*!
-     * Spyne 0.18.3
+     * Spyne 0.19.0
      * https://spynejs.org
      *
      * @license Copyright 2017-2021, Frank Batista, Relevant Context, LLC. All rights reserved.

package/src/spyne/spyne.js

@@ -14,6 +14,7 @@ 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';
 
@@ -35,5 +36,6 @@ export {
   SpyneApp,
   SpyneAppProperties,
   SpynePlugin,
-  deepMerge
+  deepMerge,
+  safeClone
 };

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

@@ -47,7 +47,7 @@ export class ChannelFetchUtil {
    */
 
 
-  constructor(options, subscriber, testMode) {
+  constructor(options, subscriber, testMode, CHANNEL_NAME) {
 
     const testSubscriber = (p) => console.log('FETCH RETURNED ', p);
 
@@ -57,6 +57,7 @@ export class ChannelFetchUtil {
     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 = {
       mapFn: this.mapFn,
@@ -66,18 +67,27 @@ export class ChannelFetchUtil {
       debug: this.debug
     };
     if (testMode !== true) {
-      ChannelFetchUtil.startWindowFetch(fetchProps, this._subscriber);
+      ChannelFetchUtil.startWindowFetch(fetchProps, this._subscriber, this.channelName);
     }
   }
 
-  static startWindowFetch(props, subscriber) {
+  static startWindowFetch(props, subscriber, channelName) {
     let { mapFn, url, serverOptions, responseType, debug } = props;
-    const tapLogDebug = p => console.log('DEBUG FETCH :', p);
+    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}
+
+      return (data)=>{
+        return mapMethod(data, metadata);
+      }
+
+    }
+
     let response$ = from(window.fetch(url, serverOptions))
     .pipe(tap(tapLog), flatMap(r => from(r[responseType]())),
-        map(mapFn),
+        map(mapWrapper(mapFn)),
         publish());
 
     response$.connect();
@@ -126,7 +136,7 @@ export class ChannelFetchUtil {
 
   static updateMethodWhenBodyExists(opts) {
     const hasBody = has('body');
-    const methodIsGet = propEq('method', 'GET');
+    const methodIsGet = propEq('GET', 'method');
     const pred = allPass([hasBody, methodIsGet]);
     return when(pred, assoc('method', 'POST'))(opts);
   }

package/src/spyne/utils/safe-clone.js

@@ -0,0 +1,85 @@
+import {clone, compose, fromPairs, is, path, toPairs} from 'ramda';
+import {SpyneAppProperties} from './spyne-app-properties';
+
+
+
+
+const  getPropType = (prp) => {
+  let type = typeof prp;
+  if (['number', 'boolean', 'string'].includes(type)){
+    type = 'primitive';
+  } else if (type==='object'){
+    if (Array.isArray(prp)){
+      type = 'array'
+    } else if (prp===null){
+      type = 'undefined';
+    }
+  }
+  return type;
+}
+
+
+const  cmsDataReviveNestedProxyObj = (proxyObj, proxyReviverMethod) => {
+
+
+  const {__proxy__proxyName} = proxyObj;
+
+  if (__proxy__proxyName === undefined){
+    console.error('object is not proxy object ',proxyObj);
+  }
+
+  const cloneNestedProxyObj = (target, pathArr)=>{
+    const nestedProxyObj = path(pathArr, proxyObj);
+    const {__proxy__isProxy, __proxy__props} = nestedProxyObj;
+    return __proxy__isProxy ? proxyReviverMethod(target, __proxy__props) : target;
+  }
+
+
+  const rootObj = cloneNestedProxyObj(clone(proxyObj), []);
+
+
+  const proxyIterable = (iterObj, iterPath) => {
+    let dataPath = iterPath || [];
+    const loopObj = ([key, prop]) => {
+      const type = getPropType(prop);
+      const clonedPath = [...dataPath]
+      clonedPath.push(key);
+      if (type === 'object' || type==='array') {
+        iterObj[key] = cloneNestedProxyObj(prop, clonedPath);
+        proxyIterable(prop, clonedPath)
+      }
+    }
+    Object.entries(iterObj).forEach(loopObj);
+  }
+
+  proxyIterable(rootObj);
+  // console.timeEnd('proxify2');
+
+
+  return rootObj;
+
+
+}
+
+
+
+
+export const safeClone = function(o){
+  const {__proxy__proxyName} = o;
+  if (__proxy__proxyName!==undefined){
+    const proxyReviverMethod = SpyneAppProperties.getProxyReviver(__proxy__proxyName);
+    if (typeof  proxyReviverMethod === 'function'){
+      return cmsDataReviveNestedProxyObj(o, proxyReviverMethod);
+    }
+  }
+
+  const isArr = is(Array);
+  const isObj = is(Object);
+  const isIter = ob => isArr(ob)===false && isObj(ob)===true;
+  const isIterable = isIter(o);
+  return isIterable ? compose(fromPairs, toPairs, clone)(o) : clone(o);
+
+
+
+
+}

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

@@ -5,9 +5,11 @@ import {path} from 'ramda';
 
 let _config;
 let _channels;
-let _channelsMap
+let _channelsMap;
 let _initialized = false;
 let _debug = true;
+const _doNotTrackChannelsArr = [];
+const _proxiesMap = new Map();;
 
 const _spynePluginMethods = new SpynePluginsMethods();
 
@@ -162,6 +164,27 @@ class SpyneAppPropertiesClass{
 
   }
 
+
+
+  doNotTrackChannel(channelName){
+    _doNotTrackChannelsArr.push(channelName);
+  }
+
+  getUntrackedChannelsList(){
+    return _doNotTrackChannelsArr;
+  }
+
+
+  registerProxyReviver(name, method){
+    _proxiesMap.set(name, method);
+    //console.log("REGISTERD PROXY REVIVER",_proxiesMap, _proxiesMap.get(name));
+
+  }
+
+  getProxyReviver(proxyName){
+    return _proxiesMap.get(proxyName);
+  }
+
   getPluginConfigByPluginName(pluginName){
     return _config.plugins[pluginName];
   }

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

@@ -188,7 +188,7 @@ export class SpyneUtilsChannelRouteUrl {
     };
 
     const checkForEitherStrOrReMatch =  either(
-      propEq('str', mainStr), compose(test(__, mainStr), prop('re'))
+      propEq(mainStr, 'str'), compose(test(__, mainStr), prop('re'))
     );
 
     const findMatchIndex = compose(findLastIndex(equals(true)), map(checkForEitherStrOrReMatch), map(createStrRegexTest), map(checkForEmpty));

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

@@ -55,13 +55,12 @@ export class SpyneUtilsChannelRoute {
           return obj;
         };
 
-        const createPred = p => compose(keys, filter(propEq(p, true)));
+        const createPred = p => compose(keys, filter(propEq(true, p)));
 
         const getPropsState = compose(map(compareProps), uniq, chain(keys))([obj1, obj2]);
         let pathsChanged = chain(createPred('changed'), getPropsState);
         let pathsAdded = chain(createPred('added'), getPropsState);
         let pathsRemoved = chain(createPred('removed'), getPropsState);
-        // console.log("GET KEYS ", pathsChanged);
         obj1 = obj2;
         return { pathsAdded, pathsRemoved, pathsChanged };
       },

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

@@ -1,5 +1,6 @@
 import {includes, __, ifElse, path, prop, reject, is, isNil, isEmpty} from 'ramda';
 
+
 /**
  * @module DomElTemplate
  * @type util
@@ -133,8 +134,11 @@ import {includes, __, ifElse, path, prop, reject, is, isNil, isEmpty} from 'ramd
  */
 
 export class DomElementTemplate {
-  constructor(template, data) {
+  constructor(template, data={}) {
     this.template = this.formatTemplate(template);
+    this.isProxyData = data.__cms__isProxy === true;
+
+
 
     const checkForArrayData = ()=>{
       if (is(Array, data) === true) {
@@ -149,40 +153,60 @@ export class DomElementTemplate {
 
     this.templateData = data;
 
-
     let strArr = DomElementTemplate.getStringArray(this.template);
 
-
     let strMatches = this.template.match(DomElementTemplate.findTmplLoopsRE());
     strMatches = strMatches === null ? [] : strMatches;
 
     const parseTmplLoopsRE = DomElementTemplate.parseTmplLoopsRE();
+
     const parseTmplLoopFn =  this.parseTheTmplLoop.bind(this);
-    const mapTmplLoop = (str, data) => str.replace(parseTmplLoopsRE, parseTmplLoopFn);
-    const findTmplLoopsPred = includes(__, strMatches);
 
+    const mapTmplLoop = (str, data) => {
+      return str.replace(parseTmplLoopsRE, parseTmplLoopFn);
+    }
+
+    const findTmplLoopsPred = includes(__, strMatches);
     const checkForMatches = ifElse(
-      findTmplLoopsPred,
-      mapTmplLoop,
-      this.addParams.bind(this));
+        findTmplLoopsPred,
+        mapTmplLoop,
+        this.addParams.bind(this));
 
     this.finalArr = strArr.map(checkForMatches);
 
   }
 
+  static isPrimitiveTag(str){
+    return  /({{\.\*?}})/.test(str);;
+  }
+
+  // FIND CORRECT NESTED DATA
+  static getNestedDataReducer(data={}, param=""){
+    const dataReducer = (nestedData, str) =>{
+      if (nestedData[str]){
+        return nestedData[str];
+      }
+      return nestedData;
+    }
+    return  /(\.)/gm.test(String(param)) ?  String(param).split('.').reduce(dataReducer,data) : data[param];
+  }
+
   static getStringArray(template) {
     let strArr = template.split(DomElementTemplate.findTmplLoopsRE());
     const emptyRE = /^([\\n\s\W]+)$/;
     const filterOutEmptyStrings = s => s.match(emptyRE);
-    return reject(filterOutEmptyStrings, strArr);
+    const finalStr =  reject(filterOutEmptyStrings, strArr);
+
+    return finalStr;
+
   }
 
   static findTmplLoopsRE() {
-    return /({{#\w+}}[\w\n\s\W]+?{{\/\w+}})/gm;
+    return /({{#[\w.]+}}[\w\n\s\W]+?{{\/[\w.]+}})/gm;
   }
 
   static parseTmplLoopsRE() {
-    return /({{#(\w+)}})([\w\n\s\W]+?)({{\/\2}})/gm;
+    return /({{#([\w.]+)}})([\w\n\s\W]+?)({{\/\2}})/gm;
   }
 
   static swapParamsForTagsRE() {
@@ -196,10 +220,10 @@ export class DomElementTemplate {
   }
 
 
-    /**
-     *
-     * @desc Returns a document fragment generated from the template and any added data.
-     */
+  /**
+   *
+   * @desc Returns a document fragment generated from the template and any added data.
+   */
 
 
   renderDocFrag() {
@@ -207,7 +231,7 @@ export class DomElementTemplate {
     const isTableSubTag =   /^([^>]*?)(<){1}(\b)(thead|col|colgroup|tbody|td|tfoot|tr|th)(\b)([^\0]*)$/.test(html);
     const el = isTableSubTag ? html : document.createRange().createContextualFragment(html);
 
-      window.setTimeout(this.removeThis(), 2);
+    window.setTimeout(this.removeThis(), 2);
     return el;
 
   }
@@ -233,52 +257,97 @@ export class DomElementTemplate {
   }
 
   addParams(str) {
-    //console.time(this.tempL+'9')
     const re = /(\.)/gm;
-
     const replaceTags = (str, p1, p2, p3) => {
-      if (re.test(p2) === false && this.templateData[p2] !==undefined){
-        return this.templateData[p2];
-      }
-      return this.getDataValFromPathStr(p2, this.templateData);
+      return DomElementTemplate.getNestedDataReducer(this.templateData, p2);
     };
-
-   return str.replace(DomElementTemplate.swapParamsForTagsRE(), replaceTags);
+    return str.replace(DomElementTemplate.swapParamsForTagsRE(), replaceTags);
 
   }
 
-  parseTheTmplLoop(str, p1, p2, p3) {
 
-    //console.time(this.tempL+'5b')
+
+
+  parseTheTmplLoop(str, p1, p2, p3) {
+    const dotConverter = str=>`${str.replace(/(\.)/g, "][")}`
     const reDot = /(\.)/gm;
     const subStr = p3;
-    let elData = this.templateData[p2];
-    const parseString = (item, str) => {
+
+    const dataReducer = (acc, str) =>{
+      acc = acc[str];
+      return acc;
+    }
+
+
+    let elData = DomElementTemplate.getNestedDataReducer(this.templateData, p2);
+
+    const arrayStringToObjAdapter = (d,str, i)=>{
+
+      // IF {{.}} RUN parseString
+      if (DomElementTemplate.isPrimitiveTag(str)){
+        return parseString(d, str, i);
+      }
+
+      // CREATE DATA OBJ -- CHECK TO ADD PROXY VALUES
+      const createDataObj = ()=>{
+        const spyneLoopKey = d;
+        const loopIndex = i;
+        const loopNum = i+1;
+
+        if (this.isProxyData) {
+          const __cms__dataId = elData.__cms__dataId;
+          const keyIdStr = `__cms__keyFor_${d}`
+          const origKey = elData[keyIdStr];
+          return {spyneLoopKey, __cms__dataId, origKey, loopIndex, loopNum, d}
+
+        }
+        return {spyneLoopKey, loopIndex, loopNum};
+      }
+
+      return parseObject(createDataObj(), str, i);
+    }
+
+    const parseString = (item, str, index, origIndex) => {
       return str.replace(DomElementTemplate.swapParamsForTagsRE(), item);
     };
-    const parseObject = (obj, str) => {
+
+
+    // PARSING ARRAYS AND OBJECTS
+    const parseObject = (obj, str, i) => {
+      /// LOOP NUMBER VALUES AUTO ADDED
+
+      //const loopIndex = i;
+      //const loopNum = i+1;
+
       const loopObj = (str, p1, p2) => {
         // DOT SYNTAX CHECK
+        const hash = {
+          loopIndex: i,
+          loopNum: i+1
+        }
+
+        // IF {{.}}
         if (reDot.test(p2) === false && obj[p2] !==undefined) {
-          return obj[p2]
+          return hash[p2] !== undefined ? hash[p2] : obj[p2]
         }
 
-        return this.getDataValFromPathStr(p2, obj);
+        const dataReducedVal  = this.getDataValFromPathStr(p2, obj);
+        return hash[p2] !== undefined ? hash[p2] : dataReducedVal
       };
       return str.replace(DomElementTemplate.swapParamsForTagsRE(), loopObj);
     };
-    const mapStringData = (d) => typeof(d) === 'string' ? parseString(d, subStr) : parseObject(d, subStr);
 
+    const mapStringData = (d, i) => typeof(d) === 'string' ? arrayStringToObjAdapter(d, subStr,  i) : parseObject(d, subStr, i);
 
     if (isNil(elData) === true || isEmpty(elData)) {
       return '';
     }
 
     if (elData.length===undefined) {
-          elData = [elData];
-      }
+      elData = [elData];
+    }
 
-     return elData.map(mapStringData).join('');
+    return elData.map(mapStringData).join('');
 
 
   }

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

@@ -155,9 +155,17 @@ export class ViewStreamElement {
     let container =  isNil(d.query) ? d.node : d.query;
     let prepend = (node, item) => node.insertBefore(item, node.firstChild);
     let append = (node, item) => node.appendChild(item);
+    let after = (node, item) => node.after(item);
+
+    const defaultFn = prepend;
+    const attachTypeHash = {
+      'appendChild' : append,
+      'after' : after
+    }
     // DETERMINE WHETHER TO USE APPEND OR PREPEND
     // ON CONNECTING DOM ITEMS TO EACH OTHER
-    let attachFunc = d.attachType === 'appendChild' ? append : prepend;
+    //let attachFunc = d.attachType === 'appendChild' ? append : prepend;
+    const attachFunc = attachTypeHash[d.attachType] || defaultFn;
     attachFunc(container, this.domItem.render());
     this.setAnimateIn(d);
   }

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

@@ -1,4 +1,5 @@
 import {SpyneAppProperties} from '../utils/spyne-app-properties';
+import {safeClone} from '../utils/safe-clone';
 import { gc } from '../utils/gc';
 import {
   compose,
@@ -36,7 +37,8 @@ export class ViewStreamPayload {
 
   sendToDirectorStream(payload) {
     let directorStream$ = SpyneAppProperties.channelsMap.getStream('DISPATCHER');
-    const frozenPayload = ViewStreamPayload.deepClone(payload);
+    const frozenPayload = safeClone(payload);
+    //console.log("VS PAYLOAD ",frozenPayload);
     directorStream$.next(frozenPayload);
     payload = undefined;
 

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

@@ -33,7 +33,7 @@ function testSelectors(cxt, str, verboseBool) {
   const elIsDomElement = compose(lte(0), defaultTo(-1),
       prop('nodeType'));
 
-  if (elIsDomElement(el) === false) {
+  if (el !== null && elIsDomElement(el) === false) {
     console.warn(`Spyne Warning: the el object is not a valid single element, ${el}`);
     return;
   }
@@ -52,18 +52,37 @@ function testSelectors(cxt, str, verboseBool) {
 
 function getNodeListArray(cxt, str, verboseBool=false) {
   let selector = str !== undefined ? `${cxt} ${str}` : cxt;
+  let isParent = false;
 
 
   const returnSelectorIfValid = (selector) => {
-        try { document.querySelectorAll(selector) } catch (e) { return [] }
-        return  document.querySelectorAll(selector);
+        let arr = [];
+        try {
+          arr = document.querySelectorAll(selector)
+        } catch (e) { arr = [] }
+        try {
+          isParent = document.querySelector(str) === document.querySelector(cxt);
+          if (isParent === true){
+            arr =  [document.querySelector(str)];
+          }
+        } catch(e){
+          //return [];
+        }
+        return  arr;// document.querySelectorAll(selector);
       };
 
 
+  const elArr =  returnSelectorIfValid(selector);
+
   if (verboseBool===true) {
-    testSelectors(cxt, str, verboseBool);
+    const mainSel = isParent === true ? 'body' : cxt;
+    testSelectors(mainSel, str, verboseBool);
   }
-  return returnSelectorIfValid(selector)
+
+  return elArr;
+
+
+
 }
 
 function setInlineCss(val, cxt, str) {