@heartlandone/vega 2.0.0-temp-test-0.2 → 2.0.0

package/dist/esm/{index-fe904372.js → index-c3505689.js}

@@ -1,11 +1,7 @@
 const NAMESPACE = 'vega';
 
 let scopeId;
-let contentRef;
 let hostTagName;
-let useNativeShadowDom = false;
-let checkSlotFallbackVisibility = false;
-let checkSlotRelocate = false;
 let isSvgMode = false;
 let queuePending = false;
 const win = typeof window !== 'undefined' ? window : {};
@@ -182,7 +178,6 @@ const isComplexType = (o) => {
 const h = (nodeName, vnodeData, ...children) => {
     let child = null;
     let key = null;
-    let slotName = null;
     let simple = false;
     let lastSimple = false;
     const vNodeChildren = [];
@@ -214,9 +209,6 @@ const h = (nodeName, vnodeData, ...children) => {
         if (vnodeData.key) {
             key = vnodeData.key;
         }
-        if (vnodeData.name) {
-            slotName = vnodeData.name;
-        }
         {
             const classData = vnodeData.className || vnodeData.class;
             if (classData) {
@@ -241,9 +233,6 @@ const h = (nodeName, vnodeData, ...children) => {
     {
         vnode.$key$ = key;
     }
-    {
-        vnode.$name$ = slotName;
-    }
     return vnode;
 };
 const newVNode = (tag, text) => {
@@ -260,9 +249,6 @@ const newVNode = (tag, text) => {
     {
         vnode.$key$ = null;
     }
-    {
-        vnode.$name$ = null;
-    }
     return vnode;
 };
 const Host = {};
@@ -475,39 +461,16 @@ const createElm = (oldParentVNode, newParentVNode, childIndex, parentElm) => {
     let i = 0;
     let elm;
     let childNode;
-    let oldVNode;
-    if (!useNativeShadowDom) {
-        // remember for later we need to check to relocate nodes
-        checkSlotRelocate = true;
-        if (newVNode.$tag$ === 'slot') {
-            if (scopeId) {
-                // scoped css needs to add its scoped id to the parent element
-                parentElm.classList.add(scopeId + '-s');
-            }
-            newVNode.$flags$ |= newVNode.$children$
-                ? // slot element has fallback content
-                    2 /* isSlotFallback */
-                : // slot element does not have fallback content
-                    1 /* isSlotReference */;
-        }
-    }
     if (newVNode.$text$ !== null) {
         // create text node
         elm = newVNode.$elm$ = doc.createTextNode(newVNode.$text$);
     }
-    else if (newVNode.$flags$ & 1 /* isSlotReference */) {
-        // create a slot reference node
-        elm = newVNode.$elm$ =
-            doc.createTextNode('');
-    }
     else {
         if (!isSvgMode) {
             isSvgMode = newVNode.$tag$ === 'svg';
         }
         // create element
-        elm = newVNode.$elm$ = (doc.createElementNS(isSvgMode ? SVG_NS : HTML_NS, newVNode.$flags$ & 2 /* isSlotFallback */
-                ? 'slot-fb'
-                : newVNode.$tag$)
+        elm = newVNode.$elm$ = (doc.createElementNS(isSvgMode ? SVG_NS : HTML_NS, newVNode.$tag$)
             );
         if (isSvgMode && newVNode.$tag$ === 'foreignObject') {
             isSvgMode = false;
@@ -524,7 +487,7 @@ const createElm = (oldParentVNode, newParentVNode, childIndex, parentElm) => {
         if (newVNode.$children$) {
             for (i = 0; i < newVNode.$children$.length; ++i) {
                 // create the node
-                childNode = createElm(oldParentVNode, newVNode, i, elm);
+                childNode = createElm(oldParentVNode, newVNode, i);
                 // return node could have been null
                 if (childNode) {
                     // append our new node
@@ -543,62 +506,20 @@ const createElm = (oldParentVNode, newParentVNode, childIndex, parentElm) => {
             }
         }
     }
-    {
-        elm['s-hn'] = hostTagName;
-        if (newVNode.$flags$ & (2 /* isSlotFallback */ | 1 /* isSlotReference */)) {
-            // remember the content reference comment
-            elm['s-sr'] = true;
-            // remember the content reference comment
-            elm['s-cr'] = contentRef;
-            // remember the slot name, or empty string for default slot
-            elm['s-sn'] = newVNode.$name$ || '';
-            // check if we've got an old vnode for this slot
-            oldVNode = oldParentVNode && oldParentVNode.$children$ && oldParentVNode.$children$[childIndex];
-            if (oldVNode && oldVNode.$tag$ === newVNode.$tag$ && oldParentVNode.$elm$) {
-                // we've got an old slot vnode and the wrapper is being replaced
-                // so let's move the old slot content back to it's original location
-                putBackInOriginalLocation(oldParentVNode.$elm$, false);
-            }
-        }
-    }
     return elm;
 };
-const putBackInOriginalLocation = (parentElm, recursive) => {
-    plt.$flags$ |= 1 /* isTmpDisconnected */;
-    const oldSlotChildNodes = parentElm.childNodes;
-    for (let i = oldSlotChildNodes.length - 1; i >= 0; i--) {
-        const childNode = oldSlotChildNodes[i];
-        if (childNode['s-hn'] !== hostTagName && childNode['s-ol']) {
-            // // this child node in the old element is from another component
-            // // remove this node from the old slot's parent
-            // childNode.remove();
-            // and relocate it back to it's original location
-            parentReferenceNode(childNode).insertBefore(childNode, referenceNode(childNode));
-            // remove the old original location comment entirely
-            // later on the patch function will know what to do
-            // and move this to the correct spot in need be
-            childNode['s-ol'].remove();
-            childNode['s-ol'] = undefined;
-            checkSlotRelocate = true;
-        }
-        if (recursive) {
-            putBackInOriginalLocation(childNode, recursive);
-        }
-    }
-    plt.$flags$ &= ~1 /* isTmpDisconnected */;
-};
 const addVnodes = (parentElm, before, parentVNode, vnodes, startIdx, endIdx) => {
-    let containerElm = ((parentElm['s-cr'] && parentElm['s-cr'].parentNode) || parentElm);
+    let containerElm = (parentElm);
     let childNode;
     if (containerElm.shadowRoot && containerElm.tagName === hostTagName) {
         containerElm = containerElm.shadowRoot;
     }
     for (; startIdx <= endIdx; ++startIdx) {
         if (vnodes[startIdx]) {
-            childNode = createElm(null, parentVNode, startIdx, parentElm);
+            childNode = createElm(null, parentVNode, startIdx);
             if (childNode) {
                 vnodes[startIdx].$elm$ = childNode;
-                containerElm.insertBefore(childNode, referenceNode(before) );
+                containerElm.insertBefore(childNode, before);
             }
         }
     }
@@ -608,20 +529,6 @@ const removeVnodes = (vnodes, startIdx, endIdx, vnode, elm) => {
         if ((vnode = vnodes[startIdx])) {
             elm = vnode.$elm$;
             callNodeRefs(vnode);
-            {
-                // we're removing this element
-                // so it's possible we need to show slot fallback content now
-                checkSlotFallbackVisibility = true;
-                if (elm['s-ol']) {
-                    // remove the original location comment
-                    elm['s-ol'].remove();
-                }
-                else {
-                    // it's possible that child nodes of the node
-                    // that's being removed are slot nodes
-                    putBackInOriginalLocation(elm, true);
-                }
-            }
             // remove the vnode's element from the dom
             elm.remove();
         }
@@ -665,20 +572,12 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh) => {
             newEndVnode = newCh[--newEndIdx];
         }
         else if (isSameVnode(oldStartVnode, newEndVnode)) {
-            // Vnode moved right
-            if ((oldStartVnode.$tag$ === 'slot' || newEndVnode.$tag$ === 'slot')) {
-                putBackInOriginalLocation(oldStartVnode.$elm$.parentNode, false);
-            }
             patch(oldStartVnode, newEndVnode);
             parentElm.insertBefore(oldStartVnode.$elm$, oldEndVnode.$elm$.nextSibling);
             oldStartVnode = oldCh[++oldStartIdx];
             newEndVnode = newCh[--newEndIdx];
         }
         else if (isSameVnode(oldEndVnode, newStartVnode)) {
-            // Vnode moved left
-            if ((oldStartVnode.$tag$ === 'slot' || newEndVnode.$tag$ === 'slot')) {
-                putBackInOriginalLocation(oldEndVnode.$elm$.parentNode, false);
-            }
             patch(oldEndVnode, newStartVnode);
             parentElm.insertBefore(oldEndVnode.$elm$, oldStartVnode.$elm$);
             oldEndVnode = oldCh[--oldEndIdx];
@@ -698,7 +597,7 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh) => {
             if (idxInOld >= 0) {
                 elmToMove = oldCh[idxInOld];
                 if (elmToMove.$tag$ !== newStartVnode.$tag$) {
-                    node = createElm(oldCh && oldCh[newStartIdx], newVNode, idxInOld, parentElm);
+                    node = createElm(oldCh && oldCh[newStartIdx], newVNode, idxInOld);
                 }
                 else {
                     patch(elmToMove, newStartVnode);
@@ -709,12 +608,12 @@ const updateChildren = (parentElm, oldCh, newVNode, newCh) => {
             }
             else {
                 // new element
-                node = createElm(oldCh && oldCh[newStartIdx], newVNode, newStartIdx, parentElm);
+                node = createElm(oldCh && oldCh[newStartIdx], newVNode, newStartIdx);
                 newStartVnode = newCh[++newStartIdx];
             }
             if (node) {
                 {
-                    parentReferenceNode(oldStartVnode.$elm$).insertBefore(node, referenceNode(oldStartVnode.$elm$));
+                    oldStartVnode.$elm$.parentNode.insertBefore(node, oldStartVnode.$elm$);
                 }
             }
         }
@@ -730,30 +629,18 @@ const isSameVnode = (vnode1, vnode2) => {
     // compare if two vnode to see if they're "technically" the same
     // need to have the same element tag, and same key to be the same
     if (vnode1.$tag$ === vnode2.$tag$) {
-        if (vnode1.$tag$ === 'slot') {
-            return vnode1.$name$ === vnode2.$name$;
-        }
         {
             return vnode1.$key$ === vnode2.$key$;
         }
     }
     return false;
 };
-const referenceNode = (node) => {
-    // this node was relocated to a new location in the dom
-    // because of some other component's slot
-    // but we still have an html comment in place of where
-    // it's original location was according to it's original vdom
-    return (node && node['s-ol']) || node;
-};
-const parentReferenceNode = (node) => (node['s-ol'] ? node['s-ol'] : node).parentNode;
 const patch = (oldVNode, newVNode) => {
     const elm = (newVNode.$elm$ = oldVNode.$elm$);
     const oldChildren = oldVNode.$children$;
     const newChildren = newVNode.$children$;
     const tag = newVNode.$tag$;
     const text = newVNode.$text$;
-    let defaultHolder;
     if (text === null) {
         {
             // test if we're rendering an svg element, or still rendering nodes inside of one
@@ -792,147 +679,12 @@ const patch = (oldVNode, newVNode) => {
             isSvgMode = false;
         }
     }
-    else if ((defaultHolder = elm['s-cr'])) {
-        // this element has slotted content
-        defaultHolder.parentNode.textContent = text;
-    }
     else if (oldVNode.$text$ !== text) {
         // update the text content for the text only vnode
         // and also only if the text is different than before
         elm.data = text;
     }
 };
-const updateFallbackSlotVisibility = (elm) => {
-    // tslint:disable-next-line: prefer-const
-    const childNodes = elm.childNodes;
-    let childNode;
-    let i;
-    let ilen;
-    let j;
-    let slotNameAttr;
-    let nodeType;
-    for (i = 0, ilen = childNodes.length; i < ilen; i++) {
-        childNode = childNodes[i];
-        if (childNode.nodeType === 1 /* ElementNode */) {
-            if (childNode['s-sr']) {
-                // this is a slot fallback node
-                // get the slot name for this slot reference node
-                slotNameAttr = childNode['s-sn'];
-                // by default always show a fallback slot node
-                // then hide it if there are other slots in the light dom
-                childNode.hidden = false;
-                for (j = 0; j < ilen; j++) {
-                    nodeType = childNodes[j].nodeType;
-                    if (childNodes[j]['s-hn'] !== childNode['s-hn'] || slotNameAttr !== '') {
-                        // this sibling node is from a different component OR is a named fallback slot node
-                        if (nodeType === 1 /* ElementNode */ && slotNameAttr === childNodes[j].getAttribute('slot')) {
-                            childNode.hidden = true;
-                            break;
-                        }
-                    }
-                    else {
-                        // this is a default fallback slot node
-                        // any element or text node (with content)
-                        // should hide the default fallback slot node
-                        if (nodeType === 1 /* ElementNode */ ||
-                            (nodeType === 3 /* TextNode */ && childNodes[j].textContent.trim() !== '')) {
-                            childNode.hidden = true;
-                            break;
-                        }
-                    }
-                }
-            }
-            // keep drilling down
-            updateFallbackSlotVisibility(childNode);
-        }
-    }
-};
-const relocateNodes = [];
-const relocateSlotContent = (elm) => {
-    // tslint:disable-next-line: prefer-const
-    let childNode;
-    let node;
-    let hostContentNodes;
-    let slotNameAttr;
-    let relocateNodeData;
-    let j;
-    let i = 0;
-    const childNodes = elm.childNodes;
-    const ilen = childNodes.length;
-    for (; i < ilen; i++) {
-        childNode = childNodes[i];
-        if (childNode['s-sr'] && (node = childNode['s-cr']) && node.parentNode) {
-            // first got the content reference comment node
-            // then we got it's parent, which is where all the host content is in now
-            hostContentNodes = node.parentNode.childNodes;
-            slotNameAttr = childNode['s-sn'];
-            for (j = hostContentNodes.length - 1; j >= 0; j--) {
-                node = hostContentNodes[j];
-                if (!node['s-cn'] && !node['s-nr'] && node['s-hn'] !== childNode['s-hn']) {
-                    // let's do some relocating to its new home
-                    // but never relocate a content reference node
-                    // that is suppose to always represent the original content location
-                    if (isNodeLocatedInSlot(node, slotNameAttr)) {
-                        // it's possible we've already decided to relocate this node
-                        relocateNodeData = relocateNodes.find((r) => r.$nodeToRelocate$ === node);
-                        // made some changes to slots
-                        // let's make sure we also double check
-                        // fallbacks are correctly hidden or shown
-                        checkSlotFallbackVisibility = true;
-                        node['s-sn'] = node['s-sn'] || slotNameAttr;
-                        if (relocateNodeData) {
-                            // previously we never found a slot home for this node
-                            // but turns out we did, so let's remember it now
-                            relocateNodeData.$slotRefNode$ = childNode;
-                        }
-                        else {
-                            // add to our list of nodes to relocate
-                            relocateNodes.push({
-                                $slotRefNode$: childNode,
-                                $nodeToRelocate$: node,
-                            });
-                        }
-                        if (node['s-sr']) {
-                            relocateNodes.map((relocateNode) => {
-                                if (isNodeLocatedInSlot(relocateNode.$nodeToRelocate$, node['s-sn'])) {
-                                    relocateNodeData = relocateNodes.find((r) => r.$nodeToRelocate$ === node);
-                                    if (relocateNodeData && !relocateNode.$slotRefNode$) {
-                                        relocateNode.$slotRefNode$ = relocateNodeData.$slotRefNode$;
-                                    }
-                                }
-                            });
-                        }
-                    }
-                    else if (!relocateNodes.some((r) => r.$nodeToRelocate$ === node)) {
-                        // so far this element does not have a slot home, not setting slotRefNode on purpose
-                        // if we never find a home for this element then we'll need to hide it
-                        relocateNodes.push({
-                            $nodeToRelocate$: node,
-                        });
-                    }
-                }
-            }
-        }
-        if (childNode.nodeType === 1 /* ElementNode */) {
-            relocateSlotContent(childNode);
-        }
-    }
-};
-const isNodeLocatedInSlot = (nodeToRelocate, slotNameAttr) => {
-    if (nodeToRelocate.nodeType === 1 /* ElementNode */) {
-        if (nodeToRelocate.getAttribute('slot') === null && slotNameAttr === '') {
-            return true;
-        }
-        if (nodeToRelocate.getAttribute('slot') === slotNameAttr) {
-            return true;
-        }
-        return false;
-    }
-    if (nodeToRelocate['s-sn'] === slotNameAttr) {
-        return true;
-    }
-    return slotNameAttr === '';
-};
 const callNodeRefs = (vNode) => {
     {
         vNode.$attrs$ && vNode.$attrs$.ref && vNode.$attrs$.ref(null);
@@ -956,90 +708,8 @@ const renderVdom = (hostRef, renderFnResults) => {
     {
         scopeId = hostElm['s-sc'];
     }
-    {
-        contentRef = hostElm['s-cr'];
-        useNativeShadowDom = (cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) !== 0;
-        // always reset
-        checkSlotFallbackVisibility = false;
-    }
     // synchronous patch
     patch(oldVNode, rootVnode);
-    {
-        // while we're moving nodes around existing nodes, temporarily disable
-        // the disconnectCallback from working
-        plt.$flags$ |= 1 /* isTmpDisconnected */;
-        if (checkSlotRelocate) {
-            relocateSlotContent(rootVnode.$elm$);
-            let relocateData;
-            let nodeToRelocate;
-            let orgLocationNode;
-            let parentNodeRef;
-            let insertBeforeNode;
-            let refNode;
-            let i = 0;
-            for (; i < relocateNodes.length; i++) {
-                relocateData = relocateNodes[i];
-                nodeToRelocate = relocateData.$nodeToRelocate$;
-                if (!nodeToRelocate['s-ol']) {
-                    // add a reference node marking this node's original location
-                    // keep a reference to this node for later lookups
-                    orgLocationNode =
-                        doc.createTextNode('');
-                    orgLocationNode['s-nr'] = nodeToRelocate;
-                    nodeToRelocate.parentNode.insertBefore((nodeToRelocate['s-ol'] = orgLocationNode), nodeToRelocate);
-                }
-            }
-            for (i = 0; i < relocateNodes.length; i++) {
-                relocateData = relocateNodes[i];
-                nodeToRelocate = relocateData.$nodeToRelocate$;
-                if (relocateData.$slotRefNode$) {
-                    // by default we're just going to insert it directly
-                    // after the slot reference node
-                    parentNodeRef = relocateData.$slotRefNode$.parentNode;
-                    insertBeforeNode = relocateData.$slotRefNode$.nextSibling;
-                    orgLocationNode = nodeToRelocate['s-ol'];
-                    while ((orgLocationNode = orgLocationNode.previousSibling)) {
-                        refNode = orgLocationNode['s-nr'];
-                        if (refNode && refNode['s-sn'] === nodeToRelocate['s-sn'] && parentNodeRef === refNode.parentNode) {
-                            refNode = refNode.nextSibling;
-                            if (!refNode || !refNode['s-nr']) {
-                                insertBeforeNode = refNode;
-                                break;
-                            }
-                        }
-                    }
-                    if ((!insertBeforeNode && parentNodeRef !== nodeToRelocate.parentNode) ||
-                        nodeToRelocate.nextSibling !== insertBeforeNode) {
-                        // we've checked that it's worth while to relocate
-                        // since that the node to relocate
-                        // has a different next sibling or parent relocated
-                        if (nodeToRelocate !== insertBeforeNode) {
-                            if (!nodeToRelocate['s-hn'] && nodeToRelocate['s-ol']) {
-                                // probably a component in the index.html that doesn't have it's hostname set
-                                nodeToRelocate['s-hn'] = nodeToRelocate['s-ol'].parentNode.nodeName;
-                            }
-                            // add it back to the dom but in its new home
-                            parentNodeRef.insertBefore(nodeToRelocate, insertBeforeNode);
-                        }
-                    }
-                }
-                else {
-                    // this node doesn't have a slot home to go to, so let's hide it
-                    if (nodeToRelocate.nodeType === 1 /* ElementNode */) {
-                        nodeToRelocate.hidden = true;
-                    }
-                }
-            }
-        }
-        if (checkSlotFallbackVisibility) {
-            updateFallbackSlotVisibility(rootVnode.$elm$);
-        }
-        // done moving nodes around
-        // allow the disconnect callback to work again
-        plt.$flags$ &= ~1 /* isTmpDisconnected */;
-        // always reset
-        relocateNodes.length = 0;
-    }
 };
 const getElement = (ref) => (getHostRef(ref).$hostElement$ );
 const createEvent = (ref, name, flags) => {
@@ -1103,9 +773,6 @@ const dispatchHooks = (hostRef, isInitialLoad) => {
             promise = safeCall(instance, 'componentWillLoad');
         }
     }
-    {
-        promise = then(promise, () => safeCall(instance, 'componentWillRender'));
-    }
     endSchedule();
     return then(promise, () => updateComponent(hostRef, instance, isInitialLoad));
 };
@@ -1543,15 +1210,6 @@ const connectedCallback = (elm) => {
         if (!(hostRef.$flags$ & 1 /* hasConnected */)) {
             // first time this component has connected
             hostRef.$flags$ |= 1 /* hasConnected */;
-            {
-                // initUpdate
-                // if the slot polyfill is required we'll need to put some nodes
-                // in here to act as original content anchors as we move nodes around
-                // host element has been connected to the DOM
-                if ((cmpMeta.$flags$ & (4 /* hasSlotRelocation */ | 8 /* needsShadowDomShim */))) {
-                    setContentReference(elm);
-                }
-            }
             {
                 // find the first ancestor component (if there is one) and register
                 // this component as one of the actively loading child components for its ancestor
@@ -1593,17 +1251,6 @@ const connectedCallback = (elm) => {
         endConnected();
     }
 };
-const setContentReference = (elm) => {
-    // only required when we're NOT using native shadow dom (slot)
-    // or this browser doesn't support native shadow dom
-    // and this host element was NOT created with SSR
-    // let's pick out the inner content for slot projection
-    // create a node to represent where the original
-    // content was first placed, which is useful later on
-    const contentRefElm = (elm['s-cr'] = doc.createComment(''));
-    contentRefElm['s-cn'] = true;
-    elm.insertBefore(contentRefElm, elm.firstChild);
-};
 const disconnectedCallback = (elm) => {
     if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0) {
         const hostRef = getHostRef(elm);
@@ -1758,10 +1405,6 @@ const loadModule = (cmpMeta, hostRef, hmrVersionId) => {
       }
       switch(bundleId) {
         
-        case 'vega-banner_30':
-          return import(
-            /* webpackMode: "lazy" */
-            './vega-banner_30.entry.js').then(processMod, consoleError);
         case 'vega-accordion':
           return import(
             /* webpackMode: "lazy" */
@@ -1774,114 +1417,122 @@ const loadModule = (cmpMeta, hostRef, hmrVersionId) => {
           return import(
             /* webpackMode: "lazy" */
             './vega-app-header-button.entry.js').then(processMod, consoleError);
-        case 'vega-badge':
+        case 'vega-backdrop':
           return import(
             /* webpackMode: "lazy" */
-            './vega-badge.entry.js').then(processMod, consoleError);
-        case 'vega-bar-chart':
-          return import(
-            /* webpackMode: "lazy" */
-            './vega-bar-chart.entry.js').then(processMod, consoleError);
+            './vega-backdrop.entry.js').then(processMod, consoleError);
         case 'vega-box':
           return import(
             /* webpackMode: "lazy" */
             './vega-box.entry.js').then(processMod, consoleError);
+        case 'vega-flex':
+          return import(
+            /* webpackMode: "lazy" */
+            './vega-flex.entry.js').then(processMod, consoleError);
+        case 'vega-grid':
+          return import(
+            /* webpackMode: "lazy" */
+            './vega-grid.entry.js').then(processMod, consoleError);
         case 'vega-breadcrumb':
           return import(
             /* webpackMode: "lazy" */
             './vega-breadcrumb.entry.js').then(processMod, consoleError);
-        case 'vega-color-picker':
+        case 'vega-button':
           return import(
             /* webpackMode: "lazy" */
-            './vega-color-picker.entry.js').then(processMod, consoleError);
-        case 'vega-combo-box':
+            './vega-button.entry.js').then(processMod, consoleError);
+        case 'vega-button-circle':
           return import(
             /* webpackMode: "lazy" */
-            './vega-combo-box.entry.js').then(processMod, consoleError);
-        case 'vega-counter-badge':
+            './vega-button-circle.entry.js').then(processMod, consoleError);
+        case 'vega-button-link':
           return import(
             /* webpackMode: "lazy" */
-            './vega-counter-badge.entry.js').then(processMod, consoleError);
-        case 'vega-dialog':
+            './vega-button-link.entry.js').then(processMod, consoleError);
+        case 'vega-card':
           return import(
             /* webpackMode: "lazy" */
-            './vega-dialog.entry.js').then(processMod, consoleError);
-        case 'vega-dropdown-group':
+            './vega-card.entry.js').then(processMod, consoleError);
+        case 'vega-carousel':
           return import(
             /* webpackMode: "lazy" */
-            './vega-dropdown-group.entry.js').then(processMod, consoleError);
-        case 'vega-dropdown-item':
+            './vega-carousel.entry.js').then(processMod, consoleError);
+        case 'vega-line-chart':
           return import(
             /* webpackMode: "lazy" */
-            './vega-dropdown-item.entry.js').then(processMod, consoleError);
-        case 'vega-field-error':
+            './vega-line-chart.entry.js').then(processMod, consoleError);
+        case 'vega-bar-chart':
           return import(
             /* webpackMode: "lazy" */
-            './vega-field-error.entry.js').then(processMod, consoleError);
-        case 'vega-font':
+            './vega-bar-chart.entry.js').then(processMod, consoleError);
+        case 'vega-pie-chart':
           return import(
             /* webpackMode: "lazy" */
-            './vega-font.entry.js').then(processMod, consoleError);
-        case 'vega-header':
+            './vega-pie-chart.entry.js').then(processMod, consoleError);
+        case 'vega-chip':
           return import(
             /* webpackMode: "lazy" */
-            './vega-header.entry.js').then(processMod, consoleError);
-        case 'vega-image-uploader':
+            './vega-chip.entry.js').then(processMod, consoleError);
+        case 'vega-counter-badge':
           return import(
             /* webpackMode: "lazy" */
-            './vega-image-uploader.entry.js').then(processMod, consoleError);
-        case 'vega-input-credit-card':
+            './vega-counter-badge.entry.js').then(processMod, consoleError);
+        case 'vega-color-picker':
           return import(
             /* webpackMode: "lazy" */
-            './vega-input-credit-card.entry.js').then(processMod, consoleError);
-        case 'vega-item-toggle':
+            './vega-color-picker.entry.js').then(processMod, consoleError);
+        case 'vega-combo-box':
           return import(
             /* webpackMode: "lazy" */
-            './vega-item-toggle.entry.js').then(processMod, consoleError);
-        case 'vega-left-nav':
+            './vega-combo-box.entry.js').then(processMod, consoleError);
+        case 'vega-field-error':
           return import(
             /* webpackMode: "lazy" */
-            './vega-left-nav.entry.js').then(processMod, consoleError);
-        case 'vega-left-nav-group':
+            './vega-field-error.entry.js').then(processMod, consoleError);
+        case 'vega-field-label':
           return import(
             /* webpackMode: "lazy" */
-            './vega-left-nav-group.entry.js').then(processMod, consoleError);
-        case 'vega-left-nav-link':
+            './vega-field-label.entry.js').then(processMod, consoleError);
+        case 'vega-font':
           return import(
             /* webpackMode: "lazy" */
-            './vega-left-nav-link.entry.js').then(processMod, consoleError);
-        case 'vega-left-nav-section':
+            './vega-font.entry.js').then(processMod, consoleError);
+        case 'vega-form':
           return import(
             /* webpackMode: "lazy" */
-            './vega-left-nav-section.entry.js').then(processMod, consoleError);
-        case 'vega-loading-indicator':
+            './vega-form.entry.js').then(processMod, consoleError);
+        case 'vega-icon':
           return import(
             /* webpackMode: "lazy" */
-            './vega-loading-indicator.entry.js').then(processMod, consoleError);
-        case 'vega-nav-card':
+            './vega-icon.entry.js').then(processMod, consoleError);
+        case 'vega-image-uploader':
           return import(
             /* webpackMode: "lazy" */
-            './vega-nav-card.entry.js').then(processMod, consoleError);
-        case 'vega-option':
+            './vega-image-uploader.entry.js').then(processMod, consoleError);
+        case 'vega-input-credit-card':
           return import(
             /* webpackMode: "lazy" */
-            './vega-option.entry.js').then(processMod, consoleError);
-        case 'vega-page-notification':
+            './vega-input-credit-card.entry.js').then(processMod, consoleError);
+        case 'vega-input-select':
           return import(
             /* webpackMode: "lazy" */
-            './vega-page-notification.entry.js').then(processMod, consoleError);
-        case 'vega-pagination':
+            './vega-input-select.entry.js').then(processMod, consoleError);
+        case 'vega-input':
           return import(
             /* webpackMode: "lazy" */
-            './vega-pagination.entry.js').then(processMod, consoleError);
-        case 'vega-pie-chart':
+            './vega-input.entry.js').then(processMod, consoleError);
+        case 'vega-item-toggle':
           return import(
             /* webpackMode: "lazy" */
-            './vega-pie-chart.entry.js').then(processMod, consoleError);
-        case 'vega-popover':
+            './vega-item-toggle.entry.js').then(processMod, consoleError);
+        case 'vega-pagination':
           return import(
             /* webpackMode: "lazy" */
-            './vega-popover.entry.js').then(processMod, consoleError);
+            './vega-pagination.entry.js').then(processMod, consoleError);
+        case 'vega-progress-tracker':
+          return import(
+            /* webpackMode: "lazy" */
+            './vega-progress-tracker.entry.js').then(processMod, consoleError);
         case 'vega-slot-container':
           return import(
             /* webpackMode: "lazy" */
@@ -1890,58 +1541,70 @@ const loadModule = (cmpMeta, hostRef, hmrVersionId) => {
           return import(
             /* webpackMode: "lazy" */
             './vega-stepper.entry.js').then(processMod, consoleError);
-        case 'vega-table-body':
+        case 'vega-text':
           return import(
             /* webpackMode: "lazy" */
-            './vega-table-body.entry.js').then(processMod, consoleError);
-        case 'vega-table-cell':
+            './vega-text.entry.js').then(processMod, consoleError);
+        case 'vega-textarea':
           return import(
             /* webpackMode: "lazy" */
-            './vega-table-cell.entry.js').then(processMod, consoleError);
-        case 'vega-table-expand-row':
+            './vega-textarea.entry.js').then(processMod, consoleError);
+        case 'vega-toggle-switch':
           return import(
             /* webpackMode: "lazy" */
-            './vega-table-expand-row.entry.js').then(processMod, consoleError);
-        case 'vega-table-head':
+            './vega-toggle-switch.entry.js').then(processMod, consoleError);
+        case 'vega-checkbox_2':
           return import(
             /* webpackMode: "lazy" */
-            './vega-table-head.entry.js').then(processMod, consoleError);
-        case 'vega-table-head-cell':
+            './vega-checkbox_2.entry.js').then(processMod, consoleError);
+        case 'vega-date-picker_2':
           return import(
             /* webpackMode: "lazy" */
-            './vega-table-head-cell.entry.js').then(processMod, consoleError);
-        case 'vega-table-head-row':
+            './vega-date-picker_2.entry.js').then(processMod, consoleError);
+        case 'vega-dialog_2':
           return import(
             /* webpackMode: "lazy" */
-            './vega-table-head-row.entry.js').then(processMod, consoleError);
-        case 'vega-table-row':
+            './vega-dialog_2.entry.js').then(processMod, consoleError);
+        case 'vega-page-notification_2':
           return import(
             /* webpackMode: "lazy" */
-            './vega-table-row.entry.js').then(processMod, consoleError);
-        case 'vega-textarea':
+            './vega-page-notification_2.entry.js').then(processMod, consoleError);
+        case 'vega-loader-wrapper_2':
           return import(
             /* webpackMode: "lazy" */
-            './vega-textarea.entry.js').then(processMod, consoleError);
-        case 'vega-virtual-scroll':
+            './vega-loader-wrapper_2.entry.js').then(processMod, consoleError);
+        case 'vega-popover_2':
           return import(
             /* webpackMode: "lazy" */
-            './vega-virtual-scroll.entry.js').then(processMod, consoleError);
-        case 'vega-chip':
+            './vega-popover_2.entry.js').then(processMod, consoleError);
+        case 'vega-radio_2':
           return import(
             /* webpackMode: "lazy" */
-            './vega-chip.entry.js').then(processMod, consoleError);
-        case 'vega-form':
+            './vega-radio_2.entry.js').then(processMod, consoleError);
+        case 'vega-tab-group_2':
           return import(
             /* webpackMode: "lazy" */
-            './vega-form.entry.js').then(processMod, consoleError);
-        case 'vega-dropdown':
+            './vega-tab-group_2.entry.js').then(processMod, consoleError);
+        case 'vega-time-picker_2':
           return import(
             /* webpackMode: "lazy" */
-            './vega-dropdown.entry.js').then(processMod, consoleError);
-        case 'vega-button-circle':
+            './vega-time-picker_2.entry.js').then(processMod, consoleError);
+        case 'vega-tooltip_2':
           return import(
             /* webpackMode: "lazy" */
-            './vega-button-circle.entry.js').then(processMod, consoleError);
+            './vega-tooltip_2.entry.js').then(processMod, consoleError);
+        case 'vega-dropdown_5':
+          return import(
+            /* webpackMode: "lazy" */
+            './vega-dropdown_5.entry.js').then(processMod, consoleError);
+        case 'vega-left-nav_5':
+          return import(
+            /* webpackMode: "lazy" */
+            './vega-left-nav_5.entry.js').then(processMod, consoleError);
+        case 'vega-table_8':
+          return import(
+            /* webpackMode: "lazy" */
+            './vega-table_8.entry.js').then(processMod, consoleError);
       }
     }
     return import(