jqx-es 1.2.6 → 1.2.8

package/src/JQxConstructorFactory.js

@@ -0,0 +1,78 @@
+import { proxify, addJQxStaticMethods } from "./JQxCreatorFactory.js";
+import {
+  isHtmlString, truncateHtmlStr, isArrayOfHtmlStrings, isArrayOfHtmlElements,
+  ElemArray2HtmlString, input2Collection, setCollectionFromCssSelector,
+  IS, systemLog, insertPositions, inject2DOMTree, createElementFromHtmlString
+} from "./JQxUtilities.js";
+
+export default addJQxStaticMethods(JQxMainFactory());
+
+function JQxMainFactory() {
+  const logLineLength = 70;
+  
+  return function(input, root, position = insertPositions.BeforeEnd) {
+    if (input?.isJQx) { return input; }
+    const isVirtual = IS(root, HTMLBRElement);
+    root = (!isVirtual && root && root.isJQx ? root[0] : root) || document.body;
+    position = position && Object.values(insertPositions).find(pos => position === pos) ? position : undefined;
+    const isRawHtml = isHtmlString(input);
+    const isRawHtmlArray = !isRawHtml && isArrayOfHtmlStrings(input);
+    const shouldCreateElements = isRawHtmlArray || isRawHtml;
+    
+    let instance = {
+      collection: input2Collection(input) ?? [],
+      isVirtual,
+      isJQx: true,
+    };
+    
+    const isRawElemCollection = isArrayOfHtmlElements(instance.collection);
+    
+    const logStr = `JQx: input => ${
+      isRawHtmlArray
+        ? `"${truncateHtmlStr(input.join(`, `), logLineLength)}"`
+        : !shouldCreateElements && isRawElemCollection ? `element collection [${
+            truncateHtmlStr( instance.collection.map(el => `${
+              IS(el, Comment, Text) ? `Comment|Text @` : ``} ${
+              el?.outerHTML || el?.textContent}`).join(`, `), logLineLength)}]`
+          : `"${truncateHtmlStr(input, logLineLength)}"`}`;
+    
+    if (instance.collection.length && isRawElemCollection) {
+      systemLog.log(logStr);
+      
+      if (!isVirtual) {
+        instance.collection.forEach(el => {
+          if (!root.contains(el)) {
+            inject2DOMTree([el], root, position);
+          }
+        });
+      }
+      
+      return proxify(instance);
+    }
+    
+    if (shouldCreateElements) {
+      [input].flat().forEach(htmlStringOrComment =>
+        instance.collection.push(createElementFromHtmlString(htmlStringOrComment)));
+      
+      if (instance.collection.length > 0) {
+        const errors = instance.collection.filter( el => el?.dataset?.jqxcreationerror );
+        instance.collection = instance.collection.filter(el => !el?.dataset?.jqxcreationerror);
+        
+        systemLog.log(`${logStr}`);
+        systemLog.log(`JQx: created ${instance.isVirtual ? `VIRTUAL ` : ``}[${
+          truncateHtmlStr(ElemArray2HtmlString(instance.collection).trim() ||
+            "sanitized: no elements remaining", logLineLength)}]`);
+        
+        if (!instance.isVirtual) {
+          inject2DOMTree(instance.collection, root, position);
+        }
+      }
+      
+      return proxify(instance);
+    }
+    
+    const forLog = setCollectionFromCssSelector(input, root, instance);
+    systemLog.log(`JQx: input => ${forLog}`);
+    return proxify(instance);
+  }
+}

package/src/{JQxFactory.js → JQxCreatorFactory.js}

