jqx-es 1.2.4 → 1.2.5

package/src/HandlerFactory.js

@@ -8,7 +8,7 @@ const getCapture = eventType => !!(shouldCaptureEventTypes.find(t => t === event
 export { handlerStore as listeners, HandleFactory as default };
 
 function HandleFactory(jqx) {
-  return function(spec) { /*NODOC*/
+  return function(spec) {
     let {eventType, selector, callback, name, capture, once, canRemove} = spec;
 
     switch(true) {
@@ -54,10 +54,10 @@ function HandleFactory(jqx) {
   function removeHandlerFactory(spec) {
     const {once, abortcontroller, name, eventType} = spec;
     return !name
-      ? function() { jqx.logger.error(`An anonymous listener can not be removed`); }
+      ? function() { jqx.logger.error(`JQx: an anonymous listener can not be removed`); }
       : !abortcontroller
         ? function(evt) {
-            jqx.logger.error(`Listener for event type [${eventType}] with name [${
+            jqx.logger.error(`JQx: listener for event type [${eventType}] with name [${
               name}] is not marked as removable`);
           }
         : function removeHandler() {
@@ -65,7 +65,7 @@ function HandleFactory(jqx) {
           const toRemove = [...handlerStore[eventType].entries()].find(([k, v]) => v.name === name);
           handlerStore[eventType].delete(toRemove[0]);
           setTimeout( () =>
-            jqx.logger.log(`Listener for event type [${eventType}] with name [${
+            jqx.logger.log(`JQx: Listener for event type [${eventType}] with name [${
               name}] was removed${once ? ` (once active, so handled once).` : ``}`), 100 );
           }
   }

package/src/JQxFactory.js

@@ -5,7 +5,7 @@ import { listeners, default as HandleFactory } from "./HandlerFactory.js";
 import tagLib from "./HTMLTags.js";
 import {
   randomString, toDashedNotation, IS, tagFNFactory as $T, styleFactory, toCamelcase, systemLog, escHtml,
-  isNonEmptyString, resolveEventTypeParameter, selectedExtensionHelpers, insertPositions,
+  isNonEmptyString, resolveEventTypeParameter, selectedFactoryHelpers, insertPositions
 } from "./Utilities.js";
 
 let instanceGetters, instanceMethods;
@@ -16,15 +16,17 @@ const {
 
 export { proxify, addJQxStaticMethods };
 
-/* region functions */
 function selectedUtilitiesFactory() {
-  const cssRuleEdit = styleFactory({createWithId: `JQxStylesheet`});
-  const addFn = (name, fn) => instanceMethods[name] = (self, ...params) => fn(self, ...params);
-  return { ...selectedExtensionHelpers(), ...{ cssRuleEdit, addFn } };
+   return {
+    ...selectedFactoryHelpers(),
+    addFn(name, extensionMethod) {
+      systemLog.log(`JQx: added extension function [${name}]`);
+      return instanceMethods[name] = (self, ...params) => extensionMethod(self, ...params);
+    } };
 }
 
 function proxify(instance) {
-  return new Proxy( instance, { get: (obj, key) => proxyKeyFactory(obj, key, instance) } );
+  return new Proxy( instance, Object.freeze({ get: (obj, key) => proxyKeyFactory(obj, key, instance) }) );
 }
 
 function wrap(method, instance) {
@@ -162,25 +164,27 @@ function delegateCaptureFactory(listen) {
     let {type, origin, selector, handlers, name, capture, once, canRemove} = spec;
     const typesResolved = resolveEventTypeParameter(type);
     const specifiedName = name;
-    if (!IS(handlers, Function, Array)) { return; }
     handlers = IS(handlers, Function) ? [handlers] : handlers;
     canRemove = IS(canRemove, Boolean) ? canRemove : false;
-    const params = { eventType: typesResolved, selector: selector || origin, capture,
+    const params = {
+      eventType: typesResolved, selector: selector || origin, capture,
       name: specifiedName, once, canRemove };
+
     switch(true) {
       case IS(typesResolved, Array) && typesResolved.length > 0:
         for (const type of typesResolved) {
           params.eventType = type;
-          for (const handler of handlers) { doHandle(handler); }
+          assignListeners(handlers, params, listen);
         }
-        return;
-      default: for (const handler of handlers) { doHandle(handler); }
+        break;
+      default: return assignListeners(handlers, params, listen);
     }
+  }
+}
 
-    function doHandle(handler) {
-      params.name = specifiedName;
-      IS(handler, Function) && listen({...params, callback: handler});
-    }
+function assignListeners(handlers, params, listen) {
+  for (const handler of handlers) {
+    listen({...params, callback: handler});
   }
 }
 
@@ -247,4 +251,3 @@ function staticMethodsFactory(jqx) {
     get Popup() { return popupGetter(jqx); },
   };
 }
-/* endregion functions */

package/src/JQxMethods.js

@@ -1,116 +1,13 @@
 import {createElementFromHtmlString, inject2DOMTree} from "./DOM.js";
-import {ATTRS} from "./EmbedResources.js";
 import {
   IS, isNode, truncateHtmlStr, addHandlerId, ExamineElementFeatureFactory,
   isNonEmptyString, toDashedNotation, randomString, escHtml, systemLog,
-  insertPositions, isCommentOrTextNode, datasetKeyProxy
+  insertPositions, datasetKeyProxy, loop, cloneAndDestroy, setData, before,
+  after, findParentScrollDistance, emptyElement, checkProp, css, assignAttrValues,
+  applyStyle,
 } from "./Utilities.js";
 
-const isIt = ExamineElementFeatureFactory();
-
-/* region functions */
-function emptyElement(el) {
-  return el && (el.textContent = "");
-}
-
-function loop(instance, callback) {
-  const cleanCollection = instance.collection.filter(el => !isCommentOrTextNode(el));
-  for (let i = 0; i < cleanCollection.length; i += 1) {
-    callback(cleanCollection[i], i);
-  }
-
-  return instance;
-}
-
-function compareCI(key, compareTo) {
-  return key.toLowerCase().trim() === compareTo.trim().toLowerCase();
-}
-
-function cloneAndDestroy(elem) {
-  const cloned = elem.cloneNode(true)
-  cloned.removeAttribute && cloned.removeAttribute(`id`);
-  elem.isConnected ? elem.remove() : elem = null;
-  return cloned;
-}
-
-function setData(el, keyValuePairs) {
-  if (el && IS(keyValuePairs, Object)) {
-    for (const [key, value] of Object.entries(keyValuePairs)) {
-      el.setAttribute(`data-${toDashedNotation(key)}`, value);
-    }
-  }
-}
-
-function before (instance, elem2AddBefore) {
-  return instance.andThen(elem2AddBefore, true);
-}
-
-function after(instance, elem2AddAfter) {
-  return instance.andThen(elem2AddAfter);
-}
-
-function checkProp(prop) {
-  return prop.startsWith(`data`) || ATTRS.html.find(attr => prop.toLowerCase() === attr);
-}
-
-function css(el, keyOrKvPairs, value, jqx) {
-  if (value && IS(keyOrKvPairs, String)) {
-    keyOrKvPairs = {[keyOrKvPairs]: value === "-" ? "" : value};
-  }
-
-  let nwClass = undefined;
-
-  if (keyOrKvPairs.className) {
-    nwClass = keyOrKvPairs.className;
-    delete keyOrKvPairs.className;
-  }
-
-  const classExists = ([...el.classList].find(c => c.startsWith(`JQxClass-`) || nwClass && c === nwClass));
-  nwClass = classExists || nwClass || `JQxClass-${randomString().slice(1)}`;
-  jqx.editCssRule(`.${nwClass}`, keyOrKvPairs);
-  el.classList.add(nwClass);
-}
-
-function assignAttrValues(/*NODOC*/el, keyValuePairs) {
-  if (el) {
-    for (let [key, value] of Object.entries(keyValuePairs)) {
-      key = toDashedNotation(key);
-      if (key.startsWith(`data`)) {
-        return setData(el, value);
-      }
-
-      if (IS(value, String) && checkProp(key)) {
-        el.setAttribute(key, value.split(/[, ]/)?.join(` `));
-      }
-    }
-  }
-}
-
-function applyStyle(el, rules) {
-  if (IS(rules, Object)) {
-    for (let [key, value] of Object.entries(rules)) {
-      let priority;
-      if (/!important/i.test(value)) {
-        value = value.slice(0, value.indexOf(`!`)).trim();
-        priority = 'important';
-      }
-
-      el.style.setProperty(toDashedNotation(key), value, priority)
-    }
-  }
-}
-
-function logDebug(...args) {
-  debugLog.log(`❗` + args.map(v => String(v)).join(`, `) ) ;
-}
-
-function findParentScrollDistance(node, distance = 0, top = true) {
-  node = node?.parentElement;
-  const what = top ? `scrollTop` : `scrollLeft`;
-  distance += node ? node[what] : 0;
-  return !node ? distance : findParentScrollDistance(node, distance, top);
-}
-/* endregion functions */
+const instanceIs = ExamineElementFeatureFactory();
 
 /* region exportfunctions */
 function factoryExtensionsFactory(jqx) {
@@ -179,7 +76,7 @@ function factoryExtensionsFactory(jqx) {
         return instance.HTML.set(content + instance.HTML.get(), false, escape);
       },
     }),
-    is: instance => isIt(instance),
+    is: instance => instanceIs(instance),
     length: instance => instance.collection.length,
     outerHtml: instance => (instance.first() || {outerHTML: undefined}).outerHTML,
     parent: instance =>{
@@ -233,7 +130,7 @@ function instanceExtensionsFactory(jqx) {
     afterMe: after,
     andThen: (instance, elem2Add, before = false) => {
       if (!elem2Add || !IS(elem2Add, String, Node, Proxy)) {
-        logDebug(`[JQx instance].[beforeMe | afterMe | andThen]: insufficient input [${elem2Add}]`, );
+        systemLog.log(`[JQx instance].[beforeMe | afterMe | andThen]: insufficient input [${elem2Add}]`, );
         return instance;
       }
 

package/src/Utilities.js

@@ -1,24 +1,34 @@
 import {default as tagFNFactory} from "./tinyDOM.js";
 import {default as IS, maybe} from "./TypeofAnything.js";
 import styleFactory from "./LifeCSS.js";
+import {ATTRS} from "./EmbedResources.js";
 
 const characters4RandomString = [...Array(26)]
   .map((x, i) => String.fromCharCode(i + 65))
   .concat([...Array(26)].map((x, i) => String.fromCharCode(i + 97)))
   .concat([...Array(10)].map((x, i) => `${i}`));
 const systemLog = systemLogFactory();
-const datasetKeyProxy = {
+const datasetKeyProxy = Object.freeze({
   get(obj, key) { return obj[toCamelcase(key)] || obj[key]; },
   enumerable: false,
   configurable: false
-};
-const insertPositions = new Proxy({
+});
+const insertPositions = Object.freeze(new Proxy({
   start: "afterbegin", afterbegin: "afterbegin",
   end: "beforeend", beforeend: "beforeend",
   before: "beforebegin", beforebegin: "beforebegin",
   after: "afterend", afterend: "afterend" }, {
   get(obj, key) { return obj[String(key).toLowerCase()] ?? obj[key]; }
-});
+}));
+
+export {
+  addHandlerId, after, applyStyle, assignAttrValues, before, checkProp, cloneAndDestroy, css, datasetKeyProxy,
+  ElemArray2HtmlString, emptyElement, escHtml, ExamineElementFeatureFactory, findParentScrollDistance,
+  input2Collection, insertPositions, IS, isArrayOfHtmlElements, isArrayOfHtmlStrings, isCommentOrTextNode,
+  isHtmlString, isNode, isNonEmptyString, logTime, loop, maybe, randomNr, randomString, resolveEventTypeParameter,
+  selectedFactoryHelpers, setCollectionFromCssSelector, setData, styleFactory, systemLog, tagFNFactory,
+  toCamelcase, toDashedNotation, truncate2SingleStr, truncateHtmlStr,
+};
 
 function pad0(nr, n=2) {
   return `${nr}`.padStart(n, `0`);
@@ -41,6 +51,15 @@ function resolveEventTypeParameter (maybeTypes) {
     : IS(maybeTypes, String) && maybeTypes?.trim().toLowerCase() || ``;
 }
 
+function loop(instance, callback) {
+  const cleanCollection = instance.collection.filter(el => !isCommentOrTextNode(el));
+  for (let i = 0; i < cleanCollection.length; i += 1) {
+    callback(cleanCollection[i], i);
+  }
+
+  return instance;
+}
+
 function shuffle(array) {
   let i = array.length;
   while (i--) {
@@ -50,11 +69,6 @@ function shuffle(array) {
   return array;
 }
 
-function hex2Full(hex) {
-  hex = (hex.trim().startsWith("#") ? hex.slice(1) : hex).trim();
-  return hex.length === 3 ? [...hex].map(v => v + v).join("") : hex;
-}
-
 function truncateHtmlStr(str, maxLength = 120) {
  return `${str}`
    .trim()
@@ -96,17 +110,14 @@ function logTime() {
       pad0(d.getSeconds())}.${pad0(d.getMilliseconds(), 3)}]`)(new Date());
 }
 
-function hex2RGBA(hex, opacity = 100) {
-  hex = hex2Full(hex.slice(1));
-  const op = opacity % 100 !== 0;
-  return `rgb${op ? "a" : ""}(${
-    parseInt(hex.slice(0, 2), 16)}, ${
-    parseInt(hex.slice(2, 4), 16)}, ${
-    parseInt(hex.slice(-2), 16)}${op ? `, ${opacity / 100}` : ""})`;
-}
-
 function escHtml(html) {
-  return html.replace(/</g, `&lt;`).replace(/>/g, `&gt;`);
+  switch(true) {
+    case IS(html, String):
+      const tmpDiv = document.createElement("div");
+      tmpDiv.append(html);
+      return tmpDiv.innerHTML;
+    default: return html;
+  }
 }
 
 function isCommentOrTextNode(node) {
@@ -171,11 +182,11 @@ function  addHandlerId(instance) {
   return `[data-hid="${handleId}"]`;
 }
 
-function selectedExtensionHelpers() {
+function selectedFactoryHelpers() {
   return {
     isCommentOrTextNode, isNode, isComment, isText, isHtmlString, isArrayOfHtmlElements,
     isArrayOfHtmlStrings, ElemArray2HtmlString, input2Collection, setCollectionFromCssSelector,
-    addHandlerId };
+    addHandlerId, cssRuleEdit: styleFactory({createWithId: `JQxStylesheet`}) };
 }
 
 function isVisible(el) {
@@ -200,45 +211,49 @@ function isModal(elem) {
 
 function ExamineElementFeatureFactory() {
   const notApplicable = `n/a`;
-  const noElements = {
+  const noElements = Object.freeze({
     notInDOM: true, writable: notApplicable, modal: notApplicable, empty: true,
-    open: notApplicable, visible: notApplicable, };
+    open: notApplicable, visible: notApplicable, });
 
   return self => {
     const firstElem = self.node;
 
-    return IS(firstElem, Node) ? {
-      get writable() {
-        return isWritable(firstElem);
-      },
-      get modal() {
-        return isModal(firstElem);
-      },
-      get inDOM() {
-        return firstElem.isConnected;
-      },
-      get open() {
-        return firstElem.open ?? false;
-      },
-      get visible() {
-        return isVisible(firstElem);
-      },
-      get disabled() {
-        return firstElem.hasAttribute("readonly") || firstElem.hasAttribute("disabled");
-      },
-      get empty() {
-        return self.collection.length < 1;
-      },
-      get virtual() {
-        return self.isVirtual;
-      }
-    } : noElements;
+    return IS(firstElem, Node)
+      ? Object.freeze({
+        get writable() {
+          return isWritable(firstElem);
+        },
+        get modal() {
+          return isModal(firstElem);
+        },
+        get inDOM() {
+          return firstElem.isConnected;
+        },
+        get open() {
+          return firstElem.open ?? false;
+        },
+        get visible() {
+          return isVisible(firstElem);
+        },
+        get disabled() {
+          return firstElem.hasAttribute("readonly") || firstElem.hasAttribute("disabled");
+        },
+        get empty() {
+          return self.collection.length < 1;
+        },
+        get virtual() {
+          return self.isVirtual;
+        }
+      })
+      : noElements;
   };
 }
 
 function decodeForConsole(something) {
   return IS(something, String) &&
-    Object.assign(document.createElement(`textarea`), {innerHTML: something}).textContent || something;
+    Object.assign(
+      document.createElement(`textarea`),
+      {innerHTML: something}).textContent || something;
 }
 
 function systemLogFactory() {
@@ -258,9 +273,10 @@ function systemLogFactory() {
 
   function log(...args) {
     backLog.unshift(...args.map(arg => `${logTime()} ✔ ${decodeForConsole(arg)}`));
-    if (!on) { return systemLogger; }
-    console.log(backLog.slice(0, args.length).join(`\n`));
-    return systemLogger;
+    switch(on) {
+      case true: console.log(backLog.slice(0, args.length).join(`\n`));
+      default: return systemLogger;
+    }
   }
 
   Object.defineProperties(systemLogger, {
@@ -271,34 +287,87 @@ function systemLogFactory() {
   return Object.freeze(systemLogger);
 }
 
-export {
-  addHandlerId,
-  IS,
-  maybe,
-  isCommentOrTextNode,
-  isHtmlString,
-  isArrayOfHtmlStrings,
-  isArrayOfHtmlElements,
-  ElemArray2HtmlString,
-  input2Collection,
-  setCollectionFromCssSelector,
-  isNode,
-  randomString,
-  isNonEmptyString,
-  insertPositions,
-  toDashedNotation,
-  toCamelcase,
-  truncateHtmlStr,
-  truncate2SingleStr,
-  logTime,
-  randomNr,
-  hex2RGBA,
-  escHtml,
-  ExamineElementFeatureFactory,
-  styleFactory,
-  tagFNFactory,
-  resolveEventTypeParameter,
-  selectedExtensionHelpers,
-  systemLog,
-  datasetKeyProxy,
-};
+function cloneAndDestroy(elem) {
+  const cloned = elem.cloneNode(true)
+  cloned.removeAttribute && cloned.removeAttribute(`id`);
+  elem.isConnected ? elem.remove() : elem = null;
+  return cloned;
+}
+
+function setData(el, keyValuePairs) {
+  if (el && IS(keyValuePairs, Object)) {
+    for (const [key, value] of Object.entries(keyValuePairs)) {
+      el.setAttribute(`data-${toDashedNotation(key)}`, value);
+    }
+  }
+}
+
+function before (instance, elem2AddBefore) {
+  return instance.andThen(elem2AddBefore, true);
+}
+
+function after(instance, elem2AddAfter) {
+  return instance.andThen(elem2AddAfter);
+}
+
+function findParentScrollDistance(node, distance = 0, top = true) {
+  node = node?.parentElement;
+  const what = top ? `scrollTop` : `scrollLeft`;
+  distance += node ? node[what] : 0;
+  return !node ? distance : findParentScrollDistance(node, distance, top);
+}
+
+function emptyElement(el) {
+  return el && (el.textContent = "");
+}
+
+function checkProp(prop) {
+  return prop.startsWith(`data`) || ATTRS.html.find(attr => prop.toLowerCase() === attr);
+}
+
+function css(el, keyOrKvPairs, value, jqx) {
+  if (value && IS(keyOrKvPairs, String)) {
+    keyOrKvPairs = {[keyOrKvPairs]: value === "-" ? "" : value};
+  }
+
+  let nwClass = undefined;
+
+  if (keyOrKvPairs.className) {
+    nwClass = keyOrKvPairs.className;
+    delete keyOrKvPairs.className;
+  }
+
+  const classExists = ([...el.classList].find(c => c.startsWith(`JQxClass-`) || nwClass && c === nwClass));
+  nwClass = classExists || nwClass || `JQxClass-${randomString().slice(1)}`;
+  jqx.editCssRule(`.${nwClass}`, keyOrKvPairs);
+  el.classList.add(nwClass);
+}
+
+function assignAttrValues(/*NODOC*/el, keyValuePairs) {
+  if (el) {
+    for (let [key, value] of Object.entries(keyValuePairs)) {
+      key = toDashedNotation(key);
+      if (key.startsWith(`data`)) {
+        return setData(el, value);
+      }
+
+      if (IS(value, String) && checkProp(key)) {
+        el.setAttribute(key, value.split(/[, ]/)?.join(` `));
+      }
+    }
+  }
+}
+
+function applyStyle(el, rules) {
+  if (IS(rules, Object)) {
+    for (let [key, value] of Object.entries(rules)) {
+      let priority;
+      if (/!important/i.test(value)) {
+        value = value.slice(0, value.indexOf(`!`)).trim();
+        priority = 'important';
+      }
+
+      el.style.setProperty(toDashedNotation(key), value, priority)
+    }
+  }
+}