jqx-es 1.2.8 → 1.3.0

package/src/JQxCreatorFactory.js

@@ -1,7 +1,7 @@
 import {
   randomString, toDashedNotation, IS, tagFNFactory as $T, styleFactory, toCamelcase, systemLog,
   escHtml, isNonEmptyString, resolveEventTypeParameter, selectedFactoryHelpers, insertPositions,
-  cleanupHtml, PopupFactory, tagLib, listeners, HandleFactory,
+  cleanupHtml, PopupFactory, tagLib, HandlerFactory, getHandlerName,
 } from "./JQxUtilities.js";
 import allMethodsFactory from "./JQxInstanceMethods.js";
 
@@ -156,39 +156,48 @@ function delegateFactory(listen) {
   }
 }
 
-function delegateCaptureFactory(listen) {
+/* region __WIP */
+function delegateCaptureFactory(handlerWrapper) {
   return function(spec) {
-    let {type, origin, selector, handlers, name, capture, once, canRemove} = spec;
+    let {type, types, origin, selector, handler, handlers, node, name, capture, once, about} = spec;
+    // <legacy>
+    handler = handlers || handler;
+    type = types || type;
+    selector = origin || selector;
+    // </legacy>
     const typesResolved = resolveEventTypeParameter(type);
     const specifiedName = name;
-    handlers = IS(handlers, Function) ? [handlers] : handlers;
-    canRemove = IS(canRemove, Boolean) ? canRemove : false;
+    handler = IS(handler, Function) ? [handler] : handler;
     const params = {
-      eventType: typesResolved, selector: selector || origin, capture,
-      name: specifiedName, once, canRemove };
-
+      type: typesResolved, selector: selector || origin, capture,
+      name: specifiedName, once, node, about };
+    
     switch(true) {
       case IS(typesResolved, Array) && typesResolved.length > 0:
         for (const type of typesResolved) {
-          params.eventType = type;
-          assignListeners(handlers, params, listen);
+          params.type = type;
+          assignListeners(handler, params, handlerWrapper);
         }
         break;
-      default: return assignListeners(handlers, params, listen);
+      default: return assignListeners(handler, params, handlerWrapper);
     }
   }
 }
 
