@siemens/ix-icons 1.1.1 → 1.2.0-beta.0

package/dist/esm/{index-460e19e2.js → index-58099fde.js}

@@ -396,11 +396,7 @@ const createElm = (oldParentVNode, newParentVNode, childIndex, parentElm) => {
     let i = 0;
     let elm;
     let childNode;
-    if (newVNode.$text$ !== null) {
-        // create text node
-        elm = newVNode.$elm$ = doc.createTextNode(newVNode.$text$);
-    }
-    else {
+    {
         // create element
         elm = newVNode.$elm$ = (doc.createElement(newVNode.$tag$));
         // add css classes, attrs, props, listeners, etc.
@@ -467,16 +463,15 @@ const addVnodes = (parentElm, before, parentVNode, vnodes, startIdx, endIdx) =>
  * @param vnodes a list of virtual DOM nodes to remove
  * @param startIdx the index at which to start removing nodes (inclusive)
  * @param endIdx the index at which to stop removing nodes (inclusive)
+ * @param vnode a VNode
+ * @param elm an element
  */
-const removeVnodes = (vnodes, startIdx, endIdx) => {
-    for (let index = startIdx; index <= endIdx; ++index) {
-        const vnode = vnodes[index];
-        if (vnode) {
-            const elm = vnode.$elm$;
-            if (elm) {
-                // remove the vnode's element from the dom
-                elm.remove();
-            }
+const removeVnodes = (vnodes, startIdx, endIdx, vnode, elm) => {
+    for (; startIdx <= endIdx; ++startIdx) {
+        if ((vnode = vnodes[startIdx])) {
+            elm = vnode.$elm$;
+            // remove the vnode's element from the dom
+            elm.remove();
         }
     }
 };
@@ -689,8 +684,7 @@ const patch = (oldVNode, newVNode) => {
     const elm = (newVNode.$elm$ = oldVNode.$elm$);
     const oldChildren = oldVNode.$children$;
     const newChildren = newVNode.$children$;
-    const text = newVNode.$text$;
-    if (text === null) {
+    {
         {
             {
                 // either this is the first render of an element OR it's an update
@@ -705,11 +699,6 @@ const patch = (oldVNode, newVNode) => {
             updateChildren(elm, oldChildren, newVNode, newChildren);
         }
         else if (newChildren !== null) {
-            // no old child vnodes, but there are new child vnodes to add
-            if (oldVNode.$text$ !== null) {
-                // the old vnode was text, so be sure to clear it out
-                elm.textContent = '';
-            }
             // add the new vnode children
             addVnodes(elm, null, newVNode, newChildren, 0, newChildren.length - 1);
         }
@@ -718,11 +707,6 @@ const patch = (oldVNode, newVNode) => {
             removeVnodes(oldChildren, 0, oldChildren.length - 1);
         }
     }
-    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;
-    }
 };
 /**
  * The main entry point for Stencil's virtual DOM-based rendering engine
@@ -738,14 +722,9 @@ const patch = (oldVNode, newVNode) => {
  */
 const renderVdom = (hostRef, renderFnResults) => {
     const hostElm = hostRef.$hostElement$;
-    const cmpMeta = hostRef.$cmpMeta$;
     const oldVNode = hostRef.$vnode$ || newVNode(null, null);
     const rootVnode = isHost(renderFnResults) ? renderFnResults : h(null, null, renderFnResults);
     hostTagName = hostElm.tagName;
-    if (cmpMeta.$attrsToReflect$) {
-        rootVnode.$attrs$ = rootVnode.$attrs$ || {};
-        cmpMeta.$attrsToReflect$.map(([propName, attribute]) => (rootVnode.$attrs$[attribute] = hostElm[propName]));
-    }
     rootVnode.$tag$ = null;
     rootVnode.$flags$ |= 4 /* VNODE_FLAGS.isHost */;
     hostRef.$vnode$ = rootVnode;
@@ -776,53 +755,15 @@ const scheduleUpdate = (hostRef, isInitialLoad) => {
     const dispatch = () => dispatchHooks(hostRef, isInitialLoad);
     return writeTask(dispatch) ;
 };
-/**
- * Dispatch initial-render and update lifecycle hooks, enqueuing calls to
- * component lifecycle methods like `componentWillLoad` as well as
- * {@link updateComponent}, which will kick off the virtual DOM re-render.
- *
- * @param hostRef a reference to a host DOM node
- * @param isInitialLoad whether we're on the initial load or not
- * @returns an empty Promise which is used to enqueue a series of operations for
- * the component
- */
 const dispatchHooks = (hostRef, isInitialLoad) => {
     const endSchedule = createTime('scheduleUpdate', hostRef.$cmpMeta$.$tagName$);
     const instance = hostRef.$lazyInstance$ ;
-    // We're going to use this variable together with `enqueue` to implement a
-    // little promise-based queue. We start out with it `undefined`. When we add
-    // the first function to the queue we'll set this variable to be that
-    // function's return value. When we attempt to add subsequent values to the
-    // queue we'll check that value and, if it was a `Promise`, we'll then chain
-    // the new function off of that `Promise` using `.then()`. This will give our
-    // queue two nice properties:
-    //
-    // 1. If all functions added to the queue are synchronous they'll be called
-    //    synchronously right away.
-    // 2. If all functions added to the queue are asynchronous they'll all be
-    //    called in order after `dispatchHooks` exits.
-    let maybePromise;
+    let promise;
     endSchedule();
-    return enqueue(maybePromise, () => updateComponent(hostRef, instance, isInitialLoad));
+    return then(promise, () => updateComponent(hostRef, instance, isInitialLoad));
 };
-/**
- * This function uses a Promise to implement a simple first-in, first-out queue
- * of functions to be called.
- *
- * The queue is ordered on the basis of the first argument. If it's
- * `undefined`, then nothing is on the queue yet, so the provided function can
- * be called synchronously (although note that this function may return a
- * `Promise`). The idea is that then the return value of that enqueueing
- * operation is kept around, so that if it was a `Promise` then subsequent
- * functions can be enqueued by calling this function again with that `Promise`
- * as the first argument.
- *
- * @param maybePromise either a `Promise` which should resolve before the next function is called or an 'empty' sentinel
- * @param fn a function to enqueue
- * @returns either a `Promise` or the return value of the provided function
- */
-const enqueue = (maybePromise, fn) => maybePromise instanceof Promise ? maybePromise.then(fn) : fn();
 const updateComponent = async (hostRef, instance, isInitialLoad) => {
+    // updateComponent
     const elm = hostRef.$hostElement$;
     const endUpdate = createTime('update', hostRef.$cmpMeta$.$tagName$);
     const rc = elm['s-rc'];
@@ -938,6 +879,9 @@ const safeCall = (instance, method, arg) => {
     }
     return undefined;
 };
+const then = (promise, thenFn) => {
+    return promise && promise.then ? promise.then(thenFn) : thenFn();
+};
 const addHydratedFlag = (elm) => elm.classList.add('hydrated')
     ;
 const getValue = (ref, propName) => getHostRef(ref).$instanceValues$.get(propName);
@@ -1079,9 +1023,6 @@ const proxyComponent = (Cstr, cmpMeta, flags) => {
                 .map(([propName, m]) => {
                 const attrName = m[1] || propName;
                 attrNameToPropName.set(attrName, propName);
-                if (m[0] & 512 /* MEMBER_FLAGS.ReflectAttr */) {
-                    cmpMeta.$attrsToReflect$.push([propName, attrName]);
-                }
                 return attrName;
             });
         }
@@ -1091,9 +1032,9 @@ const proxyComponent = (Cstr, cmpMeta, flags) => {
 const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId, Cstr) => {
     // initializeComponent
     if ((hostRef.$flags$ & 32 /* HOST_FLAGS.hasInitializedComponent */) === 0) {
-        // Let the runtime know that the component has been initialized
-        hostRef.$flags$ |= 32 /* HOST_FLAGS.hasInitializedComponent */;
         {
+            // we haven't initialized this element yet
+            hostRef.$flags$ |= 32 /* HOST_FLAGS.hasInitializedComponent */;
             // lazy loaded components
             // request the component's implementation to be
             // wired up with the host element
@@ -1247,9 +1188,6 @@ const bootstrapLazy = (lazyBundles, options = {}) => {
             {
                 cmpMeta.$members$ = compactMeta[2];
             }
-            {
-                cmpMeta.$attrsToReflect$ = [];
-            }
             {
                 cmpMeta.$watchers$ = {};
             }
@@ -1451,4 +1389,4 @@ const writeTask = /*@__PURE__*/ queueTask(queueDomWrites, true);
 
 export { Host as H, bootstrapLazy as b, h, promiseResolve as p, registerInstance as r, setNonce as s };
 
-//# sourceMappingURL=index-460e19e2.js.map
+//# sourceMappingURL=index-58099fde.js.map