@@ -1,12 +1,9 @@
-import { cleanupHtml } from "./DOM.js";
-import allMethodsFactory from "./JQxMethods.js";
-import PopupFactory from "./Popup.js";
-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, selectedFactoryHelpers, insertPositions
-} from "./Utilities.js";
+  randomString, toDashedNotation, IS, tagFNFactory as $T, styleFactory, toCamelcase, systemLog,
+  escHtml, isNonEmptyString, resolveEventTypeParameter, selectedFactoryHelpers, insertPositions,
+  cleanupHtml, PopupFactory, tagLib, listeners, HandleFactory,
+} from "./JQxUtilities.js";
+import allMethodsFactory from "./JQxInstanceMethods.js";
 
 let instanceGetters, instanceMethods;
 const {
@@ -19,7 +16,7 @@ export { proxify, addJQxStaticMethods };
 function selectedUtilitiesFactory() {
    return {
     ...selectedFactoryHelpers(),
-    addFn(name, extensionMethod) {
+    addFn: function(name, extensionMethod) {
       systemLog.log(`JQx: added extension function [${name}]`);
       return instanceMethods[name] = (self, ...params) => extensionMethod(self, ...params);
     } };

package/src/{JQxMethods.js → JQxInstanceMethods.js}

@@ -1,14 +1,20 @@
-import {createElementFromHtmlString, inject2DOMTree} from "./DOM.js";
 import {
   IS, isNode, truncateHtmlStr, addHandlerId, ExamineElementFeatureFactory,
   isNonEmptyString, toDashedNotation, escHtml, systemLog, insertPositions,
-  datasetKeyProxy, loop, cloneAndDestroy, setData, before, after, findParentScrollDistance,
-  emptyElement, checkProp, css, assignAttrValues, applyStyle,
-} from "./Utilities.js";
+  datasetKeyProxy, loop, cloneAndDestroy, setData, before, after,
+  findParentScrollDistance, emptyElement, checkProp, css, assignAttrValues,
+  applyStyle, createElementFromHtmlString, inject2DOMTree,
+} from "./JQxUtilities.js";
 
 const instanceIs = ExamineElementFeatureFactory();
 
-/* region exportfunctions */
+export default function(jqx) {
+  return {
+    factoryExtensions: factoryExtensionsFactory(jqx),
+    instanceExtensions: instanceExtensionsFactory(jqx),
+  }
+};
+
 function factoryExtensionsFactory(jqx) {
   return {
     data: instance => ({
@@ -509,11 +515,3 @@ function instanceExtensionsFactory(jqx) {
     },
   };
 }
-
-/* endregion exportfunctions */
-export default function(jqx) {
-  return {
-    factoryExtensions: factoryExtensionsFactory(jqx),
-    instanceExtensions: instanceExtensionsFactory(jqx),
-  }
-};

package/src/JQxUtilities.js

@@ -0,0 +1,111 @@
+import {
+  after, applyStyle, assignAttrValues, before, checkProp, cloneAndDestroy, datasetKeyProxy,
+  ElemArray2HtmlString, emptyElement, escHtml, findParentScrollDistance, input2Collection, insertPositions,
+  IS, isArrayOfHtmlElements, isArrayOfHtmlStrings, isComment, isCommentOrTextNode, isHtmlString, isModal,
+  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,
+} from "../Resource/Common/Utilities.js"
+
+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, createElementFromHtmlString, inject2DOMTree,
+  cleanupHtml, PopupFactory, tagLib, HandleFactory, listeners
+};
+
+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 setCollectionFromCssSelector(input, root, self) {
+  const selectorRoot = root !== document.body && (IS(input, String) && input.toLowerCase() !== "body") ? root : document;
+  let errorStr = undefined;
+
+  try { self.collection = [...selectorRoot.querySelectorAll(input)]; }
+  catch (err) { errorStr = `Invalid CSS querySelector. [${!IS(input, String) ? `Nothing valid given!` : input}]`; }
+  const collectionLen = self.collection.length;
+  return collectionLen < 1
+    ? `CSS querySelector "${input}", output: nothing`
+    : errorStr ?? `CSS querySelector "${input}", output ${collectionLen} element${collectionLen > 1 ? `s` : ``}`;
+}
+
+function  addHandlerId(instance) {
+  const handleId = instance.data.get(`hid`) || `HID${randomString()}`;
+  instance.data.add({hid: handleId});
+  return `[data-hid="${handleId}"]`;
+}
+
+function selectedFactoryHelpers() {
+  return {
+    isCommentOrTextNode, isNode, isComment, isText, isHtmlString, isArrayOfHtmlElements,
+    isArrayOfHtmlStrings, ElemArray2HtmlString, input2Collection, setCollectionFromCssSelector,
+    addHandlerId, cssRuleEdit: styleFactory({createWithId: `JQxStylesheet`}) };
+}
+
+function ExamineElementFeatureFactory() {
+  const notApplicable = `n/a`;
+  const noElements = Object.freeze({
+    notInDOM: true, writable: notApplicable, modal: notApplicable, empty: true,
+    open: notApplicable, visible: notApplicable, });
+
+  return self => {
+    const firstElem = self.node;
+
+    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 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);
+}