qcobjects 2.4.105-ts → 2.4.108-ts

package/build/WidgetsFactory.js

@@ -0,0 +1,537 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegisterWidgets = exports.RegisterWidget = exports._ComponentWidget_ = void 0;
+const DOMCreateElement_1 = require("./DOMCreateElement");
+const Export_1 = require("./Export");
+const introspection_1 = require("./introspection");
+const platform_1 = require("./platform");
+class QCObjectsWidgetNode {
+    accessKey;
+    accessKeyLabel;
+    autocapitalize;
+    dir;
+    draggable;
+    hidden;
+    inert;
+    innerText;
+    lang;
+    offsetHeight;
+    offsetLeft;
+    offsetParent;
+    offsetTop;
+    offsetWidth;
+    outerText;
+    popover;
+    spellcheck;
+    title;
+    translate;
+    attachInternals() {
+        throw new Error("Method not implemented.");
+    }
+    click() {
+        throw new Error("Method not implemented.");
+    }
+    hidePopover() {
+        throw new Error("Method not implemented.");
+    }
+    showPopover() {
+        throw new Error("Method not implemented.");
+    }
+    togglePopover(force) {
+        throw new Error("Method not implemented.");
+    }
+    addEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    removeEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    attributes;
+    classList;
+    className;
+    clientHeight;
+    clientLeft;
+    clientTop;
+    clientWidth;
+    id;
+    innerHTML;
+    localName;
+    namespaceURI;
+    onfullscreenchange;
+    onfullscreenerror;
+    outerHTML;
+    ownerDocument;
+    part;
+    prefix;
+    scrollHeight;
+    scrollLeft;
+    scrollTop;
+    scrollWidth;
+    shadowRoot;
+    slot;
+    tagName;
+    attachShadow(init) {
+        throw new Error("Method not implemented.");
+    }
+    checkVisibility(options) {
+        throw new Error("Method not implemented.");
+    }
+    closest(selectors) {
+        throw new Error("Method not implemented.");
+    }
+    computedStyleMap() {
+        throw new Error("Method not implemented.");
+    }
+    getAttribute(qualifiedName) {
+        throw new Error("Method not implemented.");
+    }
+    getAttributeNS(namespace, localName) {
+        throw new Error("Method not implemented.");
+    }
+    getAttributeNames() {
+        throw new Error("Method not implemented.");
+    }
+    getAttributeNode(qualifiedName) {
+        throw new Error("Method not implemented.");
+    }
+    getAttributeNodeNS(namespace, localName) {
+        throw new Error("Method not implemented.");
+    }
+    getBoundingClientRect() {
+        throw new Error("Method not implemented.");
+    }
+    getClientRects() {
+        throw new Error("Method not implemented.");
+    }
+    getElementsByClassName(classNames) {
+        throw new Error("Method not implemented.");
+    }
+    getElementsByTagName(qualifiedName) {
+        throw new Error("Method not implemented.");
+    }
+    getElementsByTagNameNS(namespace, localName) {
+        throw new Error("Method not implemented.");
+    }
+    getHTML(options) {
+        throw new Error("Method not implemented.");
+    }
+    hasAttribute(qualifiedName) {
+        throw new Error("Method not implemented.");
+    }
+    hasAttributeNS(namespace, localName) {
+        throw new Error("Method not implemented.");
+    }
+    hasAttributes() {
+        throw new Error("Method not implemented.");
+    }
+    hasPointerCapture(pointerId) {
+        throw new Error("Method not implemented.");
+    }
+    insertAdjacentElement(where, element) {
+        throw new Error("Method not implemented.");
+    }
+    insertAdjacentHTML(position, string) {
+        throw new Error("Method not implemented.");
+    }
+    insertAdjacentText(where, data) {
+        throw new Error("Method not implemented.");
+    }
+    matches(selectors) {
+        throw new Error("Method not implemented.");
+    }
+    releasePointerCapture(pointerId) {
+        throw new Error("Method not implemented.");
+    }
+    removeAttribute(qualifiedName) {
+        throw new Error("Method not implemented.");
+    }
+    removeAttributeNS(namespace, localName) {
+        throw new Error("Method not implemented.");
+    }
+    removeAttributeNode(attr) {
+        throw new Error("Method not implemented.");
+    }
+    requestFullscreen(options) {
+        throw new Error("Method not implemented.");
+    }
+    requestPointerLock(options) {
+        throw new Error("Method not implemented.");
+    }
+    scroll(x, y) {
+        throw new Error("Method not implemented.");
+    }
+    scrollBy(x, y) {
+        throw new Error("Method not implemented.");
+    }
+    scrollIntoView(arg) {
+        throw new Error("Method not implemented.");
+    }
+    scrollTo(x, y) {
+        throw new Error("Method not implemented.");
+    }
+    setAttribute(qualifiedName, value) {
+        throw new Error("Method not implemented.");
+    }
+    setAttributeNS(namespace, qualifiedName, value) {
+        throw new Error("Method not implemented.");
+    }
+    setAttributeNode(attr) {
+        throw new Error("Method not implemented.");
+    }
+    setAttributeNodeNS(attr) {
+        throw new Error("Method not implemented.");
+    }
+    setHTMLUnsafe(html) {
+        throw new Error("Method not implemented.");
+    }
+    setPointerCapture(pointerId) {
+        throw new Error("Method not implemented.");
+    }
+    toggleAttribute(qualifiedName, force) {
+        throw new Error("Method not implemented.");
+    }
+    webkitMatchesSelector(selectors) {
+        throw new Error("Method not implemented.");
+    }
+    baseURI;
+    childNodes;
+    firstChild;
+    isConnected;
+    lastChild;
+    nextSibling;
+    nodeName;
+    nodeType;
+    nodeValue;
+    parentElement;
+    parentNode;
+    previousSibling;
+    textContent;
+    appendChild(node) {
+        throw new Error("Method not implemented.");
+    }
+    cloneNode(deep) {
+        throw new Error("Method not implemented.");
+    }
+    compareDocumentPosition(other) {
+        throw new Error("Method not implemented.");
+    }
+    contains(other) {
+        throw new Error("Method not implemented.");
+    }
+    getRootNode(options) {
+        throw new Error("Method not implemented.");
+    }
+    hasChildNodes() {
+        throw new Error("Method not implemented.");
+    }
+    insertBefore(node, child) {
+        throw new Error("Method not implemented.");
+    }
+    isDefaultNamespace(namespace) {
+        throw new Error("Method not implemented.");
+    }
+    isEqualNode(otherNode) {
+        throw new Error("Method not implemented.");
+    }
+    isSameNode(otherNode) {
+        throw new Error("Method not implemented.");
+    }
+    lookupNamespaceURI(prefix) {
+        throw new Error("Method not implemented.");
+    }
+    lookupPrefix(namespace) {
+        throw new Error("Method not implemented.");
+    }
+    normalize() {
+        throw new Error("Method not implemented.");
+    }
+    removeChild(child) {
+        throw new Error("Method not implemented.");
+    }
+    replaceChild(node, child) {
+        throw new Error("Method not implemented.");
+    }
+    ELEMENT_NODE;
+    ATTRIBUTE_NODE;
+    TEXT_NODE;
+    CDATA_SECTION_NODE;
+    ENTITY_REFERENCE_NODE;
+    ENTITY_NODE;
+    PROCESSING_INSTRUCTION_NODE;
+    COMMENT_NODE;
+    DOCUMENT_NODE;
+    DOCUMENT_TYPE_NODE;
+    DOCUMENT_FRAGMENT_NODE;
+    NOTATION_NODE;
+    DOCUMENT_POSITION_DISCONNECTED;
+    DOCUMENT_POSITION_PRECEDING;
+    DOCUMENT_POSITION_FOLLOWING;
+    DOCUMENT_POSITION_CONTAINS;
+    DOCUMENT_POSITION_CONTAINED_BY;
+    DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC;
+    dispatchEvent(event) {
+        throw new Error("Method not implemented.");
+    }
+    ariaAtomic;
+    ariaAutoComplete;
+    ariaBrailleLabel;
+    ariaBrailleRoleDescription;
+    ariaBusy;
+    ariaChecked;
+    ariaColCount;
+    ariaColIndex;
+    ariaColSpan;
+    ariaCurrent;
+    ariaDescription;
+    ariaDisabled;
+    ariaExpanded;
+    ariaHasPopup;
+    ariaHidden;
+    ariaInvalid;
+    ariaKeyShortcuts;
+    ariaLabel;
+    ariaLevel;
+    ariaLive;
+    ariaModal;
+    ariaMultiLine;
+    ariaMultiSelectable;
+    ariaOrientation;
+    ariaPlaceholder;
+    ariaPosInSet;
+    ariaPressed;
+    ariaReadOnly;
+    ariaRequired;
+    ariaRoleDescription;
+    ariaRowCount;
+    ariaRowIndex;
+    ariaRowSpan;
+    ariaSelected;
+    ariaSetSize;
+    ariaSort;
+    ariaValueMax;
+    ariaValueMin;
+    ariaValueNow;
+    ariaValueText;
+    role;
+    animate(keyframes, options) {
+        throw new Error("Method not implemented.");
+    }
+    getAnimations(options) {
+        throw new Error("Method not implemented.");
+    }
+    after(...nodes) {
+        throw new Error("Method not implemented.");
+    }
+    before(...nodes) {
+        throw new Error("Method not implemented.");
+    }
+    remove() {
+        throw new Error("Method not implemented.");
+    }
+    replaceWith(...nodes) {
+        throw new Error("Method not implemented.");
+    }
+    nextElementSibling;
+    previousElementSibling;
+    childElementCount;
+    children;
+    firstElementChild;
+    lastElementChild;
+    append(...nodes) {
+        throw new Error("Method not implemented.");
+    }
+    prepend(...nodes) {
+        throw new Error("Method not implemented.");
+    }
+    querySelector(selectors) {
+        throw new Error("Method not implemented.");
+    }
+    querySelectorAll(selectors) {
+        throw new Error("Method not implemented.");
+    }
+    replaceChildren(...nodes) {
+        throw new Error("Method not implemented.");
+    }
+    assignedSlot;
+    attributeStyleMap;
+    style;
+    contentEditable;
+    enterKeyHint;
+    inputMode;
+    isContentEditable;
+    onabort;
+    onanimationcancel;
+    onanimationend;
+    onanimationiteration;
+    onanimationstart;
+    onauxclick;
+    onbeforeinput;
+    onbeforetoggle;
+    onblur;
+    oncancel;
+    oncanplay;
+    oncanplaythrough;
+    onchange;
+    onclick;
+    onclose;
+    oncontextlost;
+    oncontextmenu;
+    oncontextrestored;
+    oncopy;
+    oncuechange;
+    oncut;
+    ondblclick;
+    ondrag;
+    ondragend;
+    ondragenter;
+    ondragleave;
+    ondragover;
+    ondragstart;
+    ondrop;
+    ondurationchange;
+    onemptied;
+    onended;
+    onerror;
+    onfocus;
+    onformdata;
+    ongotpointercapture;
+    oninput;
+    oninvalid;
+    onkeydown;
+    onkeypress;
+    onkeyup;
+    onload;
+    onloadeddata;
+    onloadedmetadata;
+    onloadstart;
+    onlostpointercapture;
+    onmousedown;
+    onmouseenter;
+    onmouseleave;
+    onmousemove;
+    onmouseout;
+    onmouseover;
+    onmouseup;
+    onpaste;
+    onpause;
+    onplay;
+    onplaying;
+    onpointercancel;
+    onpointerdown;
+    onpointerenter;
+    onpointerleave;
+    onpointermove;
+    onpointerout;
+    onpointerover;
+    onpointerup;
+    onprogress;
+    onratechange;
+    onreset;
+    onresize;
+    onscroll;
+    onscrollend;
+    onsecuritypolicyviolation;
+    onseeked;
+    onseeking;
+    onselect;
+    onselectionchange;
+    onselectstart;
+    onslotchange;
+    onstalled;
+    onsubmit;
+    onsuspend;
+    ontimeupdate;
+    ontoggle;
+    ontouchcancel;
+    ontouchend;
+    ontouchmove;
+    ontouchstart;
+    ontransitioncancel;
+    ontransitionend;
+    ontransitionrun;
+    ontransitionstart;
+    onvolumechange;
+    onwaiting;
+    onwebkitanimationend;
+    onwebkitanimationiteration;
+    onwebkitanimationstart;
+    onwebkittransitionend;
+    onwheel;
+    autofocus;
+    dataset;
+    nonce;
+    tabIndex;
+    blur() {
+        throw new Error("Method not implemented.");
+    }
+    focus(options) {
+        throw new Error("Method not implemented.");
+    }
+}
+if (platform_1.isBrowser) {
+    exports._ComponentWidget_ = class _ComponentWidget_ extends HTMLElement {
+        constructor() {
+            super();
+            const componentWidget = this;
+            const componentName = componentWidget.nodeName.toLowerCase();
+            const componentBody = (0, DOMCreateElement_1._DOMCreateElement)("quick-component");
+            const __enabled__atributes__ = componentWidget.getAttributeNames();
+            componentBody.setAttribute("name", componentName);
+            if (!componentWidget.hasAttribute("shadowed")) {
+                componentBody.setAttribute("shadowed", "true");
+            }
+            __enabled__atributes__.map(function (attributeName) {
+                if (componentWidget.hasAttribute(attributeName)) {
+                    componentBody.setAttribute(attributeName, componentWidget?.getAttribute(attributeName));
+                    componentWidget.removeAttribute(attributeName);
+                }
+            });
+            const data_attributenames = componentWidget.getAttributeNames().filter(function (a) {
+                return a.startsWith("data-");
+            }).map(function (a) {
+                return a.split("-")[1];
+            });
+            data_attributenames.map(function (_attribute_name_) {
+                componentBody.setAttribute("data-" + _attribute_name_, componentWidget?.getAttribute("data-" + _attribute_name_));
+                componentWidget.removeAttribute("data-" + _attribute_name_);
+            });
+            [...componentWidget.children].map(function (element) {
+                componentBody.appendChild(element.cloneNode(true));
+                element.remove();
+            });
+            componentWidget.append(componentBody);
+        }
+    };
+}
+else {
+    exports._ComponentWidget_ = class _ComponentWidget_ extends QCObjectsWidgetNode {
+        constructor() {
+            super();
+            throw new Error("Class not implemented.");
+        }
+    };
+}
+(0, Export_1.Export)(exports._ComponentWidget_);
+const RegisterWidget = function (widgetName) {
+    if (platform_1.isBrowser) {
+        customElements.define(widgetName, class extends exports._ComponentWidget_ {
+        });
+    }
+    else {
+        throw new Error("RegisterWidget is not implemented for non browser ecosystems yet.");
+    }
+};
+exports.RegisterWidget = RegisterWidget;
+const RegisterWidgets = function (...args) {
+    const widgetList = [...args];
+    widgetList.filter(function (widgetName) {
+        return typeof widgetName === "string";
+    }).map(function (widgetName) {
+        return (0, exports.RegisterWidget)(widgetName);
+    });
+};
+exports.RegisterWidgets = RegisterWidgets;
+(introspection_1._protected_code_)(exports.RegisterWidget);
+(introspection_1._protected_code_)(exports.RegisterWidgets);
+(0, Export_1.Export)(exports.RegisterWidget);
+(0, Export_1.Export)(exports.RegisterWidgets);