-function assignListeners(handlers, params, listen) {
-  for (const handler of handlers) {
-    listen({...params, callback: handler});
+function assignListeners(handlerFns, params, handlerWrapper) {
+  for (const handler of handlerFns) {
+    params.name = getHandlerName(params.name || handler.name);
+    handlerWrapper.listen({...params, handler});
   }
 }
+/* endregion __WIP */
 
-function getNamedListener(type, name) {
-  name = isNonEmptyString(name) && name;
-  type = isNonEmptyString(type) && type;
-  return name && type && [...listeners[type].values()].find(h => (h.name || ``) === name);
+function getNamedListenerFactory(jqx) {
+  return function(type, name) {
+    name = isNonEmptyString(name) && name;
+    type = isNonEmptyString(type) && type;
+    return name && type && jqx.listenerStore[type][name];
+  };
 }
 
 function popupGetter(jqx) {
@@ -207,19 +216,21 @@ function getSelectedStaticMethods(jqx) {
   const createStyle = id => styleFactory({createWithId: id || `jqx${randomString()}`});
   const editCssRules = (...rules) => { for (const rule of rules) { cssRuleEdit(rule); } };
   const allowProhibit = allowances(jqx);
-  const handle = HandleFactory(jqx);
-  const capturedHandling = delegateCaptureFactory(handle);
+  const handlerWrapper = HandlerFactory(jqx);
+  const capturedHandling = delegateCaptureFactory(handlerWrapper);
   const log = (...line) => systemLog.on.log(...line).off;
-  return {editCssRule, createStyle, editCssRules, allowProhibit, handle, capturedHandling,log};
+  return {
+    editCssRule, createStyle, editCssRules, allowProhibit, handle: capturedHandling, capturedHandling,
+    log, handlerWrapper};
 }
 
 function staticMethodsFactory(jqx) {
   const { factoryExtensions, instanceExtensions } = allMethodsFactory(jqx);
   instanceGetters = factoryExtensions;
   instanceMethods = instanceExtensions;
-  const { editCssRule, createStyle, editCssRules, allowProhibit, handle, capturedHandling, log } =
+  const { editCssRule, createStyle, editCssRules, allowProhibit, handle, capturedHandling, log, handlerWrapper } =
     getSelectedStaticMethods(jqx);
-
+  const getNamedListener = getNamedListenerFactory(jqx);
   return {
     log,
     editCssRules,
@@ -240,11 +251,13 @@ function staticMethodsFactory(jqx) {
     get delegate()  { return delegateFactory(capturedHandling); },
     get delegateCaptured() { return capturedHandling; } ,
     get handle() { return  capturedHandling; },
+    get listen() { return handlerWrapper.listen; },
     get at() { return insertPositions; },
     get setStyle() { /*deprecated*/return editCssRule; },
     get fn() { return addFn; },
     get lenient() { return tagLib.allowUnknownHtmlTags; },
     get IS() { return IS; },
     get Popup() { return popupGetter(jqx); },
+    get listenerStore() { return handlerWrapper.ListenerStore; },
   };
 }

package/src/JQxInstanceMethods.js

@@ -305,13 +305,20 @@ function instanceExtensionsFactory(jqx) {
     nth$: (instance, indexOrSelector) => instance.single(indexOrSelector),
     on: (instance, type, ...callback) => {
       if (instance.collection.length && IS(type, String, Array)) {
-        if (type?.length < 1 || callback.length < 1) { return instance; }
-        const cssSelector4Handler = addHandlerId(instance);
-        jqx.handle({type, selector: cssSelector4Handler, handlers: callback});
+        if (!isNonEmptyString(type) || callback.length < 1) { return instance; }
+        jqx.handle({type, node: instance.node, handlers: callback});
       }
 
       return instance;
     },
+    once: (instance, type, ...callback) => {
+      if (instance.collection.length && IS(type, String, Array)) {
+        if (!isNonEmptyString(type) || callback.length < 1) { return instance; }
+        jqx.handle({type, once: true, node: instance.node, handlers: callback});
+      }
+      
+      return instance;
+    },
     prepend: (instance, ...elems2Prepend) => {
       if (!instance.is.empty && elems2Prepend) {
         const shouldMove = instance.length === 1;

package/src/JQxUtilities.js

@@ -5,7 +5,7 @@ import {
   isNode, isNonEmptyString, isText, isVisible, isWritable, logTime, maybe, randomNr, randomString,
   resolveEventTypeParameter, setData, styleFactory, systemLog, tagFNFactory, toCamelcase, toDashedNotation,
   truncate2SingleStr, truncateHtmlStr, createElementFromHtmlString, inject2DOMTree, cleanupHtml,
-  PopupFactory, tagLib, listeners, HandleFactory,
+  PopupFactory, tagLib, HandlerFactory, getHandlerName,
 } from "../Resource/Common/Utilities.js"
 
 export {
@@ -15,7 +15,7 @@ export {
   isHtmlString, isNode, isNonEmptyString, logTime, loop, maybe, randomNr, randomString, resolveEventTypeParameter,
   selectedFactoryHelpers, setCollectionFromCssSelector, setData, styleFactory, systemLog, tagFNFactory,
   toCamelcase, toDashedNotation, truncate2SingleStr, truncateHtmlStr, createElementFromHtmlString, inject2DOMTree,
-  cleanupHtml, PopupFactory, tagLib, HandleFactory, listeners
+  cleanupHtml, PopupFactory, tagLib, HandlerFactory, getHandlerName,
 };
 
 function loop(instance, callback) {
@@ -40,7 +40,7 @@ function setCollectionFromCssSelector(input, root, self) {
 }
 
 function  addHandlerId(instance) {
-  const handleId = instance.data.get(`hid`) || `HID${randomString()}`;
+  const handleId = `anonymous_${Math.random().toString(36).slice(2)}`;
   instance.data.add({hid: handleId});
   return `[data-hid="${handleId}"]`;
 }