package/build/assign.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Object.assign Polyfilling
+// Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign#Polyfill
+if (typeof Object.assign !== "function") {
+    // Must be writable: true, enumerable: false, configurable: true
+    Object.defineProperty(Object, "assign", {
+        // eslint-disable-next-line no-unused-vars
+        value: function assign(target, varArgs) {
+            "use strict";
+            if (target === null) { // TypeError if undefined or null
+                throw new TypeError("Cannot convert undefined or null to object");
+            }
+            const to = Object(target);
+            for (let index = 1; index < arguments.length; index++) {
+                // eslint-disable-next-line prefer-rest-params
+                const nextSource = arguments[index];
+                if (nextSource !== null) { // Skip over if undefined or null
+                    for (const nextKey in nextSource) {
+                        // Avoid bugs when hasOwnProperty is shadowed
+                        if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
+                            to[nextKey] = nextSource[nextKey];
+                        }
+                    }
+                }
+            }
+            return to;
+        },
+        writable: true,
+        configurable: true
+    });
+}

package/build/asyncLoad.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._fireAsyncLoad = exports._asyncLoad = void 0;
+exports.asyncLoad = asyncLoad;
+const Export_1 = require("./Export");
+const platform_1 = require("./platform");
+const top_1 = require("./top");
+exports._asyncLoad = [];
+function asyncLoad(callback, args) {
+    class AsyncCallback {
+        func;
+        args;
+        constructor(callback, args = []) {
+            this.func = callback;
+            this.args = args;
+        }
+        dispatch() {
+            this.func.apply(this, ...args, this);
+        }
+    }
+    exports._asyncLoad.push((new AsyncCallback(callback, args)));
+    return AsyncCallback;
+}
+const _fireAsyncLoad = function () {
+    if (platform_1.isBrowser) {
+        document.addEventListener("readystatechange", () => {
+            if (document.readyState === "complete") {
+                // eslint-disable-next-line array-callback-return
+                exports._asyncLoad.map(function (fc) {
+                    fc.dispatch.call(fc);
+                });
+            }
+        });
+    }
+    else if (typeof top_1._top.global !== "undefined") {
+        // eslint-disable-next-line array-callback-return
+        exports._asyncLoad.map(function (fc) {
+            fc.dispatch.call(fc);
+        });
+    }
+};
+exports._fireAsyncLoad = _fireAsyncLoad;
+(0, Export_1.Export)(asyncLoad);

package/build/basePath.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setBasePath = exports._basePath_ = void 0;
+const Logger_1 = require("./Logger");
+const platform_1 = require("./platform");
+exports._basePath_ = (function () {
+    let _basePath = "";
+    if (platform_1.isBrowser) {
+        const baseURI = document.baseURI.split("?")[0].split("/");
+        baseURI.pop();
+        _basePath = baseURI.join("/") + "/";
+    }
+    else {
+        let process;
+        try {
+            process = (0, platform_1._require_)("process");
+        }
+        catch (e) {
+            Logger_1.logger.debug(`An error ocurred: ${e}.`);
+            // not a process module
+        }
+        if (typeof process !== "undefined") {
+            _basePath = `${(process).cwd()}/`;
+        }
+        else {
+            _basePath = "";
+        }
+    }
+    return _basePath;
+})();
+const setBasePath = (value) => { exports._basePath_ = value; };
+exports.setBasePath = setBasePath;

package/build/captureFalseTouch.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureFalseTouch = exports.supportsPassive = void 0;
+const Logger_1 = require("./Logger");
+const platform_1 = require("./platform");
+exports.supportsPassive = false;
+const captureFalseTouch = () => {
+    return (exports.supportsPassive) ? ({
+        passive: true
+    }) : (false);
+};
+exports.captureFalseTouch = captureFalseTouch;
+// Test via a getter in the options object to see if the passive property is accessed
+if (platform_1.isBrowser) {
+    try {
+        const opts = Object.defineProperty({}, "passive", {
+            get() {
+                exports.supportsPassive = true;
+                return exports.supportsPassive;
+            }
+        });
+        window.addEventListener("testPassive", null, opts);
+        window.removeEventListener("testPassive", null, opts);
+    }
+    catch (e) {
+        Logger_1.logger.debug(`An error ocurred: ${e}.`);
+        exports.supportsPassive = false;
+    }
+}
+else {
+    exports.supportsPassive = false;
+}