New Research: Supply Chain Attack on Axios Pulls Malicious Dependency from npm.Details → →
@deckdeckgo/inline-editor
Advanced tools
@deckdeckgo/inline-editor - npm Package Compare versions
| 'use strict'; | ||
| function _interopNamespace(e) { | ||
| if (e && e.__esModule) return e; | ||
| var n = Object.create(null); | ||
| if (e) { | ||
| Object.keys(e).forEach(function (k) { | ||
| if (k !== 'default') { | ||
| var d = Object.getOwnPropertyDescriptor(e, k); | ||
| Object.defineProperty(n, k, d.get ? d : { | ||
| enumerable: true, | ||
| get: function () { | ||
| return e[k]; | ||
| } | ||
| }); | ||
| } | ||
| }); | ||
| } | ||
| n['default'] = e; | ||
| return Object.freeze(n); | ||
| } | ||
| const NAMESPACE = 'deckdeckgo-inline-editor'; | ||
| let scopeId; | ||
| let hostTagName; | ||
| let isSvgMode = false; | ||
| let queuePending = false; | ||
| const win = typeof window !== 'undefined' ? window : {}; | ||
| const doc = win.document || { head: {} }; | ||
| const plt = { | ||
| $flags$: 0, | ||
| $resourcesUrl$: '', | ||
| jmp: h => h(), | ||
| raf: h => requestAnimationFrame(h), | ||
| ael: (el, eventName, listener, opts) => el.addEventListener(eventName, listener, opts), | ||
| rel: (el, eventName, listener, opts) => el.removeEventListener(eventName, listener, opts), | ||
| ce: (eventName, opts) => new CustomEvent(eventName, opts), | ||
| }; | ||
| const promiseResolve = (v) => Promise.resolve(v); | ||
| const supportsConstructibleStylesheets = /*@__PURE__*/ (() => { | ||
| try { | ||
| new CSSStyleSheet(); | ||
| return typeof (new CSSStyleSheet()).replace === 'function'; | ||
| } | ||
| catch (e) { } | ||
| return false; | ||
| })() | ||
| ; | ||
| const HYDRATED_CSS = '{visibility:hidden}.hydrated{visibility:inherit}'; | ||
| const createTime = (fnName, tagName = '') => { | ||
| { | ||
| return () => { | ||
| return; | ||
| }; | ||
| } | ||
| }; | ||
| const uniqueTime = (key, measureText) => { | ||
| { | ||
| return () => { | ||
| return; | ||
| }; | ||
| } | ||
| }; | ||
| const rootAppliedStyles = new WeakMap(); | ||
| const registerStyle = (scopeId, cssText, allowCS) => { | ||
| let style = styles.get(scopeId); | ||
| if (supportsConstructibleStylesheets && allowCS) { | ||
| style = (style || new CSSStyleSheet()); | ||
| style.replace(cssText); | ||
| } | ||
| else { | ||
| style = cssText; | ||
| } | ||
| styles.set(scopeId, style); | ||
| }; | ||
| const addStyle = (styleContainerNode, cmpMeta, mode, hostElm) => { | ||
| let scopeId = getScopeId(cmpMeta); | ||
| let style = styles.get(scopeId); | ||
| // if an element is NOT connected then getRootNode() will return the wrong root node | ||
| // so the fallback is to always use the document for the root node in those cases | ||
| styleContainerNode = styleContainerNode.nodeType === 11 /* DocumentFragment */ ? styleContainerNode : doc; | ||
| if (style) { | ||
| if (typeof style === 'string') { | ||
| styleContainerNode = styleContainerNode.head || styleContainerNode; | ||
| let appliedStyles = rootAppliedStyles.get(styleContainerNode); | ||
| let styleElm; | ||
| if (!appliedStyles) { | ||
| rootAppliedStyles.set(styleContainerNode, (appliedStyles = new Set())); | ||
| } | ||
| if (!appliedStyles.has(scopeId)) { | ||
| { | ||
| { | ||
| styleElm = doc.createElement('style'); | ||
| styleElm.innerHTML = style; | ||
| } | ||
| styleContainerNode.insertBefore(styleElm, styleContainerNode.querySelector('link')); | ||
| } | ||
| if (appliedStyles) { | ||
| appliedStyles.add(scopeId); | ||
| } | ||
| } | ||
| } | ||
| else if (!styleContainerNode.adoptedStyleSheets.includes(style)) { | ||
| styleContainerNode.adoptedStyleSheets = [...styleContainerNode.adoptedStyleSheets, style]; | ||
| } | ||
| } | ||
| return scopeId; | ||
| }; | ||
| const attachStyles = (hostRef) => { | ||
| const cmpMeta = hostRef.$cmpMeta$; | ||
| const elm = hostRef.$hostElement$; | ||
| const flags = cmpMeta.$flags$; | ||
| const endAttachStyles = createTime('attachStyles', cmpMeta.$tagName$); | ||
| const scopeId = addStyle(elm.shadowRoot ? elm.shadowRoot : elm.getRootNode(), cmpMeta); | ||
| if (flags & 10 /* needsScopedEncapsulation */) { | ||
| // 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 | ||
| // DOM WRITE!! | ||
| elm['s-sc'] = scopeId; | ||
| elm.classList.add(scopeId + '-h'); | ||
| } | ||
| endAttachStyles(); | ||
| }; | ||
| const getScopeId = (cmp, mode) => 'sc-' + (cmp.$tagName$); | ||
| /** | ||
| * Default style mode id | ||
| */ | ||
| /** | ||
| * Reusable empty obj/array | ||
| * Don't add values to these!! | ||
| */ | ||
| const EMPTY_OBJ = {}; | ||
| const isDef = (v) => v != null; | ||
| const isComplexType = (o) => { | ||
| // https://jsperf.com/typeof-fn-object/5 | ||
| o = typeof o; | ||
| return o === 'object' || o === 'function'; | ||
| }; | ||
| /** | ||
| * Production h() function based on Preact by | ||
| * Jason Miller (@developit) | ||
| * Licensed under the MIT License | ||
| * https://github.com/developit/preact/blob/master/LICENSE | ||
| * | ||
| * Modified for Stencil's compiler and vdom | ||
| */ | ||
| // const stack: any[] = []; | ||
| // export function h(nodeName: string | d.FunctionalComponent, vnodeData: d.PropsType, child?: d.ChildType): d.VNode; | ||
| // export function h(nodeName: string | d.FunctionalComponent, vnodeData: d.PropsType, ...children: d.ChildType[]): d.VNode; | ||
| const h = (nodeName, vnodeData, ...children) => { | ||
| let child = null; | ||
| let simple = false; | ||
| let lastSimple = false; | ||
| let vNodeChildren = []; | ||
| const walk = (c) => { | ||
| for (let i = 0; i < c.length; i++) { | ||
| child = c[i]; | ||
| if (Array.isArray(child)) { | ||
| walk(child); | ||
| } | ||
| else if (child != null && typeof child !== 'boolean') { | ||
| if ((simple = typeof nodeName !== 'function' && !isComplexType(child))) { | ||
| child = String(child); | ||
| } | ||
| if (simple && lastSimple) { | ||
| // If the previous child was simple (string), we merge both | ||
| vNodeChildren[vNodeChildren.length - 1].$text$ += child; | ||
| } | ||
| else { | ||
| // Append a new vNode, if it's text, we create a text vNode | ||
| vNodeChildren.push(simple ? newVNode(null, child) : child); | ||
| } | ||
| lastSimple = simple; | ||
| } | ||
| } | ||
| }; | ||
| walk(children); | ||
| if (vnodeData) { | ||
| { | ||
| const classData = vnodeData.className || vnodeData.class; | ||
| if (classData) { | ||
| vnodeData.class = | ||
| typeof classData !== 'object' | ||
| ? classData | ||
| : Object.keys(classData) | ||
| .filter(k => classData[k]) | ||
| .join(' '); | ||
| } | ||
| } | ||
| } | ||
| if (typeof nodeName === 'function') { | ||
| // nodeName is a functional component | ||
| return nodeName(vnodeData === null ? {} : vnodeData, vNodeChildren, vdomFnUtils); | ||
| } | ||
| const vnode = newVNode(nodeName, null); | ||
| vnode.$attrs$ = vnodeData; | ||
| if (vNodeChildren.length > 0) { | ||
| vnode.$children$ = vNodeChildren; | ||
| } | ||
| return vnode; | ||
| }; | ||
| const newVNode = (tag, text) => { | ||
| const vnode = { | ||
| $flags$: 0, | ||
| $tag$: tag, | ||
| $text$: text, | ||
| $elm$: null, | ||
| $children$: null, | ||
| }; | ||
| { | ||
| vnode.$attrs$ = null; | ||
| } | ||
| return vnode; | ||
| }; | ||
| const Host = {}; | ||
| const isHost = (node) => node && node.$tag$ === Host; | ||
| const vdomFnUtils = { | ||
| forEach: (children, cb) => children.map(convertToPublic).forEach(cb), | ||
| map: (children, cb) => children.map(convertToPublic).map(cb).map(convertToPrivate), | ||
| }; | ||
| const convertToPublic = (node) => ({ | ||
| vattrs: node.$attrs$, | ||
| vchildren: node.$children$, | ||
| vkey: node.$key$, | ||
| vname: node.$name$, | ||
| vtag: node.$tag$, | ||
| vtext: node.$text$, | ||
| }); | ||
| const convertToPrivate = (node) => { | ||
| if (typeof node.vtag === 'function') { | ||
| const vnodeData = Object.assign({}, node.vattrs); | ||
| if (node.vkey) { | ||
| vnodeData.key = node.vkey; | ||
| } | ||
| if (node.vname) { | ||
| vnodeData.name = node.vname; | ||
| } | ||
| return h(node.vtag, vnodeData, ...(node.vchildren || [])); | ||
| } | ||
| const vnode = newVNode(node.vtag, node.vtext); | ||
| vnode.$attrs$ = node.vattrs; | ||
| vnode.$children$ = node.vchildren; | ||
| vnode.$key$ = node.vkey; | ||
| vnode.$name$ = node.vname; | ||
| return vnode; | ||
| }; | ||
| /** | ||
| * Production setAccessor() function based on Preact by | ||
| * Jason Miller (@developit) | ||
| * Licensed under the MIT License | ||
| * https://github.com/developit/preact/blob/master/LICENSE | ||
| * | ||
| * Modified for Stencil's compiler and vdom | ||
| */ | ||
| const setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags) => { | ||
| if (oldValue !== newValue) { | ||
| let isProp = isMemberInElement(elm, memberName); | ||
| let ln = memberName.toLowerCase(); | ||
| if (memberName === 'class') { | ||
| const classList = elm.classList; | ||
| const oldClasses = parseClassList(oldValue); | ||
| const newClasses = parseClassList(newValue); | ||
| classList.remove(...oldClasses.filter(c => c && !newClasses.includes(c))); | ||
| classList.add(...newClasses.filter(c => c && !oldClasses.includes(c))); | ||
| } | ||
| else if (memberName === 'style') { | ||
| // update style attribute, css properties and values | ||
| { | ||
| for (const prop in oldValue) { | ||
| if (!newValue || newValue[prop] == null) { | ||
| if (prop.includes('-')) { | ||
| elm.style.removeProperty(prop); | ||
| } | ||
| else { | ||
| elm.style[prop] = ''; | ||
| } | ||
| } | ||
| } | ||
| } | ||
| for (const prop in newValue) { | ||
| if (!oldValue || newValue[prop] !== oldValue[prop]) { | ||
| if (prop.includes('-')) { | ||
| elm.style.setProperty(prop, newValue[prop]); | ||
| } | ||
| else { | ||
| elm.style[prop] = newValue[prop]; | ||
| } | ||
| } | ||
| } | ||
| } | ||
| else if (memberName === 'ref') { | ||
| // minifier will clean this up | ||
| if (newValue) { | ||
| newValue(elm); | ||
| } | ||
| } | ||
| else if ((!isProp ) && memberName[0] === 'o' && memberName[1] === 'n') { | ||
| // Event Handlers | ||
| // so if the member name starts with "on" and the 3rd characters is | ||
| // a capital letter, and it's not already a member on the element, | ||
| // then we're assuming it's an event listener | ||
| if (memberName[2] === '-') { | ||
| // on- prefixed events | ||
| // allows to be explicit about the dom event to listen without any magic | ||
| // under the hood: | ||
| // <my-cmp on-click> // listens for "click" | ||
| // <my-cmp on-Click> // listens for "Click" | ||
| // <my-cmp on-ionChange> // listens for "ionChange" | ||
| // <my-cmp on-EVENTS> // listens for "EVENTS" | ||
| memberName = memberName.slice(3); | ||
| } | ||
| else if (isMemberInElement(win, ln)) { | ||
| // standard event | ||
| // the JSX attribute could have been "onMouseOver" and the | ||
| // member name "onmouseover" is on the window's prototype | ||
| // so let's add the listener "mouseover", which is all lowercased | ||
| memberName = ln.slice(2); | ||
| } | ||
| else { | ||
| // custom event | ||
| // the JSX attribute could have been "onMyCustomEvent" | ||
| // so let's trim off the "on" prefix and lowercase the first character | ||
| // and add the listener "myCustomEvent" | ||
| // except for the first character, we keep the event name case | ||
| memberName = ln[2] + memberName.slice(3); | ||
| } | ||
| if (oldValue) { | ||
| plt.rel(elm, memberName, oldValue, false); | ||
| } | ||
| if (newValue) { | ||
| plt.ael(elm, memberName, newValue, false); | ||
| } | ||
| } | ||
| else { | ||
| // Set property if it exists and it's not a SVG | ||
| const isComplex = isComplexType(newValue); | ||
| if ((isProp || (isComplex && newValue !== null)) && !isSvg) { | ||
| try { | ||
| if (!elm.tagName.includes('-')) { | ||
| let n = newValue == null ? '' : newValue; | ||
| // Workaround for Safari, moving the <input> caret when re-assigning the same valued | ||
| if (memberName === 'list') { | ||
| isProp = false; | ||
| // tslint:disable-next-line: triple-equals | ||
| } | ||
| else if (oldValue == null || elm[memberName] != n) { | ||
| elm[memberName] = n; | ||
| } | ||
| } | ||
| else { | ||
| elm[memberName] = newValue; | ||
| } | ||
| } | ||
| catch (e) { } | ||
| } | ||
| if (newValue == null || newValue === false) { | ||
| if (newValue !== false || elm.getAttribute(memberName) === '') { | ||
| { | ||
| elm.removeAttribute(memberName); | ||
| } | ||
| } | ||
| } | ||
| else if ((!isProp || flags & 4 /* isHost */ || isSvg) && !isComplex) { | ||
| newValue = newValue === true ? '' : newValue; | ||
| { | ||
| elm.setAttribute(memberName, newValue); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| }; | ||
| const parseClassListRegex = /\s/; | ||
| const parseClassList = (value) => (!value ? [] : value.split(parseClassListRegex)); | ||
| const updateElement = (oldVnode, newVnode, isSvgMode, memberName) => { | ||
| // if the element passed in is a shadow root, which is a document fragment | ||
| // then we want to be adding attrs/props to the shadow root's "host" element | ||
| // if it's not a shadow root, then we add attrs/props to the same element | ||
| const elm = newVnode.$elm$.nodeType === 11 /* DocumentFragment */ && newVnode.$elm$.host ? newVnode.$elm$.host : newVnode.$elm$; | ||
| const oldVnodeAttrs = (oldVnode && oldVnode.$attrs$) || EMPTY_OBJ; | ||
| const newVnodeAttrs = newVnode.$attrs$ || EMPTY_OBJ; | ||
| { | ||
| // remove attributes no longer present on the vnode by setting them to undefined | ||
| for (memberName in oldVnodeAttrs) { | ||
| if (!(memberName in newVnodeAttrs)) { | ||
| setAccessor(elm, memberName, oldVnodeAttrs[memberName], undefined, isSvgMode, newVnode.$flags$); | ||
| } | ||
| } | ||
| } | ||
| // add new & update changed attributes | ||
| for (memberName in newVnodeAttrs) { | ||
| setAccessor(elm, memberName, oldVnodeAttrs[memberName], newVnodeAttrs[memberName], isSvgMode, newVnode.$flags$); | ||
| } | ||
| }; | ||
| const createElm = (oldParentVNode, newParentVNode, childIndex, parentElm) => { | ||
| // tslint:disable-next-line: prefer-const | ||
| let newVNode = newParentVNode.$children$[childIndex]; | ||
| 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. | ||
| { | ||
| updateElement(null, newVNode, isSvgMode); | ||
| } | ||
| if (isDef(scopeId) && elm['s-si'] !== scopeId) { | ||
| // if there is a scopeId and this is the initial render | ||
| // then let's add the scopeId as a css class | ||
| elm.classList.add((elm['s-si'] = scopeId)); | ||
| } | ||
| if (newVNode.$children$) { | ||
| for (i = 0; i < newVNode.$children$.length; ++i) { | ||
| // create the node | ||
| childNode = createElm(oldParentVNode, newVNode, i); | ||
| // return node could have been null | ||
| if (childNode) { | ||
| // append our new node | ||
| elm.appendChild(childNode); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| return elm; | ||
| }; | ||
| const addVnodes = (parentElm, before, parentVNode, vnodes, startIdx, endIdx) => { | ||
| 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); | ||
| if (childNode) { | ||
| vnodes[startIdx].$elm$ = childNode; | ||
| containerElm.insertBefore(childNode, before); | ||
| } | ||
| } | ||
| } | ||
| }; | ||
| const removeVnodes = (vnodes, startIdx, endIdx, vnode, elm) => { | ||
| for (; startIdx <= endIdx; ++startIdx) { | ||
| if ((vnode = vnodes[startIdx])) { | ||
| elm = vnode.$elm$; | ||
| callNodeRefs(vnode); | ||
| // remove the vnode's element from the dom | ||
| elm.remove(); | ||
| } | ||
| } | ||
| }; | ||
| const updateChildren = (parentElm, oldCh, newVNode, newCh) => { | ||
| let oldStartIdx = 0; | ||
| let newStartIdx = 0; | ||
| let oldEndIdx = oldCh.length - 1; | ||
| let oldStartVnode = oldCh[0]; | ||
| let oldEndVnode = oldCh[oldEndIdx]; | ||
| let newEndIdx = newCh.length - 1; | ||
| let newStartVnode = newCh[0]; | ||
| let newEndVnode = newCh[newEndIdx]; | ||
| let node; | ||
| while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) { | ||
| if (oldStartVnode == null) { | ||
| // Vnode might have been moved left | ||
| oldStartVnode = oldCh[++oldStartIdx]; | ||
| } | ||
| else if (oldEndVnode == null) { | ||
| oldEndVnode = oldCh[--oldEndIdx]; | ||
| } | ||
| else if (newStartVnode == null) { | ||
| newStartVnode = newCh[++newStartIdx]; | ||
| } | ||
| else if (newEndVnode == null) { | ||
| newEndVnode = newCh[--newEndIdx]; | ||
| } | ||
| else if (isSameVnode(oldStartVnode, newStartVnode)) { | ||
| patch(oldStartVnode, newStartVnode); | ||
| oldStartVnode = oldCh[++oldStartIdx]; | ||
| newStartVnode = newCh[++newStartIdx]; | ||
| } | ||
| else if (isSameVnode(oldEndVnode, newEndVnode)) { | ||
| patch(oldEndVnode, newEndVnode); | ||
| oldEndVnode = oldCh[--oldEndIdx]; | ||
| newEndVnode = newCh[--newEndIdx]; | ||
| } | ||
| else if (isSameVnode(oldStartVnode, newEndVnode)) { | ||
| patch(oldStartVnode, newEndVnode); | ||
| parentElm.insertBefore(oldStartVnode.$elm$, oldEndVnode.$elm$.nextSibling); | ||
| oldStartVnode = oldCh[++oldStartIdx]; | ||
| newEndVnode = newCh[--newEndIdx]; | ||
| } | ||
| else if (isSameVnode(oldEndVnode, newStartVnode)) { | ||
| patch(oldEndVnode, newStartVnode); | ||
| parentElm.insertBefore(oldEndVnode.$elm$, oldStartVnode.$elm$); | ||
| oldEndVnode = oldCh[--oldEndIdx]; | ||
| newStartVnode = newCh[++newStartIdx]; | ||
| } | ||
| else { | ||
| { | ||
| // new element | ||
| node = createElm(oldCh && oldCh[newStartIdx], newVNode, newStartIdx); | ||
| newStartVnode = newCh[++newStartIdx]; | ||
| } | ||
| if (node) { | ||
| { | ||
| oldStartVnode.$elm$.parentNode.insertBefore(node, oldStartVnode.$elm$); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| if (oldStartIdx > oldEndIdx) { | ||
| addVnodes(parentElm, newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].$elm$, newVNode, newCh, newStartIdx, newEndIdx); | ||
| } | ||
| else if (newStartIdx > newEndIdx) { | ||
| removeVnodes(oldCh, oldStartIdx, oldEndIdx); | ||
| } | ||
| }; | ||
| 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$) { | ||
| return true; | ||
| } | ||
| return false; | ||
| }; | ||
| 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$; | ||
| if (text === null) { | ||
| // element node | ||
| { | ||
| if (tag === 'slot') | ||
| ; | ||
| else { | ||
| // either this is the first render of an element OR it's an update | ||
| // AND we already know it's possible it could have changed | ||
| // this updates the element's css classes, attrs, props, listeners, etc. | ||
| updateElement(oldVNode, newVNode, isSvgMode); | ||
| } | ||
| } | ||
| if (oldChildren !== null && newChildren !== null) { | ||
| // looks like there's child vnodes for both the old and new vnodes | ||
| 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); | ||
| } | ||
| else if (oldChildren !== null) { | ||
| // no new child vnodes, but there are old child vnodes to remove | ||
| 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; | ||
| } | ||
| }; | ||
| const callNodeRefs = (vNode) => { | ||
| { | ||
| vNode.$attrs$ && vNode.$attrs$.ref && vNode.$attrs$.ref(null); | ||
| vNode.$children$ && vNode.$children$.map(callNodeRefs); | ||
| } | ||
| }; | ||
| const renderVdom = (hostRef, renderFnResults) => { | ||
| const hostElm = hostRef.$hostElement$; | ||
| const oldVNode = hostRef.$vnode$ || newVNode(null, null); | ||
| const rootVnode = isHost(renderFnResults) ? renderFnResults : h(null, null, renderFnResults); | ||
| hostTagName = hostElm.tagName; | ||
| rootVnode.$tag$ = null; | ||
| rootVnode.$flags$ |= 4 /* isHost */; | ||
| hostRef.$vnode$ = rootVnode; | ||
| rootVnode.$elm$ = oldVNode.$elm$ = (hostElm.shadowRoot || hostElm ); | ||
| { | ||
| scopeId = hostElm['s-sc']; | ||
| } | ||
| // synchronous patch | ||
| patch(oldVNode, rootVnode); | ||
| }; | ||
| const getElement = (ref) => (getHostRef(ref).$hostElement$ ); | ||
| const createEvent = (ref, name, flags) => { | ||
| const elm = getElement(ref); | ||
| return { | ||
| emit: (detail) => { | ||
| return emitEvent(elm, name, { | ||
| bubbles: !!(flags & 4 /* Bubbles */), | ||
| composed: !!(flags & 2 /* Composed */), | ||
| cancelable: !!(flags & 1 /* Cancellable */), | ||
| detail, | ||
| }); | ||
| }, | ||
| }; | ||
| }; | ||
| const emitEvent = (elm, name, opts) => { | ||
| const ev = plt.ce(name, opts); | ||
| elm.dispatchEvent(ev); | ||
| return ev; | ||
| }; | ||
| const attachToAncestor = (hostRef, ancestorComponent) => { | ||
| if (ancestorComponent && !hostRef.$onRenderResolve$ && ancestorComponent['s-p']) { | ||
| ancestorComponent['s-p'].push(new Promise(r => (hostRef.$onRenderResolve$ = r))); | ||
| } | ||
| }; | ||
| const scheduleUpdate = (hostRef, isInitialLoad) => { | ||
| { | ||
| hostRef.$flags$ |= 16 /* isQueuedForUpdate */; | ||
| } | ||
| if (hostRef.$flags$ & 4 /* isWaitingForChildren */) { | ||
| hostRef.$flags$ |= 512 /* needsRerender */; | ||
| return; | ||
| } | ||
| attachToAncestor(hostRef, hostRef.$ancestorComponent$); | ||
| // there is no ancestor component or the ancestor component | ||
| // has already fired off its lifecycle update then | ||
| // fire off the initial update | ||
| const dispatch = () => dispatchHooks(hostRef, isInitialLoad); | ||
| return writeTask(dispatch) ; | ||
| }; | ||
| const dispatchHooks = (hostRef, isInitialLoad) => { | ||
| const endSchedule = createTime('scheduleUpdate', hostRef.$cmpMeta$.$tagName$); | ||
| const instance = hostRef.$lazyInstance$ ; | ||
| let promise; | ||
| if (isInitialLoad) { | ||
| { | ||
| promise = safeCall(instance, 'componentWillLoad'); | ||
| } | ||
| } | ||
| endSchedule(); | ||
| return then(promise, () => updateComponent(hostRef, instance, isInitialLoad)); | ||
| }; | ||
| const updateComponent = async (hostRef, instance, isInitialLoad) => { | ||
| // updateComponent | ||
| const elm = hostRef.$hostElement$; | ||
| const endUpdate = createTime('update', hostRef.$cmpMeta$.$tagName$); | ||
| const rc = elm['s-rc']; | ||
| if (isInitialLoad) { | ||
| // DOM WRITE! | ||
| attachStyles(hostRef); | ||
| } | ||
| const endRender = createTime('render', hostRef.$cmpMeta$.$tagName$); | ||
| { | ||
| callRender(hostRef, instance); | ||
| } | ||
| if (rc) { | ||
| // ok, so turns out there are some child host elements | ||
| // waiting on this parent element to load | ||
| // let's fire off all update callbacks waiting | ||
| rc.map(cb => cb()); | ||
| elm['s-rc'] = undefined; | ||
| } | ||
| endRender(); | ||
| endUpdate(); | ||
| { | ||
| const childrenPromises = elm['s-p']; | ||
| const postUpdate = () => postUpdateComponent(hostRef); | ||
| if (childrenPromises.length === 0) { | ||
| postUpdate(); | ||
| } | ||
| else { | ||
| Promise.all(childrenPromises).then(postUpdate); | ||
| hostRef.$flags$ |= 4 /* isWaitingForChildren */; | ||
| childrenPromises.length = 0; | ||
| } | ||
| } | ||
| }; | ||
| const callRender = (hostRef, instance, elm) => { | ||
| try { | ||
| instance = instance.render() ; | ||
| { | ||
| hostRef.$flags$ &= ~16 /* isQueuedForUpdate */; | ||
| } | ||
| { | ||
| hostRef.$flags$ |= 2 /* hasRendered */; | ||
| } | ||
| { | ||
| { | ||
| // looks like we've got child nodes to render into this host element | ||
| // or we need to update the css class/attrs on the host element | ||
| // DOM WRITE! | ||
| { | ||
| renderVdom(hostRef, instance); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| catch (e) { | ||
| consoleError(e, hostRef.$hostElement$); | ||
| } | ||
| return null; | ||
| }; | ||
| const postUpdateComponent = (hostRef) => { | ||
| const tagName = hostRef.$cmpMeta$.$tagName$; | ||
| const elm = hostRef.$hostElement$; | ||
| const endPostUpdate = createTime('postUpdate', tagName); | ||
| const instance = hostRef.$lazyInstance$ ; | ||
| const ancestorComponent = hostRef.$ancestorComponent$; | ||
| if (!(hostRef.$flags$ & 64 /* hasLoadedComponent */)) { | ||
| hostRef.$flags$ |= 64 /* hasLoadedComponent */; | ||
| { | ||
| // DOM WRITE! | ||
| addHydratedFlag(elm); | ||
| } | ||
| { | ||
| safeCall(instance, 'componentDidLoad'); | ||
| } | ||
| endPostUpdate(); | ||
| { | ||
| hostRef.$onReadyResolve$(elm); | ||
| if (!ancestorComponent) { | ||
| appDidLoad(); | ||
| } | ||
| } | ||
| } | ||
| else { | ||
| endPostUpdate(); | ||
| } | ||
| { | ||
| hostRef.$onInstanceResolve$(elm); | ||
| } | ||
| // load events fire from bottom to top | ||
| // the deepest elements load first then bubbles up | ||
| { | ||
| if (hostRef.$onRenderResolve$) { | ||
| hostRef.$onRenderResolve$(); | ||
| hostRef.$onRenderResolve$ = undefined; | ||
| } | ||
| if (hostRef.$flags$ & 512 /* needsRerender */) { | ||
| nextTick(() => scheduleUpdate(hostRef, false)); | ||
| } | ||
| hostRef.$flags$ &= ~(4 /* isWaitingForChildren */ | 512 /* needsRerender */); | ||
| } | ||
| // ( •_•) | ||
| // ( •_•)>⌐■-■ | ||
| // (⌐■_■) | ||
| }; | ||
| const appDidLoad = (who) => { | ||
| // on appload | ||
| // we have finish the first big initial render | ||
| { | ||
| addHydratedFlag(doc.documentElement); | ||
| } | ||
| nextTick(() => emitEvent(win, 'appload', { detail: { namespace: NAMESPACE } })); | ||
| }; | ||
| const safeCall = (instance, method, arg) => { | ||
| if (instance && instance[method]) { | ||
| try { | ||
| return instance[method](arg); | ||
| } | ||
| catch (e) { | ||
| consoleError(e); | ||
| } | ||
| } | ||
| return undefined; | ||
| }; | ||
| const then = (promise, thenFn) => { | ||
| return promise && promise.then ? promise.then(thenFn) : thenFn(); | ||
| }; | ||
| const addHydratedFlag = (elm) => (elm.classList.add('hydrated') ); | ||
| const parsePropertyValue = (propValue, propType) => { | ||
| // ensure this value is of the correct prop type | ||
| if (propValue != null && !isComplexType(propValue)) { | ||
| if (propType & 4 /* Boolean */) { | ||
| // per the HTML spec, any string value means it is a boolean true value | ||
| // but we'll cheat here and say that the string "false" is the boolean false | ||
| return propValue === 'false' ? false : propValue === '' || !!propValue; | ||
| } | ||
| if (propType & 2 /* Number */) { | ||
| // force it to be a number | ||
| return parseFloat(propValue); | ||
| } | ||
| if (propType & 1 /* String */) { | ||
| // could have been passed as a number or boolean | ||
| // but we still want it as a string | ||
| return String(propValue); | ||
| } | ||
| // redundant return here for better minification | ||
| return propValue; | ||
| } | ||
| // not sure exactly what type we want | ||
| // so no need to change to a different type | ||
| return propValue; | ||
| }; | ||
| const getValue = (ref, propName) => getHostRef(ref).$instanceValues$.get(propName); | ||
| const setValue = (ref, propName, newVal, cmpMeta) => { | ||
| // check our new property value against our internal value | ||
| const hostRef = getHostRef(ref); | ||
| const elm = hostRef.$hostElement$ ; | ||
| const oldVal = hostRef.$instanceValues$.get(propName); | ||
| const flags = hostRef.$flags$; | ||
| const instance = hostRef.$lazyInstance$ ; | ||
| newVal = parsePropertyValue(newVal, cmpMeta.$members$[propName][0]); | ||
| if ((!(flags & 8 /* isConstructingInstance */) || oldVal === undefined) && newVal !== oldVal) { | ||
| // gadzooks! the property's value has changed!! | ||
| // set our new value! | ||
| hostRef.$instanceValues$.set(propName, newVal); | ||
| if (instance) { | ||
| // get an array of method names of watch functions to call | ||
| if (cmpMeta.$watchers$ && flags & 128 /* isWatchReady */) { | ||
| const watchMethods = cmpMeta.$watchers$[propName]; | ||
| if (watchMethods) { | ||
| // this instance is watching for when this property changed | ||
| watchMethods.map(watchMethodName => { | ||
| try { | ||
| // fire off each of the watch methods that are watching this property | ||
| instance[watchMethodName](newVal, oldVal, propName); | ||
| } | ||
| catch (e) { | ||
| consoleError(e, elm); | ||
| } | ||
| }); | ||
| } | ||
| } | ||
| if ((flags & (2 /* hasRendered */ | 16 /* isQueuedForUpdate */)) === 2 /* hasRendered */) { | ||
| // looks like this value actually changed, so we've got work to do! | ||
| // but only if we've already rendered, otherwise just chill out | ||
| // queue that we need to do an update, but don't worry about queuing | ||
| // up millions cuz this function ensures it only runs once | ||
| scheduleUpdate(hostRef, false); | ||
| } | ||
| } | ||
| } | ||
| }; | ||
| const proxyComponent = (Cstr, cmpMeta, flags) => { | ||
| if (cmpMeta.$members$) { | ||
| if (Cstr.watchers) { | ||
| cmpMeta.$watchers$ = Cstr.watchers; | ||
| } | ||
| // It's better to have a const than two Object.entries() | ||
| const members = Object.entries(cmpMeta.$members$); | ||
| const prototype = Cstr.prototype; | ||
| members.map(([memberName, [memberFlags]]) => { | ||
| if ((memberFlags & 31 /* Prop */ || ((flags & 2 /* proxyState */) && memberFlags & 32 /* State */))) { | ||
| // proxyComponent - prop | ||
| Object.defineProperty(prototype, memberName, { | ||
| get() { | ||
| // proxyComponent, get value | ||
| return getValue(this, memberName); | ||
| }, | ||
| set(newValue) { | ||
| // proxyComponent, set value | ||
| setValue(this, memberName, newValue, cmpMeta); | ||
| }, | ||
| configurable: true, | ||
| enumerable: true, | ||
| }); | ||
| } | ||
| else if (flags & 1 /* isElementConstructor */ && memberFlags & 64 /* Method */) { | ||
| // proxyComponent - method | ||
| Object.defineProperty(prototype, memberName, { | ||
| value(...args) { | ||
| const ref = getHostRef(this); | ||
| return ref.$onInstancePromise$.then(() => ref.$lazyInstance$[memberName](...args)); | ||
| }, | ||
| }); | ||
| } | ||
| }); | ||
| if ((flags & 1 /* isElementConstructor */)) { | ||
| const attrNameToPropName = new Map(); | ||
| prototype.attributeChangedCallback = function (attrName, _oldValue, newValue) { | ||
| plt.jmp(() => { | ||
| const propName = attrNameToPropName.get(attrName); | ||
| this[propName] = newValue === null && typeof this[propName] === 'boolean' ? false : newValue; | ||
| }); | ||
| }; | ||
| // create an array of attributes to observe | ||
| // and also create a map of html attribute name to js property name | ||
| Cstr.observedAttributes = members | ||
| .filter(([_, m]) => m[0] & 15 /* HasAttribute */) // filter to only keep props that should match attributes | ||
| .map(([propName, m]) => { | ||
| const attrName = m[1] || propName; | ||
| attrNameToPropName.set(attrName, propName); | ||
| return attrName; | ||
| }); | ||
| } | ||
| } | ||
| return Cstr; | ||
| }; | ||
| const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId, Cstr) => { | ||
| // initializeComponent | ||
| if ((hostRef.$flags$ & 32 /* hasInitializedComponent */) === 0) { | ||
| { | ||
| // we haven't initialized this element yet | ||
| hostRef.$flags$ |= 32 /* hasInitializedComponent */; | ||
| // lazy loaded components | ||
| // request the component's implementation to be | ||
| // wired up with the host element | ||
| Cstr = loadModule(cmpMeta); | ||
| if (Cstr.then) { | ||
| // Await creates a micro-task avoid if possible | ||
| const endLoad = uniqueTime(); | ||
| Cstr = await Cstr; | ||
| endLoad(); | ||
| } | ||
| if (!Cstr.isProxied) { | ||
| // we'eve never proxied this Constructor before | ||
| // let's add the getters/setters to its prototype before | ||
| // the first time we create an instance of the implementation | ||
| { | ||
| cmpMeta.$watchers$ = Cstr.watchers; | ||
| } | ||
| proxyComponent(Cstr, cmpMeta, 2 /* proxyState */); | ||
| Cstr.isProxied = true; | ||
| } | ||
| const endNewInstance = createTime('createInstance', cmpMeta.$tagName$); | ||
| // ok, time to construct the instance | ||
| // but let's keep track of when we start and stop | ||
| // so that the getters/setters don't incorrectly step on data | ||
| { | ||
| hostRef.$flags$ |= 8 /* isConstructingInstance */; | ||
| } | ||
| // construct the lazy-loaded component implementation | ||
| // passing the hostRef is very important during | ||
| // construction in order to directly wire together the | ||
| // host element and the lazy-loaded instance | ||
| try { | ||
| new Cstr(hostRef); | ||
| } | ||
| catch (e) { | ||
| consoleError(e); | ||
| } | ||
| { | ||
| hostRef.$flags$ &= ~8 /* isConstructingInstance */; | ||
| } | ||
| { | ||
| hostRef.$flags$ |= 128 /* isWatchReady */; | ||
| } | ||
| endNewInstance(); | ||
| fireConnectedCallback(hostRef.$lazyInstance$); | ||
| } | ||
| if (Cstr.style) { | ||
| // this component has styles but we haven't registered them yet | ||
| let style = Cstr.style; | ||
| const scopeId = getScopeId(cmpMeta); | ||
| if (!styles.has(scopeId)) { | ||
| const endRegisterStyles = createTime('registerStyles', cmpMeta.$tagName$); | ||
| registerStyle(scopeId, style, !!(cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */)); | ||
| endRegisterStyles(); | ||
| } | ||
| } | ||
| } | ||
| // we've successfully created a lazy instance | ||
| const ancestorComponent = hostRef.$ancestorComponent$; | ||
| const schedule = () => scheduleUpdate(hostRef, true); | ||
| if (ancestorComponent && ancestorComponent['s-rc']) { | ||
| // this is the intial load and this component it has an ancestor component | ||
| // but the ancestor component has NOT fired its will update lifecycle yet | ||
| // so let's just cool our jets and wait for the ancestor to continue first | ||
| // this will get fired off when the ancestor component | ||
| // finally gets around to rendering its lazy self | ||
| // fire off the initial update | ||
| ancestorComponent['s-rc'].push(schedule); | ||
| } | ||
| else { | ||
| schedule(); | ||
| } | ||
| }; | ||
| const fireConnectedCallback = (instance) => { | ||
| { | ||
| safeCall(instance, 'connectedCallback'); | ||
| } | ||
| }; | ||
| const connectedCallback = (elm) => { | ||
| if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0) { | ||
| const hostRef = getHostRef(elm); | ||
| const cmpMeta = hostRef.$cmpMeta$; | ||
| const endConnected = createTime('connectedCallback', cmpMeta.$tagName$); | ||
| if (!(hostRef.$flags$ & 1 /* hasConnected */)) { | ||
| // first time this component has connected | ||
| hostRef.$flags$ |= 1 /* hasConnected */; | ||
| { | ||
| // find the first ancestor component (if there is one) and register | ||
| // this component as one of the actively loading child components for its ancestor | ||
| let ancestorComponent = elm; | ||
| while ((ancestorComponent = ancestorComponent.parentNode || ancestorComponent.host)) { | ||
| // climb up the ancestors looking for the first | ||
| // component that hasn't finished its lifecycle update yet | ||
| if (ancestorComponent['s-p']) { | ||
| // we found this components first ancestor component | ||
| // keep a reference to this component's ancestor component | ||
| attachToAncestor(hostRef, (hostRef.$ancestorComponent$ = ancestorComponent)); | ||
| break; | ||
| } | ||
| } | ||
| } | ||
| // Lazy properties | ||
| // https://developers.google.com/web/fundamentals/web-components/best-practices#lazy-properties | ||
| if (cmpMeta.$members$) { | ||
| Object.entries(cmpMeta.$members$).map(([memberName, [memberFlags]]) => { | ||
| if (memberFlags & 31 /* Prop */ && elm.hasOwnProperty(memberName)) { | ||
| const value = elm[memberName]; | ||
| delete elm[memberName]; | ||
| elm[memberName] = value; | ||
| } | ||
| }); | ||
| } | ||
| { | ||
| initializeComponent(elm, hostRef, cmpMeta); | ||
| } | ||
| } | ||
| else { | ||
| // fire off connectedCallback() on component instance | ||
| fireConnectedCallback(hostRef.$lazyInstance$); | ||
| } | ||
| endConnected(); | ||
| } | ||
| }; | ||
| const disconnectedCallback = (elm) => { | ||
| if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0) { | ||
| const hostRef = getHostRef(elm); | ||
| const instance = hostRef.$lazyInstance$ ; | ||
| { | ||
| safeCall(instance, 'disconnectedCallback'); | ||
| } | ||
| } | ||
| }; | ||
| const bootstrapLazy = (lazyBundles, options = {}) => { | ||
| const endBootstrap = createTime(); | ||
| const cmpTags = []; | ||
| const exclude = options.exclude || []; | ||
| const customElements = win.customElements; | ||
| const head = doc.head; | ||
| const metaCharset = /*@__PURE__*/ head.querySelector('meta[charset]'); | ||
| const visibilityStyle = /*@__PURE__*/ doc.createElement('style'); | ||
| const deferredConnectedCallbacks = []; | ||
| let appLoadFallback; | ||
| let isBootstrapping = true; | ||
| Object.assign(plt, options); | ||
| plt.$resourcesUrl$ = new URL(options.resourcesUrl || './', doc.baseURI).href; | ||
| lazyBundles.map(lazyBundle => lazyBundle[1].map(compactMeta => { | ||
| const cmpMeta = { | ||
| $flags$: compactMeta[0], | ||
| $tagName$: compactMeta[1], | ||
| $members$: compactMeta[2], | ||
| $listeners$: compactMeta[3], | ||
| }; | ||
| { | ||
| cmpMeta.$members$ = compactMeta[2]; | ||
| } | ||
| { | ||
| cmpMeta.$watchers$ = {}; | ||
| } | ||
| const tagName = cmpMeta.$tagName$; | ||
| const HostElement = class extends HTMLElement { | ||
| // StencilLazyHost | ||
| constructor(self) { | ||
| // @ts-ignore | ||
| super(self); | ||
| self = this; | ||
| registerHost(self, cmpMeta); | ||
| if (cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) { | ||
| // this component is using shadow dom | ||
| // and this browser supports shadow dom | ||
| // add the read-only property "shadowRoot" to the host element | ||
| // adding the shadow root build conditionals to minimize runtime | ||
| { | ||
| { | ||
| self.attachShadow({ mode: 'open' }); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| connectedCallback() { | ||
| if (appLoadFallback) { | ||
| clearTimeout(appLoadFallback); | ||
| appLoadFallback = null; | ||
| } | ||
| if (isBootstrapping) { | ||
| // connectedCallback will be processed once all components have been registered | ||
| deferredConnectedCallbacks.push(this); | ||
| } | ||
| else { | ||
| plt.jmp(() => connectedCallback(this)); | ||
| } | ||
| } | ||
| disconnectedCallback() { | ||
| plt.jmp(() => disconnectedCallback(this)); | ||
| } | ||
| componentOnReady() { | ||
| return getHostRef(this).$onReadyPromise$; | ||
| } | ||
| }; | ||
| cmpMeta.$lazyBundleId$ = lazyBundle[0]; | ||
| if (!exclude.includes(tagName) && !customElements.get(tagName)) { | ||
| cmpTags.push(tagName); | ||
| customElements.define(tagName, proxyComponent(HostElement, cmpMeta, 1 /* isElementConstructor */)); | ||
| } | ||
| })); | ||
| { | ||
| visibilityStyle.innerHTML = cmpTags + HYDRATED_CSS; | ||
| visibilityStyle.setAttribute('data-styles', ''); | ||
| head.insertBefore(visibilityStyle, metaCharset ? metaCharset.nextSibling : head.firstChild); | ||
| } | ||
| // Process deferred connectedCallbacks now all components have been registered | ||
| isBootstrapping = false; | ||
| if (deferredConnectedCallbacks.length) { | ||
| deferredConnectedCallbacks.map(host => host.connectedCallback()); | ||
| } | ||
| else { | ||
| { | ||
| plt.jmp(() => (appLoadFallback = setTimeout(appDidLoad, 30))); | ||
| } | ||
| } | ||
| // Fallback appLoad event | ||
| endBootstrap(); | ||
| }; | ||
| const Fragment = (_, children) => children; | ||
| const hostRefs = new WeakMap(); | ||
| const getHostRef = (ref) => hostRefs.get(ref); | ||
| const registerInstance = (lazyInstance, hostRef) => hostRefs.set((hostRef.$lazyInstance$ = lazyInstance), hostRef); | ||
| const registerHost = (elm, cmpMeta) => { | ||
| const hostRef = { | ||
| $flags$: 0, | ||
| $hostElement$: elm, | ||
| $cmpMeta$: cmpMeta, | ||
| $instanceValues$: new Map(), | ||
| }; | ||
| { | ||
| hostRef.$onInstancePromise$ = new Promise(r => (hostRef.$onInstanceResolve$ = r)); | ||
| } | ||
| { | ||
| hostRef.$onReadyPromise$ = new Promise(r => (hostRef.$onReadyResolve$ = r)); | ||
| elm['s-p'] = []; | ||
| elm['s-rc'] = []; | ||
| } | ||
| return hostRefs.set(elm, hostRef); | ||
| }; | ||
| const isMemberInElement = (elm, memberName) => memberName in elm; | ||
| const consoleError = (e, el) => (0, console.error)(e, el); | ||
| const cmpModules = /*@__PURE__*/ new Map(); | ||
| const loadModule = (cmpMeta, hostRef, hmrVersionId) => { | ||
| // loadModuleImport | ||
| const exportName = cmpMeta.$tagName$.replace(/-/g, '_'); | ||
| const bundleId = cmpMeta.$lazyBundleId$; | ||
| const module = cmpModules.get(bundleId) ; | ||
| if (module) { | ||
| return module[exportName]; | ||
| } | ||
| return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require( | ||
| /* webpackInclude: /\.entry\.js$/ */ | ||
| /* webpackExclude: /\.system\.entry\.js$/ */ | ||
| /* webpackMode: "lazy" */ | ||
| `./${bundleId}.entry.js${''}`)); }).then(importedModule => { | ||
| { | ||
| cmpModules.set(bundleId, importedModule); | ||
| } | ||
| return importedModule[exportName]; | ||
| }, consoleError); | ||
| }; | ||
| const styles = new Map(); | ||
| const queueDomReads = []; | ||
| const queueDomWrites = []; | ||
| const queueTask = (queue, write) => (cb) => { | ||
| queue.push(cb); | ||
| if (!queuePending) { | ||
| queuePending = true; | ||
| if (write && plt.$flags$ & 4 /* queueSync */) { | ||
| nextTick(flush); | ||
| } | ||
| else { | ||
| plt.raf(flush); | ||
| } | ||
| } | ||
| }; | ||
| const consume = (queue) => { | ||
| for (let i = 0; i < queue.length; i++) { | ||
| try { | ||
| queue[i](performance.now()); | ||
| } | ||
| catch (e) { | ||
| consoleError(e); | ||
| } | ||
| } | ||
| queue.length = 0; | ||
| }; | ||
| const flush = () => { | ||
| // always force a bunch of medium callbacks to run, but still have | ||
| // a throttle on how many can run in a certain time | ||
| // DOM READS!!! | ||
| consume(queueDomReads); | ||
| // DOM WRITES!!! | ||
| { | ||
| consume(queueDomWrites); | ||
| if ((queuePending = queueDomReads.length > 0)) { | ||
| // still more to do yet, but we've run out of time | ||
| // let's let this thing cool off and try again in the next tick | ||
| plt.raf(flush); | ||
| } | ||
| } | ||
| }; | ||
| const nextTick = /*@__PURE__*/ (cb) => promiseResolve().then(cb); | ||
| const writeTask = /*@__PURE__*/ queueTask(queueDomWrites, true); | ||
| exports.Fragment = Fragment; | ||
| exports.Host = Host; | ||
| exports.bootstrapLazy = bootstrapLazy; | ||
| exports.createEvent = createEvent; | ||
| exports.getElement = getElement; | ||
| exports.h = h; | ||
| exports.promiseResolve = promiseResolve; | ||
| exports.registerInstance = registerInstance; |
Sorry, the diff of this file is too big to display
| let e,t,n=!1;const l="undefined"!=typeof window?window:{},o=l.document||{head:{}},s={t:0,l:"",jmp:e=>e(),raf:e=>requestAnimationFrame(e),ael:(e,t,n,l)=>e.addEventListener(t,n,l),rel:(e,t,n,l)=>e.removeEventListener(t,n,l),ce:(e,t)=>new CustomEvent(e,t)},c=e=>Promise.resolve(e),r=(()=>{try{return new CSSStyleSheet,"function"==typeof(new CSSStyleSheet).replace}catch(e){}return!1})(),i=new WeakMap,a=e=>"sc-"+e.o,u={},f=e=>"object"==(e=typeof e)||"function"===e,d=(e,t,...n)=>{let l=null,o=!1,s=!1,c=[];const r=t=>{for(let n=0;n<t.length;n++)l=t[n],Array.isArray(l)?r(l):null!=l&&"boolean"!=typeof l&&((o="function"!=typeof e&&!f(l))&&(l+=""),o&&s?c[c.length-1].i+=l:c.push(o?y(null,l):l),s=o)};if(r(n),t){const e=t.className||t.class;e&&(t.class="object"!=typeof e?e:Object.keys(e).filter((t=>e[t])).join(" "))}if("function"==typeof e)return e(null===t?{}:t,c,$);const i=y(e,null);return i.u=t,c.length>0&&(i.p=c),i},y=(e,t)=>({t:0,$:e,i:t,h:null,p:null,u:null}),p={},$={forEach:(e,t)=>e.map(h).forEach(t),map:(e,t)=>e.map(h).map(t).map(m)},h=e=>({vattrs:e.u,vchildren:e.p,vkey:e.m,vname:e.v,vtag:e.$,vtext:e.i}),m=e=>{if("function"==typeof e.vtag){const t=Object.assign({},e.vattrs);return e.vkey&&(t.key=e.vkey),e.vname&&(t.name=e.vname),d(e.vtag,t,...e.vchildren||[])}const t=y(e.vtag,e.vtext);return t.u=e.vattrs,t.p=e.vchildren,t.m=e.vkey,t.v=e.vname,t},b=(e,t,n,o,c,r)=>{if(n!==o){let i=K(e,t),a=t.toLowerCase();if("class"===t){const t=e.classList,l=v(n),s=v(o);t.remove(...l.filter((e=>e&&!s.includes(e)))),t.add(...s.filter((e=>e&&!l.includes(e))))}else if("style"===t){for(const t in n)o&&null!=o[t]||(t.includes("-")?e.style.removeProperty(t):e.style[t]="");for(const t in o)n&&o[t]===n[t]||(t.includes("-")?e.style.setProperty(t,o[t]):e.style[t]=o[t])}else if("ref"===t)o&&o(e);else if(i||"o"!==t[0]||"n"!==t[1]){const l=f(o);if((i||l&&null!==o)&&!c)try{if(e.tagName.includes("-"))e[t]=o;else{let l=null==o?"":o;"list"===t?i=!1:null!=n&&e[t]==l||(e[t]=l)}}catch(e){}null==o||!1===o?!1===o&&""!==e.getAttribute(t)||e.removeAttribute(t):(!i||4&r||c)&&!l&&e.setAttribute(t,o=!0===o?"":o)}else t="-"===t[2]?t.slice(3):K(l,a)?a.slice(2):a[2]+t.slice(3),n&&s.rel(e,t,n,!1),o&&s.ael(e,t,o,!1)}},w=/\s/,v=e=>e?e.split(w):[],g=(e,t,n,l)=>{const o=11===t.h.nodeType&&t.h.host?t.h.host:t.h,s=e&&e.u||u,c=t.u||u;for(l in s)l in c||b(o,l,s[l],void 0,n,t.t);for(l in c)b(o,l,s[l],c[l],n,t.t)},S=(t,n,l)=>{let s,c,r=n.p[l],i=0;if(null!==r.i)s=r.h=o.createTextNode(r.i);else if(s=r.h=o.createElement(r.$),g(null,r,!1),null!=e&&s["s-si"]!==e&&s.classList.add(s["s-si"]=e),r.p)for(i=0;i<r.p.length;++i)c=S(t,r,i),c&&s.appendChild(c);return s},j=(e,n,l,o,s,c)=>{let r,i=e;for(i.shadowRoot&&i.tagName===t&&(i=i.shadowRoot);s<=c;++s)o[s]&&(r=S(null,l,s),r&&(o[s].h=r,i.insertBefore(r,n)))},k=(e,t,n,l,o)=>{for(;t<=n;++t)(l=e[t])&&(o=l.h,O(l),o.remove())},C=(e,t)=>e.$===t.$,M=(e,t)=>{const n=t.h=e.h,l=e.p,o=t.p,s=t.i;null===s?("slot"===t.$||g(e,t,!1),null!==l&&null!==o?((e,t,n,l)=>{let o,s=0,c=0,r=t.length-1,i=t[0],a=t[r],u=l.length-1,f=l[0],d=l[u];for(;s<=r&&c<=u;)null==i?i=t[++s]:null==a?a=t[--r]:null==f?f=l[++c]:null==d?d=l[--u]:C(i,f)?(M(i,f),i=t[++s],f=l[++c]):C(a,d)?(M(a,d),a=t[--r],d=l[--u]):C(i,d)?(M(i,d),e.insertBefore(i.h,a.h.nextSibling),i=t[++s],d=l[--u]):C(a,f)?(M(a,f),e.insertBefore(a.h,i.h),a=t[--r],f=l[++c]):(o=S(t&&t[c],n,c),f=l[++c],o&&i.h.parentNode.insertBefore(o,i.h));s>r?j(e,null==l[u+1]?null:l[u+1].h,n,l,c,u):c>u&&k(t,s,r)})(n,l,t,o):null!==o?(null!==e.i&&(n.textContent=""),j(n,null,t,o,0,o.length-1)):null!==l&&k(l,0,l.length-1)):e.i!==s&&(n.data=s)},O=e=>{e.u&&e.u.ref&&e.u.ref(null),e.p&&e.p.map(O)},P=e=>G(e).g,x=(e,t,n)=>{const l=P(e);return{emit:e=>E(l,t,{bubbles:!!(4&n),composed:!!(2&n),cancelable:!!(1&n),detail:e})}},E=(e,t,n)=>{const l=s.ce(t,n);return e.dispatchEvent(l),l},L=(e,t)=>{t&&!e.S&&t["s-p"]&&t["s-p"].push(new Promise((t=>e.S=t)))},F=(e,t)=>{if(e.t|=16,!(4&e.t))return L(e,e.j),ce((()=>T(e,t)));e.t|=512},T=(e,t)=>{const n=e.k;let l;return t&&(l=U(n,"componentWillLoad")),q(l,(()=>W(e,n,t)))},W=async(e,t,n)=>{const l=e.g,s=l["s-rc"];n&&(e=>{const t=e.C,n=e.g,l=t.t,s=((e,t)=>{let n=a(t),l=Z.get(n);if(e=11===e.nodeType?e:o,l)if("string"==typeof l){let t,s=i.get(e=e.head||e);s||i.set(e,s=new Set),s.has(n)||(t=o.createElement("style"),t.innerHTML=l,e.insertBefore(t,e.querySelector("link")),s&&s.add(n))}else e.adoptedStyleSheets.includes(l)||(e.adoptedStyleSheets=[...e.adoptedStyleSheets,l]);return n})(n.shadowRoot?n.shadowRoot:n.getRootNode(),t);10&l&&(n["s-sc"]=s,n.classList.add(s+"-h"))})(e);A(e,t),s&&(s.map((e=>e())),l["s-rc"]=void 0);{const t=l["s-p"],n=()=>H(e);0===t.length?n():(Promise.all(t).then(n),e.t|=4,t.length=0)}},A=(n,l)=>{try{l=l.render(),n.t&=-17,n.t|=2,((n,l)=>{const o=n.g,s=n.M||y(null,null),c=(e=>e&&e.$===p)(l)?l:d(null,null,l);t=o.tagName,c.$=null,c.t|=4,n.M=c,c.h=s.h=o.shadowRoot||o,e=o["s-sc"],M(s,c)})(n,l)}catch(e){Q(e,n.g)}return null},H=e=>{const t=e.g,n=e.k,l=e.j;64&e.t||(e.t|=64,D(t),U(n,"componentDidLoad"),e.O(t),l||R()),e.P(t),e.S&&(e.S(),e.S=void 0),512&e.t&&se((()=>F(e,!1))),e.t&=-517},R=()=>{D(o.documentElement),se((()=>E(l,"appload",{detail:{namespace:"deckdeckgo-inline-editor"}})))},U=(e,t,n)=>{if(e&&e[t])try{return e[t](n)}catch(e){Q(e)}},q=(e,t)=>e&&e.then?e.then(t):t(),D=e=>e.classList.add("hydrated"),N=(e,t,n)=>{if(t.L){e.watchers&&(t.F=e.watchers);const l=Object.entries(t.L),o=e.prototype;if(l.map((([e,[l]])=>{31&l||2&n&&32&l?Object.defineProperty(o,e,{get(){return((e,t)=>G(this).T.get(t))(0,e)},set(n){((e,t,n,l)=>{const o=G(e),s=o.g,c=o.T.get(t),r=o.t,i=o.k;if(n=((e,t)=>null==e||f(e)?e:4&t?"false"!==e&&(""===e||!!e):2&t?parseFloat(e):1&t?e+"":e)(n,l.L[t][0]),!(8&r&&void 0!==c||n===c)&&(o.T.set(t,n),i)){if(l.F&&128&r){const e=l.F[t];e&&e.map((e=>{try{i[e](n,c,t)}catch(e){Q(e,s)}}))}2==(18&r)&&F(o,!1)}})(this,e,n,t)},configurable:!0,enumerable:!0}):1&n&&64&l&&Object.defineProperty(o,e,{value(...t){const n=G(this);return n.W.then((()=>n.k[e](...t)))}})})),1&n){const t=new Map;o.attributeChangedCallback=function(e,n,l){s.jmp((()=>{const n=t.get(e);this[n]=(null!==l||"boolean"!=typeof this[n])&&l}))},e.observedAttributes=l.filter((([e,t])=>15&t[0])).map((([e,n])=>{const l=n[1]||e;return t.set(l,e),l}))}}return e},V=e=>{U(e,"connectedCallback")},_=(e,t={})=>{const n=[],c=t.exclude||[],i=l.customElements,u=o.head,f=u.querySelector("meta[charset]"),d=o.createElement("style"),y=[];let p,$=!0;Object.assign(s,t),s.l=new URL(t.resourcesUrl||"./",o.baseURI).href,e.map((e=>e[1].map((t=>{const l={t:t[0],o:t[1],L:t[2],A:t[3]};l.L=t[2],l.F={};const o=l.o,u=class extends HTMLElement{constructor(e){super(e),J(e=this,l),1&l.t&&e.attachShadow({mode:"open"})}connectedCallback(){p&&(clearTimeout(p),p=null),$?y.push(this):s.jmp((()=>(e=>{if(0==(1&s.t)){const t=G(e),n=t.C,l=()=>{};if(1&t.t)V(t.k);else{t.t|=1;{let n=e;for(;n=n.parentNode||n.host;)if(n["s-p"]){L(t,t.j=n);break}}n.L&&Object.entries(n.L).map((([t,[n]])=>{if(31&n&&e.hasOwnProperty(t)){const n=e[t];delete e[t],e[t]=n}})),(async(e,t,n,l,o)=>{if(0==(32&t.t)){{if(t.t|=32,(o=Y(n)).then){const e=()=>{};o=await o,e()}o.isProxied||(n.F=o.watchers,N(o,n,2),o.isProxied=!0);const e=()=>{};t.t|=8;try{new o(t)}catch(e){Q(e)}t.t&=-9,t.t|=128,e(),V(t.k)}if(o.style){let e=o.style;const t=a(n);if(!Z.has(t)){const l=()=>{};((e,t,n)=>{let l=Z.get(e);r&&n?(l=l||new CSSStyleSheet,l.replace(t)):l=t,Z.set(e,l)})(t,e,!!(1&n.t)),l()}}}const s=t.j,c=()=>F(t,!0);s&&s["s-rc"]?s["s-rc"].push(c):c()})(0,t,n)}l()}})(this)))}disconnectedCallback(){s.jmp((()=>(()=>{0==(1&s.t)&&U(G(this).k,"disconnectedCallback")})()))}componentOnReady(){return G(this).H}};l.R=e[0],c.includes(o)||i.get(o)||(n.push(o),i.define(o,N(u,l,1)))})))),d.innerHTML=n+"{visibility:hidden}.hydrated{visibility:inherit}",d.setAttribute("data-styles",""),u.insertBefore(d,f?f.nextSibling:u.firstChild),$=!1,y.length?y.map((e=>e.connectedCallback())):s.jmp((()=>p=setTimeout(R,30)))},z=(e,t)=>t,B=new WeakMap,G=e=>B.get(e),I=(e,t)=>B.set(t.k=e,t),J=(e,t)=>{const n={t:0,g:e,C:t,T:new Map};return n.W=new Promise((e=>n.P=e)),n.H=new Promise((e=>n.O=e)),e["s-p"]=[],e["s-rc"]=[],B.set(e,n)},K=(e,t)=>t in e,Q=(e,t)=>(0,console.error)(e,t),X=new Map,Y=e=>{const t=e.o.replace(/-/g,"_"),n=e.R,l=X.get(n);return l?l[t]:import(`./${n}.entry.js`).then((e=>(X.set(n,e),e[t])),Q)},Z=new Map,ee=[],te=[],ne=(e,t)=>l=>{e.push(l),n||(n=!0,t&&4&s.t?se(oe):s.raf(oe))},le=e=>{for(let t=0;t<e.length;t++)try{e[t](performance.now())}catch(e){Q(e)}e.length=0},oe=()=>{le(ee),le(te),(n=ee.length>0)&&s.raf(oe)},se=e=>c().then(e),ce=ne(te,!0);export{z as F,p as H,_ as b,x as c,P as g,d as h,c as p,I as r} |
| const NAMESPACE = 'deckdeckgo-inline-editor'; | ||
| let scopeId; | ||
| let hostTagName; | ||
| let isSvgMode = false; | ||
| let queuePending = false; | ||
| const win = typeof window !== 'undefined' ? window : {}; | ||
| const doc = win.document || { head: {} }; | ||
| const plt = { | ||
| $flags$: 0, | ||
| $resourcesUrl$: '', | ||
| jmp: h => h(), | ||
| raf: h => requestAnimationFrame(h), | ||
| ael: (el, eventName, listener, opts) => el.addEventListener(eventName, listener, opts), | ||
| rel: (el, eventName, listener, opts) => el.removeEventListener(eventName, listener, opts), | ||
| ce: (eventName, opts) => new CustomEvent(eventName, opts), | ||
| }; | ||
| const promiseResolve = (v) => Promise.resolve(v); | ||
| const supportsConstructibleStylesheets = /*@__PURE__*/ (() => { | ||
| try { | ||
| new CSSStyleSheet(); | ||
| return typeof (new CSSStyleSheet()).replace === 'function'; | ||
| } | ||
| catch (e) { } | ||
| return false; | ||
| })() | ||
| ; | ||
| const HYDRATED_CSS = '{visibility:hidden}.hydrated{visibility:inherit}'; | ||
| const createTime = (fnName, tagName = '') => { | ||
| { | ||
| return () => { | ||
| return; | ||
| }; | ||
| } | ||
| }; | ||
| const uniqueTime = (key, measureText) => { | ||
| { | ||
| return () => { | ||
| return; | ||
| }; | ||
| } | ||
| }; | ||
| const rootAppliedStyles = new WeakMap(); | ||
| const registerStyle = (scopeId, cssText, allowCS) => { | ||
| let style = styles.get(scopeId); | ||
| if (supportsConstructibleStylesheets && allowCS) { | ||
| style = (style || new CSSStyleSheet()); | ||
| style.replace(cssText); | ||
| } | ||
| else { | ||
| style = cssText; | ||
| } | ||
| styles.set(scopeId, style); | ||
| }; | ||
| const addStyle = (styleContainerNode, cmpMeta, mode, hostElm) => { | ||
| let scopeId = getScopeId(cmpMeta); | ||
| let style = styles.get(scopeId); | ||
| // if an element is NOT connected then getRootNode() will return the wrong root node | ||
| // so the fallback is to always use the document for the root node in those cases | ||
| styleContainerNode = styleContainerNode.nodeType === 11 /* DocumentFragment */ ? styleContainerNode : doc; | ||
| if (style) { | ||
| if (typeof style === 'string') { | ||
| styleContainerNode = styleContainerNode.head || styleContainerNode; | ||
| let appliedStyles = rootAppliedStyles.get(styleContainerNode); | ||
| let styleElm; | ||
| if (!appliedStyles) { | ||
| rootAppliedStyles.set(styleContainerNode, (appliedStyles = new Set())); | ||
| } | ||
| if (!appliedStyles.has(scopeId)) { | ||
| { | ||
| { | ||
| styleElm = doc.createElement('style'); | ||
| styleElm.innerHTML = style; | ||
| } | ||
| styleContainerNode.insertBefore(styleElm, styleContainerNode.querySelector('link')); | ||
| } | ||
| if (appliedStyles) { | ||
| appliedStyles.add(scopeId); | ||
| } | ||
| } | ||
| } | ||
| else if (!styleContainerNode.adoptedStyleSheets.includes(style)) { | ||
| styleContainerNode.adoptedStyleSheets = [...styleContainerNode.adoptedStyleSheets, style]; | ||
| } | ||
| } | ||
| return scopeId; | ||
| }; | ||
| const attachStyles = (hostRef) => { | ||
| const cmpMeta = hostRef.$cmpMeta$; | ||
| const elm = hostRef.$hostElement$; | ||
| const flags = cmpMeta.$flags$; | ||
| const endAttachStyles = createTime('attachStyles', cmpMeta.$tagName$); | ||
| const scopeId = addStyle(elm.shadowRoot ? elm.shadowRoot : elm.getRootNode(), cmpMeta); | ||
| if (flags & 10 /* needsScopedEncapsulation */) { | ||
| // 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 | ||
| // DOM WRITE!! | ||
| elm['s-sc'] = scopeId; | ||
| elm.classList.add(scopeId + '-h'); | ||
| } | ||
| endAttachStyles(); | ||
| }; | ||
| const getScopeId = (cmp, mode) => 'sc-' + (cmp.$tagName$); | ||
| /** | ||
| * Default style mode id | ||
| */ | ||
| /** | ||
| * Reusable empty obj/array | ||
| * Don't add values to these!! | ||
| */ | ||
| const EMPTY_OBJ = {}; | ||
| const isDef = (v) => v != null; | ||
| const isComplexType = (o) => { | ||
| // https://jsperf.com/typeof-fn-object/5 | ||
| o = typeof o; | ||
| return o === 'object' || o === 'function'; | ||
| }; | ||
| /** | ||
| * Production h() function based on Preact by | ||
| * Jason Miller (@developit) | ||
| * Licensed under the MIT License | ||
| * https://github.com/developit/preact/blob/master/LICENSE | ||
| * | ||
| * Modified for Stencil's compiler and vdom | ||
| */ | ||
| // const stack: any[] = []; | ||
| // export function h(nodeName: string | d.FunctionalComponent, vnodeData: d.PropsType, child?: d.ChildType): d.VNode; | ||
| // export function h(nodeName: string | d.FunctionalComponent, vnodeData: d.PropsType, ...children: d.ChildType[]): d.VNode; | ||
| const h = (nodeName, vnodeData, ...children) => { | ||
| let child = null; | ||
| let simple = false; | ||
| let lastSimple = false; | ||
| let vNodeChildren = []; | ||
| const walk = (c) => { | ||
| for (let i = 0; i < c.length; i++) { | ||
| child = c[i]; | ||
| if (Array.isArray(child)) { | ||
| walk(child); | ||
| } | ||
| else if (child != null && typeof child !== 'boolean') { | ||
| if ((simple = typeof nodeName !== 'function' && !isComplexType(child))) { | ||
| child = String(child); | ||
| } | ||
| if (simple && lastSimple) { | ||
| // If the previous child was simple (string), we merge both | ||
| vNodeChildren[vNodeChildren.length - 1].$text$ += child; | ||
| } | ||
| else { | ||
| // Append a new vNode, if it's text, we create a text vNode | ||
| vNodeChildren.push(simple ? newVNode(null, child) : child); | ||
| } | ||
| lastSimple = simple; | ||
| } | ||
| } | ||
| }; | ||
| walk(children); | ||
| if (vnodeData) { | ||
| { | ||
| const classData = vnodeData.className || vnodeData.class; | ||
| if (classData) { | ||
| vnodeData.class = | ||
| typeof classData !== 'object' | ||
| ? classData | ||
| : Object.keys(classData) | ||
| .filter(k => classData[k]) | ||
| .join(' '); | ||
| } | ||
| } | ||
| } | ||
| if (typeof nodeName === 'function') { | ||
| // nodeName is a functional component | ||
| return nodeName(vnodeData === null ? {} : vnodeData, vNodeChildren, vdomFnUtils); | ||
| } | ||
| const vnode = newVNode(nodeName, null); | ||
| vnode.$attrs$ = vnodeData; | ||
| if (vNodeChildren.length > 0) { | ||
| vnode.$children$ = vNodeChildren; | ||
| } | ||
| return vnode; | ||
| }; | ||
| const newVNode = (tag, text) => { | ||
| const vnode = { | ||
| $flags$: 0, | ||
| $tag$: tag, | ||
| $text$: text, | ||
| $elm$: null, | ||
| $children$: null, | ||
| }; | ||
| { | ||
| vnode.$attrs$ = null; | ||
| } | ||
| return vnode; | ||
| }; | ||
| const Host = {}; | ||
| const isHost = (node) => node && node.$tag$ === Host; | ||
| const vdomFnUtils = { | ||
| forEach: (children, cb) => children.map(convertToPublic).forEach(cb), | ||
| map: (children, cb) => children.map(convertToPublic).map(cb).map(convertToPrivate), | ||
| }; | ||
| const convertToPublic = (node) => ({ | ||
| vattrs: node.$attrs$, | ||
| vchildren: node.$children$, | ||
| vkey: node.$key$, | ||
| vname: node.$name$, | ||
| vtag: node.$tag$, | ||
| vtext: node.$text$, | ||
| }); | ||
| const convertToPrivate = (node) => { | ||
| if (typeof node.vtag === 'function') { | ||
| const vnodeData = Object.assign({}, node.vattrs); | ||
| if (node.vkey) { | ||
| vnodeData.key = node.vkey; | ||
| } | ||
| if (node.vname) { | ||
| vnodeData.name = node.vname; | ||
| } | ||
| return h(node.vtag, vnodeData, ...(node.vchildren || [])); | ||
| } | ||
| const vnode = newVNode(node.vtag, node.vtext); | ||
| vnode.$attrs$ = node.vattrs; | ||
| vnode.$children$ = node.vchildren; | ||
| vnode.$key$ = node.vkey; | ||
| vnode.$name$ = node.vname; | ||
| return vnode; | ||
| }; | ||
| /** | ||
| * Production setAccessor() function based on Preact by | ||
| * Jason Miller (@developit) | ||
| * Licensed under the MIT License | ||
| * https://github.com/developit/preact/blob/master/LICENSE | ||
| * | ||
| * Modified for Stencil's compiler and vdom | ||
| */ | ||
| const setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags) => { | ||
| if (oldValue !== newValue) { | ||
| let isProp = isMemberInElement(elm, memberName); | ||
| let ln = memberName.toLowerCase(); | ||
| if (memberName === 'class') { | ||
| const classList = elm.classList; | ||
| const oldClasses = parseClassList(oldValue); | ||
| const newClasses = parseClassList(newValue); | ||
| classList.remove(...oldClasses.filter(c => c && !newClasses.includes(c))); | ||
| classList.add(...newClasses.filter(c => c && !oldClasses.includes(c))); | ||
| } | ||
| else if (memberName === 'style') { | ||
| // update style attribute, css properties and values | ||
| { | ||
| for (const prop in oldValue) { | ||
| if (!newValue || newValue[prop] == null) { | ||
| if (prop.includes('-')) { | ||
| elm.style.removeProperty(prop); | ||
| } | ||
| else { | ||
| elm.style[prop] = ''; | ||
| } | ||
| } | ||
| } | ||
| } | ||
| for (const prop in newValue) { | ||
| if (!oldValue || newValue[prop] !== oldValue[prop]) { | ||
| if (prop.includes('-')) { | ||
| elm.style.setProperty(prop, newValue[prop]); | ||
| } | ||
| else { | ||
| elm.style[prop] = newValue[prop]; | ||
| } | ||
| } | ||
| } | ||
| } | ||
| else if (memberName === 'ref') { | ||
| // minifier will clean this up | ||
| if (newValue) { | ||
| newValue(elm); | ||
| } | ||
| } | ||
| else if ((!isProp ) && memberName[0] === 'o' && memberName[1] === 'n') { | ||
| // Event Handlers | ||
| // so if the member name starts with "on" and the 3rd characters is | ||
| // a capital letter, and it's not already a member on the element, | ||
| // then we're assuming it's an event listener | ||
| if (memberName[2] === '-') { | ||
| // on- prefixed events | ||
| // allows to be explicit about the dom event to listen without any magic | ||
| // under the hood: | ||
| // <my-cmp on-click> // listens for "click" | ||
| // <my-cmp on-Click> // listens for "Click" | ||
| // <my-cmp on-ionChange> // listens for "ionChange" | ||
| // <my-cmp on-EVENTS> // listens for "EVENTS" | ||
| memberName = memberName.slice(3); | ||
| } | ||
| else if (isMemberInElement(win, ln)) { | ||
| // standard event | ||
| // the JSX attribute could have been "onMouseOver" and the | ||
| // member name "onmouseover" is on the window's prototype | ||
| // so let's add the listener "mouseover", which is all lowercased | ||
| memberName = ln.slice(2); | ||
| } | ||
| else { | ||
| // custom event | ||
| // the JSX attribute could have been "onMyCustomEvent" | ||
| // so let's trim off the "on" prefix and lowercase the first character | ||
| // and add the listener "myCustomEvent" | ||
| // except for the first character, we keep the event name case | ||
| memberName = ln[2] + memberName.slice(3); | ||
| } | ||
| if (oldValue) { | ||
| plt.rel(elm, memberName, oldValue, false); | ||
| } | ||
| if (newValue) { | ||
| plt.ael(elm, memberName, newValue, false); | ||
| } | ||
| } | ||
| else { | ||
| // Set property if it exists and it's not a SVG | ||
| const isComplex = isComplexType(newValue); | ||
| if ((isProp || (isComplex && newValue !== null)) && !isSvg) { | ||
| try { | ||
| if (!elm.tagName.includes('-')) { | ||
| let n = newValue == null ? '' : newValue; | ||
| // Workaround for Safari, moving the <input> caret when re-assigning the same valued | ||
| if (memberName === 'list') { | ||
| isProp = false; | ||
| // tslint:disable-next-line: triple-equals | ||
| } | ||
| else if (oldValue == null || elm[memberName] != n) { | ||
| elm[memberName] = n; | ||
| } | ||
| } | ||
| else { | ||
| elm[memberName] = newValue; | ||
| } | ||
| } | ||
| catch (e) { } | ||
| } | ||
| if (newValue == null || newValue === false) { | ||
| if (newValue !== false || elm.getAttribute(memberName) === '') { | ||
| { | ||
| elm.removeAttribute(memberName); | ||
| } | ||
| } | ||
| } | ||
| else if ((!isProp || flags & 4 /* isHost */ || isSvg) && !isComplex) { | ||
| newValue = newValue === true ? '' : newValue; | ||
| { | ||
| elm.setAttribute(memberName, newValue); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| }; | ||
| const parseClassListRegex = /\s/; | ||
| const parseClassList = (value) => (!value ? [] : value.split(parseClassListRegex)); | ||
| const updateElement = (oldVnode, newVnode, isSvgMode, memberName) => { | ||
| // if the element passed in is a shadow root, which is a document fragment | ||
| // then we want to be adding attrs/props to the shadow root's "host" element | ||
| // if it's not a shadow root, then we add attrs/props to the same element | ||
| const elm = newVnode.$elm$.nodeType === 11 /* DocumentFragment */ && newVnode.$elm$.host ? newVnode.$elm$.host : newVnode.$elm$; | ||
| const oldVnodeAttrs = (oldVnode && oldVnode.$attrs$) || EMPTY_OBJ; | ||
| const newVnodeAttrs = newVnode.$attrs$ || EMPTY_OBJ; | ||
| { | ||
| // remove attributes no longer present on the vnode by setting them to undefined | ||
| for (memberName in oldVnodeAttrs) { | ||
| if (!(memberName in newVnodeAttrs)) { | ||
| setAccessor(elm, memberName, oldVnodeAttrs[memberName], undefined, isSvgMode, newVnode.$flags$); | ||
| } | ||
| } | ||
| } | ||
| // add new & update changed attributes | ||
| for (memberName in newVnodeAttrs) { | ||
| setAccessor(elm, memberName, oldVnodeAttrs[memberName], newVnodeAttrs[memberName], isSvgMode, newVnode.$flags$); | ||
| } | ||
| }; | ||
| const createElm = (oldParentVNode, newParentVNode, childIndex, parentElm) => { | ||
| // tslint:disable-next-line: prefer-const | ||
| let newVNode = newParentVNode.$children$[childIndex]; | ||
| 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. | ||
| { | ||
| updateElement(null, newVNode, isSvgMode); | ||
| } | ||
| if (isDef(scopeId) && elm['s-si'] !== scopeId) { | ||
| // if there is a scopeId and this is the initial render | ||
| // then let's add the scopeId as a css class | ||
| elm.classList.add((elm['s-si'] = scopeId)); | ||
| } | ||
| if (newVNode.$children$) { | ||
| for (i = 0; i < newVNode.$children$.length; ++i) { | ||
| // create the node | ||
| childNode = createElm(oldParentVNode, newVNode, i); | ||
| // return node could have been null | ||
| if (childNode) { | ||
| // append our new node | ||
| elm.appendChild(childNode); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| return elm; | ||
| }; | ||
| const addVnodes = (parentElm, before, parentVNode, vnodes, startIdx, endIdx) => { | ||
| 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); | ||
| if (childNode) { | ||
| vnodes[startIdx].$elm$ = childNode; | ||
| containerElm.insertBefore(childNode, before); | ||
| } | ||
| } | ||
| } | ||
| }; | ||
| const removeVnodes = (vnodes, startIdx, endIdx, vnode, elm) => { | ||
| for (; startIdx <= endIdx; ++startIdx) { | ||
| if ((vnode = vnodes[startIdx])) { | ||
| elm = vnode.$elm$; | ||
| callNodeRefs(vnode); | ||
| // remove the vnode's element from the dom | ||
| elm.remove(); | ||
| } | ||
| } | ||
| }; | ||
| const updateChildren = (parentElm, oldCh, newVNode, newCh) => { | ||
| let oldStartIdx = 0; | ||
| let newStartIdx = 0; | ||
| let oldEndIdx = oldCh.length - 1; | ||
| let oldStartVnode = oldCh[0]; | ||
| let oldEndVnode = oldCh[oldEndIdx]; | ||
| let newEndIdx = newCh.length - 1; | ||
| let newStartVnode = newCh[0]; | ||
| let newEndVnode = newCh[newEndIdx]; | ||
| let node; | ||
| while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) { | ||
| if (oldStartVnode == null) { | ||
| // Vnode might have been moved left | ||
| oldStartVnode = oldCh[++oldStartIdx]; | ||
| } | ||
| else if (oldEndVnode == null) { | ||
| oldEndVnode = oldCh[--oldEndIdx]; | ||
| } | ||
| else if (newStartVnode == null) { | ||
| newStartVnode = newCh[++newStartIdx]; | ||
| } | ||
| else if (newEndVnode == null) { | ||
| newEndVnode = newCh[--newEndIdx]; | ||
| } | ||
| else if (isSameVnode(oldStartVnode, newStartVnode)) { | ||
| patch(oldStartVnode, newStartVnode); | ||
| oldStartVnode = oldCh[++oldStartIdx]; | ||
| newStartVnode = newCh[++newStartIdx]; | ||
| } | ||
| else if (isSameVnode(oldEndVnode, newEndVnode)) { | ||
| patch(oldEndVnode, newEndVnode); | ||
| oldEndVnode = oldCh[--oldEndIdx]; | ||
| newEndVnode = newCh[--newEndIdx]; | ||
| } | ||
| else if (isSameVnode(oldStartVnode, newEndVnode)) { | ||
| patch(oldStartVnode, newEndVnode); | ||
| parentElm.insertBefore(oldStartVnode.$elm$, oldEndVnode.$elm$.nextSibling); | ||
| oldStartVnode = oldCh[++oldStartIdx]; | ||
| newEndVnode = newCh[--newEndIdx]; | ||
| } | ||
| else if (isSameVnode(oldEndVnode, newStartVnode)) { | ||
| patch(oldEndVnode, newStartVnode); | ||
| parentElm.insertBefore(oldEndVnode.$elm$, oldStartVnode.$elm$); | ||
| oldEndVnode = oldCh[--oldEndIdx]; | ||
| newStartVnode = newCh[++newStartIdx]; | ||
| } | ||
| else { | ||
| { | ||
| // new element | ||
| node = createElm(oldCh && oldCh[newStartIdx], newVNode, newStartIdx); | ||
| newStartVnode = newCh[++newStartIdx]; | ||
| } | ||
| if (node) { | ||
| { | ||
| oldStartVnode.$elm$.parentNode.insertBefore(node, oldStartVnode.$elm$); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| if (oldStartIdx > oldEndIdx) { | ||
| addVnodes(parentElm, newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].$elm$, newVNode, newCh, newStartIdx, newEndIdx); | ||
| } | ||
| else if (newStartIdx > newEndIdx) { | ||
| removeVnodes(oldCh, oldStartIdx, oldEndIdx); | ||
| } | ||
| }; | ||
| 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$) { | ||
| return true; | ||
| } | ||
| return false; | ||
| }; | ||
| 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$; | ||
| if (text === null) { | ||
| // element node | ||
| { | ||
| if (tag === 'slot') | ||
| ; | ||
| else { | ||
| // either this is the first render of an element OR it's an update | ||
| // AND we already know it's possible it could have changed | ||
| // this updates the element's css classes, attrs, props, listeners, etc. | ||
| updateElement(oldVNode, newVNode, isSvgMode); | ||
| } | ||
| } | ||
| if (oldChildren !== null && newChildren !== null) { | ||
| // looks like there's child vnodes for both the old and new vnodes | ||
| 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); | ||
| } | ||
| else if (oldChildren !== null) { | ||
| // no new child vnodes, but there are old child vnodes to remove | ||
| 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; | ||
| } | ||
| }; | ||
| const callNodeRefs = (vNode) => { | ||
| { | ||
| vNode.$attrs$ && vNode.$attrs$.ref && vNode.$attrs$.ref(null); | ||
| vNode.$children$ && vNode.$children$.map(callNodeRefs); | ||
| } | ||
| }; | ||
| const renderVdom = (hostRef, renderFnResults) => { | ||
| const hostElm = hostRef.$hostElement$; | ||
| const oldVNode = hostRef.$vnode$ || newVNode(null, null); | ||
| const rootVnode = isHost(renderFnResults) ? renderFnResults : h(null, null, renderFnResults); | ||
| hostTagName = hostElm.tagName; | ||
| rootVnode.$tag$ = null; | ||
| rootVnode.$flags$ |= 4 /* isHost */; | ||
| hostRef.$vnode$ = rootVnode; | ||
| rootVnode.$elm$ = oldVNode.$elm$ = (hostElm.shadowRoot || hostElm ); | ||
| { | ||
| scopeId = hostElm['s-sc']; | ||
| } | ||
| // synchronous patch | ||
| patch(oldVNode, rootVnode); | ||
| }; | ||
| const getElement = (ref) => (getHostRef(ref).$hostElement$ ); | ||
| const createEvent = (ref, name, flags) => { | ||
| const elm = getElement(ref); | ||
| return { | ||
| emit: (detail) => { | ||
| return emitEvent(elm, name, { | ||
| bubbles: !!(flags & 4 /* Bubbles */), | ||
| composed: !!(flags & 2 /* Composed */), | ||
| cancelable: !!(flags & 1 /* Cancellable */), | ||
| detail, | ||
| }); | ||
| }, | ||
| }; | ||
| }; | ||
| const emitEvent = (elm, name, opts) => { | ||
| const ev = plt.ce(name, opts); | ||
| elm.dispatchEvent(ev); | ||
| return ev; | ||
| }; | ||
| const attachToAncestor = (hostRef, ancestorComponent) => { | ||
| if (ancestorComponent && !hostRef.$onRenderResolve$ && ancestorComponent['s-p']) { | ||
| ancestorComponent['s-p'].push(new Promise(r => (hostRef.$onRenderResolve$ = r))); | ||
| } | ||
| }; | ||
| const scheduleUpdate = (hostRef, isInitialLoad) => { | ||
| { | ||
| hostRef.$flags$ |= 16 /* isQueuedForUpdate */; | ||
| } | ||
| if (hostRef.$flags$ & 4 /* isWaitingForChildren */) { | ||
| hostRef.$flags$ |= 512 /* needsRerender */; | ||
| return; | ||
| } | ||
| attachToAncestor(hostRef, hostRef.$ancestorComponent$); | ||
| // there is no ancestor component or the ancestor component | ||
| // has already fired off its lifecycle update then | ||
| // fire off the initial update | ||
| const dispatch = () => dispatchHooks(hostRef, isInitialLoad); | ||
| return writeTask(dispatch) ; | ||
| }; | ||
| const dispatchHooks = (hostRef, isInitialLoad) => { | ||
| const endSchedule = createTime('scheduleUpdate', hostRef.$cmpMeta$.$tagName$); | ||
| const instance = hostRef.$lazyInstance$ ; | ||
| let promise; | ||
| if (isInitialLoad) { | ||
| { | ||
| promise = safeCall(instance, 'componentWillLoad'); | ||
| } | ||
| } | ||
| endSchedule(); | ||
| return then(promise, () => updateComponent(hostRef, instance, isInitialLoad)); | ||
| }; | ||
| const updateComponent = async (hostRef, instance, isInitialLoad) => { | ||
| // updateComponent | ||
| const elm = hostRef.$hostElement$; | ||
| const endUpdate = createTime('update', hostRef.$cmpMeta$.$tagName$); | ||
| const rc = elm['s-rc']; | ||
| if (isInitialLoad) { | ||
| // DOM WRITE! | ||
| attachStyles(hostRef); | ||
| } | ||
| const endRender = createTime('render', hostRef.$cmpMeta$.$tagName$); | ||
| { | ||
| callRender(hostRef, instance); | ||
| } | ||
| if (rc) { | ||
| // ok, so turns out there are some child host elements | ||
| // waiting on this parent element to load | ||
| // let's fire off all update callbacks waiting | ||
| rc.map(cb => cb()); | ||
| elm['s-rc'] = undefined; | ||
| } | ||
| endRender(); | ||
| endUpdate(); | ||
| { | ||
| const childrenPromises = elm['s-p']; | ||
| const postUpdate = () => postUpdateComponent(hostRef); | ||
| if (childrenPromises.length === 0) { | ||
| postUpdate(); | ||
| } | ||
| else { | ||
| Promise.all(childrenPromises).then(postUpdate); | ||
| hostRef.$flags$ |= 4 /* isWaitingForChildren */; | ||
| childrenPromises.length = 0; | ||
| } | ||
| } | ||
| }; | ||
| const callRender = (hostRef, instance, elm) => { | ||
| try { | ||
| instance = instance.render() ; | ||
| { | ||
| hostRef.$flags$ &= ~16 /* isQueuedForUpdate */; | ||
| } | ||
| { | ||
| hostRef.$flags$ |= 2 /* hasRendered */; | ||
| } | ||
| { | ||
| { | ||
| // looks like we've got child nodes to render into this host element | ||
| // or we need to update the css class/attrs on the host element | ||
| // DOM WRITE! | ||
| { | ||
| renderVdom(hostRef, instance); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| catch (e) { | ||
| consoleError(e, hostRef.$hostElement$); | ||
| } | ||
| return null; | ||
| }; | ||
| const postUpdateComponent = (hostRef) => { | ||
| const tagName = hostRef.$cmpMeta$.$tagName$; | ||
| const elm = hostRef.$hostElement$; | ||
| const endPostUpdate = createTime('postUpdate', tagName); | ||
| const instance = hostRef.$lazyInstance$ ; | ||
| const ancestorComponent = hostRef.$ancestorComponent$; | ||
| if (!(hostRef.$flags$ & 64 /* hasLoadedComponent */)) { | ||
| hostRef.$flags$ |= 64 /* hasLoadedComponent */; | ||
| { | ||
| // DOM WRITE! | ||
| addHydratedFlag(elm); | ||
| } | ||
| { | ||
| safeCall(instance, 'componentDidLoad'); | ||
| } | ||
| endPostUpdate(); | ||
| { | ||
| hostRef.$onReadyResolve$(elm); | ||
| if (!ancestorComponent) { | ||
| appDidLoad(); | ||
| } | ||
| } | ||
| } | ||
| else { | ||
| endPostUpdate(); | ||
| } | ||
| { | ||
| hostRef.$onInstanceResolve$(elm); | ||
| } | ||
| // load events fire from bottom to top | ||
| // the deepest elements load first then bubbles up | ||
| { | ||
| if (hostRef.$onRenderResolve$) { | ||
| hostRef.$onRenderResolve$(); | ||
| hostRef.$onRenderResolve$ = undefined; | ||
| } | ||
| if (hostRef.$flags$ & 512 /* needsRerender */) { | ||
| nextTick(() => scheduleUpdate(hostRef, false)); | ||
| } | ||
| hostRef.$flags$ &= ~(4 /* isWaitingForChildren */ | 512 /* needsRerender */); | ||
| } | ||
| // ( •_•) | ||
| // ( •_•)>⌐■-■ | ||
| // (⌐■_■) | ||
| }; | ||
| const appDidLoad = (who) => { | ||
| // on appload | ||
| // we have finish the first big initial render | ||
| { | ||
| addHydratedFlag(doc.documentElement); | ||
| } | ||
| nextTick(() => emitEvent(win, 'appload', { detail: { namespace: NAMESPACE } })); | ||
| }; | ||
| const safeCall = (instance, method, arg) => { | ||
| if (instance && instance[method]) { | ||
| try { | ||
| return instance[method](arg); | ||
| } | ||
| catch (e) { | ||
| consoleError(e); | ||
| } | ||
| } | ||
| return undefined; | ||
| }; | ||
| const then = (promise, thenFn) => { | ||
| return promise && promise.then ? promise.then(thenFn) : thenFn(); | ||
| }; | ||
| const addHydratedFlag = (elm) => (elm.classList.add('hydrated') ); | ||
| const parsePropertyValue = (propValue, propType) => { | ||
| // ensure this value is of the correct prop type | ||
| if (propValue != null && !isComplexType(propValue)) { | ||
| if (propType & 4 /* Boolean */) { | ||
| // per the HTML spec, any string value means it is a boolean true value | ||
| // but we'll cheat here and say that the string "false" is the boolean false | ||
| return propValue === 'false' ? false : propValue === '' || !!propValue; | ||
| } | ||
| if (propType & 2 /* Number */) { | ||
| // force it to be a number | ||
| return parseFloat(propValue); | ||
| } | ||
| if (propType & 1 /* String */) { | ||
| // could have been passed as a number or boolean | ||
| // but we still want it as a string | ||
| return String(propValue); | ||
| } | ||
| // redundant return here for better minification | ||
| return propValue; | ||
| } | ||
| // not sure exactly what type we want | ||
| // so no need to change to a different type | ||
| return propValue; | ||
| }; | ||
| const getValue = (ref, propName) => getHostRef(ref).$instanceValues$.get(propName); | ||
| const setValue = (ref, propName, newVal, cmpMeta) => { | ||
| // check our new property value against our internal value | ||
| const hostRef = getHostRef(ref); | ||
| const elm = hostRef.$hostElement$ ; | ||
| const oldVal = hostRef.$instanceValues$.get(propName); | ||
| const flags = hostRef.$flags$; | ||
| const instance = hostRef.$lazyInstance$ ; | ||
| newVal = parsePropertyValue(newVal, cmpMeta.$members$[propName][0]); | ||
| if ((!(flags & 8 /* isConstructingInstance */) || oldVal === undefined) && newVal !== oldVal) { | ||
| // gadzooks! the property's value has changed!! | ||
| // set our new value! | ||
| hostRef.$instanceValues$.set(propName, newVal); | ||
| if (instance) { | ||
| // get an array of method names of watch functions to call | ||
| if (cmpMeta.$watchers$ && flags & 128 /* isWatchReady */) { | ||
| const watchMethods = cmpMeta.$watchers$[propName]; | ||
| if (watchMethods) { | ||
| // this instance is watching for when this property changed | ||
| watchMethods.map(watchMethodName => { | ||
| try { | ||
| // fire off each of the watch methods that are watching this property | ||
| instance[watchMethodName](newVal, oldVal, propName); | ||
| } | ||
| catch (e) { | ||
| consoleError(e, elm); | ||
| } | ||
| }); | ||
| } | ||
| } | ||
| if ((flags & (2 /* hasRendered */ | 16 /* isQueuedForUpdate */)) === 2 /* hasRendered */) { | ||
| // looks like this value actually changed, so we've got work to do! | ||
| // but only if we've already rendered, otherwise just chill out | ||
| // queue that we need to do an update, but don't worry about queuing | ||
| // up millions cuz this function ensures it only runs once | ||
| scheduleUpdate(hostRef, false); | ||
| } | ||
| } | ||
| } | ||
| }; | ||
| const proxyComponent = (Cstr, cmpMeta, flags) => { | ||
| if (cmpMeta.$members$) { | ||
| if (Cstr.watchers) { | ||
| cmpMeta.$watchers$ = Cstr.watchers; | ||
| } | ||
| // It's better to have a const than two Object.entries() | ||
| const members = Object.entries(cmpMeta.$members$); | ||
| const prototype = Cstr.prototype; | ||
| members.map(([memberName, [memberFlags]]) => { | ||
| if ((memberFlags & 31 /* Prop */ || ((flags & 2 /* proxyState */) && memberFlags & 32 /* State */))) { | ||
| // proxyComponent - prop | ||
| Object.defineProperty(prototype, memberName, { | ||
| get() { | ||
| // proxyComponent, get value | ||
| return getValue(this, memberName); | ||
| }, | ||
| set(newValue) { | ||
| // proxyComponent, set value | ||
| setValue(this, memberName, newValue, cmpMeta); | ||
| }, | ||
| configurable: true, | ||
| enumerable: true, | ||
| }); | ||
| } | ||
| else if (flags & 1 /* isElementConstructor */ && memberFlags & 64 /* Method */) { | ||
| // proxyComponent - method | ||
| Object.defineProperty(prototype, memberName, { | ||
| value(...args) { | ||
| const ref = getHostRef(this); | ||
| return ref.$onInstancePromise$.then(() => ref.$lazyInstance$[memberName](...args)); | ||
| }, | ||
| }); | ||
| } | ||
| }); | ||
| if ((flags & 1 /* isElementConstructor */)) { | ||
| const attrNameToPropName = new Map(); | ||
| prototype.attributeChangedCallback = function (attrName, _oldValue, newValue) { | ||
| plt.jmp(() => { | ||
| const propName = attrNameToPropName.get(attrName); | ||
| this[propName] = newValue === null && typeof this[propName] === 'boolean' ? false : newValue; | ||
| }); | ||
| }; | ||
| // create an array of attributes to observe | ||
| // and also create a map of html attribute name to js property name | ||
| Cstr.observedAttributes = members | ||
| .filter(([_, m]) => m[0] & 15 /* HasAttribute */) // filter to only keep props that should match attributes | ||
| .map(([propName, m]) => { | ||
| const attrName = m[1] || propName; | ||
| attrNameToPropName.set(attrName, propName); | ||
| return attrName; | ||
| }); | ||
| } | ||
| } | ||
| return Cstr; | ||
| }; | ||
| const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId, Cstr) => { | ||
| // initializeComponent | ||
| if ((hostRef.$flags$ & 32 /* hasInitializedComponent */) === 0) { | ||
| { | ||
| // we haven't initialized this element yet | ||
| hostRef.$flags$ |= 32 /* hasInitializedComponent */; | ||
| // lazy loaded components | ||
| // request the component's implementation to be | ||
| // wired up with the host element | ||
| Cstr = loadModule(cmpMeta); | ||
| if (Cstr.then) { | ||
| // Await creates a micro-task avoid if possible | ||
| const endLoad = uniqueTime(); | ||
| Cstr = await Cstr; | ||
| endLoad(); | ||
| } | ||
| if (!Cstr.isProxied) { | ||
| // we'eve never proxied this Constructor before | ||
| // let's add the getters/setters to its prototype before | ||
| // the first time we create an instance of the implementation | ||
| { | ||
| cmpMeta.$watchers$ = Cstr.watchers; | ||
| } | ||
| proxyComponent(Cstr, cmpMeta, 2 /* proxyState */); | ||
| Cstr.isProxied = true; | ||
| } | ||
| const endNewInstance = createTime('createInstance', cmpMeta.$tagName$); | ||
| // ok, time to construct the instance | ||
| // but let's keep track of when we start and stop | ||
| // so that the getters/setters don't incorrectly step on data | ||
| { | ||
| hostRef.$flags$ |= 8 /* isConstructingInstance */; | ||
| } | ||
| // construct the lazy-loaded component implementation | ||
| // passing the hostRef is very important during | ||
| // construction in order to directly wire together the | ||
| // host element and the lazy-loaded instance | ||
| try { | ||
| new Cstr(hostRef); | ||
| } | ||
| catch (e) { | ||
| consoleError(e); | ||
| } | ||
| { | ||
| hostRef.$flags$ &= ~8 /* isConstructingInstance */; | ||
| } | ||
| { | ||
| hostRef.$flags$ |= 128 /* isWatchReady */; | ||
| } | ||
| endNewInstance(); | ||
| fireConnectedCallback(hostRef.$lazyInstance$); | ||
| } | ||
| if (Cstr.style) { | ||
| // this component has styles but we haven't registered them yet | ||
| let style = Cstr.style; | ||
| const scopeId = getScopeId(cmpMeta); | ||
| if (!styles.has(scopeId)) { | ||
| const endRegisterStyles = createTime('registerStyles', cmpMeta.$tagName$); | ||
| registerStyle(scopeId, style, !!(cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */)); | ||
| endRegisterStyles(); | ||
| } | ||
| } | ||
| } | ||
| // we've successfully created a lazy instance | ||
| const ancestorComponent = hostRef.$ancestorComponent$; | ||
| const schedule = () => scheduleUpdate(hostRef, true); | ||
| if (ancestorComponent && ancestorComponent['s-rc']) { | ||
| // this is the intial load and this component it has an ancestor component | ||
| // but the ancestor component has NOT fired its will update lifecycle yet | ||
| // so let's just cool our jets and wait for the ancestor to continue first | ||
| // this will get fired off when the ancestor component | ||
| // finally gets around to rendering its lazy self | ||
| // fire off the initial update | ||
| ancestorComponent['s-rc'].push(schedule); | ||
| } | ||
| else { | ||
| schedule(); | ||
| } | ||
| }; | ||
| const fireConnectedCallback = (instance) => { | ||
| { | ||
| safeCall(instance, 'connectedCallback'); | ||
| } | ||
| }; | ||
| const connectedCallback = (elm) => { | ||
| if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0) { | ||
| const hostRef = getHostRef(elm); | ||
| const cmpMeta = hostRef.$cmpMeta$; | ||
| const endConnected = createTime('connectedCallback', cmpMeta.$tagName$); | ||
| if (!(hostRef.$flags$ & 1 /* hasConnected */)) { | ||
| // first time this component has connected | ||
| hostRef.$flags$ |= 1 /* hasConnected */; | ||
| { | ||
| // find the first ancestor component (if there is one) and register | ||
| // this component as one of the actively loading child components for its ancestor | ||
| let ancestorComponent = elm; | ||
| while ((ancestorComponent = ancestorComponent.parentNode || ancestorComponent.host)) { | ||
| // climb up the ancestors looking for the first | ||
| // component that hasn't finished its lifecycle update yet | ||
| if (ancestorComponent['s-p']) { | ||
| // we found this components first ancestor component | ||
| // keep a reference to this component's ancestor component | ||
| attachToAncestor(hostRef, (hostRef.$ancestorComponent$ = ancestorComponent)); | ||
| break; | ||
| } | ||
| } | ||
| } | ||
| // Lazy properties | ||
| // https://developers.google.com/web/fundamentals/web-components/best-practices#lazy-properties | ||
| if (cmpMeta.$members$) { | ||
| Object.entries(cmpMeta.$members$).map(([memberName, [memberFlags]]) => { | ||
| if (memberFlags & 31 /* Prop */ && elm.hasOwnProperty(memberName)) { | ||
| const value = elm[memberName]; | ||
| delete elm[memberName]; | ||
| elm[memberName] = value; | ||
| } | ||
| }); | ||
| } | ||
| { | ||
| initializeComponent(elm, hostRef, cmpMeta); | ||
| } | ||
| } | ||
| else { | ||
| // fire off connectedCallback() on component instance | ||
| fireConnectedCallback(hostRef.$lazyInstance$); | ||
| } | ||
| endConnected(); | ||
| } | ||
| }; | ||
| const disconnectedCallback = (elm) => { | ||
| if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0) { | ||
| const hostRef = getHostRef(elm); | ||
| const instance = hostRef.$lazyInstance$ ; | ||
| { | ||
| safeCall(instance, 'disconnectedCallback'); | ||
| } | ||
| } | ||
| }; | ||
| const bootstrapLazy = (lazyBundles, options = {}) => { | ||
| const endBootstrap = createTime(); | ||
| const cmpTags = []; | ||
| const exclude = options.exclude || []; | ||
| const customElements = win.customElements; | ||
| const head = doc.head; | ||
| const metaCharset = /*@__PURE__*/ head.querySelector('meta[charset]'); | ||
| const visibilityStyle = /*@__PURE__*/ doc.createElement('style'); | ||
| const deferredConnectedCallbacks = []; | ||
| let appLoadFallback; | ||
| let isBootstrapping = true; | ||
| Object.assign(plt, options); | ||
| plt.$resourcesUrl$ = new URL(options.resourcesUrl || './', doc.baseURI).href; | ||
| lazyBundles.map(lazyBundle => lazyBundle[1].map(compactMeta => { | ||
| const cmpMeta = { | ||
| $flags$: compactMeta[0], | ||
| $tagName$: compactMeta[1], | ||
| $members$: compactMeta[2], | ||
| $listeners$: compactMeta[3], | ||
| }; | ||
| { | ||
| cmpMeta.$members$ = compactMeta[2]; | ||
| } | ||
| { | ||
| cmpMeta.$watchers$ = {}; | ||
| } | ||
| const tagName = cmpMeta.$tagName$; | ||
| const HostElement = class extends HTMLElement { | ||
| // StencilLazyHost | ||
| constructor(self) { | ||
| // @ts-ignore | ||
| super(self); | ||
| self = this; | ||
| registerHost(self, cmpMeta); | ||
| if (cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) { | ||
| // this component is using shadow dom | ||
| // and this browser supports shadow dom | ||
| // add the read-only property "shadowRoot" to the host element | ||
| // adding the shadow root build conditionals to minimize runtime | ||
| { | ||
| { | ||
| self.attachShadow({ mode: 'open' }); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| connectedCallback() { | ||
| if (appLoadFallback) { | ||
| clearTimeout(appLoadFallback); | ||
| appLoadFallback = null; | ||
| } | ||
| if (isBootstrapping) { | ||
| // connectedCallback will be processed once all components have been registered | ||
| deferredConnectedCallbacks.push(this); | ||
| } | ||
| else { | ||
| plt.jmp(() => connectedCallback(this)); | ||
| } | ||
| } | ||
| disconnectedCallback() { | ||
| plt.jmp(() => disconnectedCallback(this)); | ||
| } | ||
| componentOnReady() { | ||
| return getHostRef(this).$onReadyPromise$; | ||
| } | ||
| }; | ||
| cmpMeta.$lazyBundleId$ = lazyBundle[0]; | ||
| if (!exclude.includes(tagName) && !customElements.get(tagName)) { | ||
| cmpTags.push(tagName); | ||
| customElements.define(tagName, proxyComponent(HostElement, cmpMeta, 1 /* isElementConstructor */)); | ||
| } | ||
| })); | ||
| { | ||
| visibilityStyle.innerHTML = cmpTags + HYDRATED_CSS; | ||
| visibilityStyle.setAttribute('data-styles', ''); | ||
| head.insertBefore(visibilityStyle, metaCharset ? metaCharset.nextSibling : head.firstChild); | ||
| } | ||
| // Process deferred connectedCallbacks now all components have been registered | ||
| isBootstrapping = false; | ||
| if (deferredConnectedCallbacks.length) { | ||
| deferredConnectedCallbacks.map(host => host.connectedCallback()); | ||
| } | ||
| else { | ||
| { | ||
| plt.jmp(() => (appLoadFallback = setTimeout(appDidLoad, 30))); | ||
| } | ||
| } | ||
| // Fallback appLoad event | ||
| endBootstrap(); | ||
| }; | ||
| const Fragment = (_, children) => children; | ||
| const hostRefs = new WeakMap(); | ||
| const getHostRef = (ref) => hostRefs.get(ref); | ||
| const registerInstance = (lazyInstance, hostRef) => hostRefs.set((hostRef.$lazyInstance$ = lazyInstance), hostRef); | ||
| const registerHost = (elm, cmpMeta) => { | ||
| const hostRef = { | ||
| $flags$: 0, | ||
| $hostElement$: elm, | ||
| $cmpMeta$: cmpMeta, | ||
| $instanceValues$: new Map(), | ||
| }; | ||
| { | ||
| hostRef.$onInstancePromise$ = new Promise(r => (hostRef.$onInstanceResolve$ = r)); | ||
| } | ||
| { | ||
| hostRef.$onReadyPromise$ = new Promise(r => (hostRef.$onReadyResolve$ = r)); | ||
| elm['s-p'] = []; | ||
| elm['s-rc'] = []; | ||
| } | ||
| return hostRefs.set(elm, hostRef); | ||
| }; | ||
| const isMemberInElement = (elm, memberName) => memberName in elm; | ||
| const consoleError = (e, el) => (0, console.error)(e, el); | ||
| const cmpModules = /*@__PURE__*/ new Map(); | ||
| const loadModule = (cmpMeta, hostRef, hmrVersionId) => { | ||
| // loadModuleImport | ||
| const exportName = cmpMeta.$tagName$.replace(/-/g, '_'); | ||
| const bundleId = cmpMeta.$lazyBundleId$; | ||
| const module = cmpModules.get(bundleId) ; | ||
| if (module) { | ||
| return module[exportName]; | ||
| } | ||
| return import( | ||
| /* webpackInclude: /\.entry\.js$/ */ | ||
| /* webpackExclude: /\.system\.entry\.js$/ */ | ||
| /* webpackMode: "lazy" */ | ||
| `./${bundleId}.entry.js${''}`).then(importedModule => { | ||
| { | ||
| cmpModules.set(bundleId, importedModule); | ||
| } | ||
| return importedModule[exportName]; | ||
| }, consoleError); | ||
| }; | ||
| const styles = new Map(); | ||
| const queueDomReads = []; | ||
| const queueDomWrites = []; | ||
| const queueTask = (queue, write) => (cb) => { | ||
| queue.push(cb); | ||
| if (!queuePending) { | ||
| queuePending = true; | ||
| if (write && plt.$flags$ & 4 /* queueSync */) { | ||
| nextTick(flush); | ||
| } | ||
| else { | ||
| plt.raf(flush); | ||
| } | ||
| } | ||
| }; | ||
| const consume = (queue) => { | ||
| for (let i = 0; i < queue.length; i++) { | ||
| try { | ||
| queue[i](performance.now()); | ||
| } | ||
| catch (e) { | ||
| consoleError(e); | ||
| } | ||
| } | ||
| queue.length = 0; | ||
| }; | ||
| const flush = () => { | ||
| // always force a bunch of medium callbacks to run, but still have | ||
| // a throttle on how many can run in a certain time | ||
| // DOM READS!!! | ||
| consume(queueDomReads); | ||
| // DOM WRITES!!! | ||
| { | ||
| consume(queueDomWrites); | ||
| if ((queuePending = queueDomReads.length > 0)) { | ||
| // still more to do yet, but we've run out of time | ||
| // let's let this thing cool off and try again in the next tick | ||
| plt.raf(flush); | ||
| } | ||
| } | ||
| }; | ||
| const nextTick = /*@__PURE__*/ (cb) => promiseResolve().then(cb); | ||
| const writeTask = /*@__PURE__*/ queueTask(queueDomWrites, true); | ||
| export { Fragment as F, Host as H, bootstrapLazy as b, createEvent as c, getElement as g, h, promiseResolve as p, registerInstance as r }; |
+6
-0
@@ -0,1 +1,7 @@ | ||
| # 4.0.3 (2021-05-15) | ||
| ### Fix | ||
| - do not display separator if font-size option not activated | ||
| # 4.0.2 (2021-05-09) | ||
@@ -2,0 +8,0 @@ |
| 'use strict'; | ||
| const index = require('./index-277996c5.js'); | ||
| const index = require('./index-2e93d929.js'); | ||
@@ -5,0 +5,0 @@ /* |
@@ -5,3 +5,3 @@ 'use strict'; | ||
| const index = require('./index-277996c5.js'); | ||
| const index = require('./index-2e93d929.js'); | ||
@@ -8,0 +8,0 @@ /* |
@@ -1,2 +0,2 @@ | ||
| import { Component, Element, Event, h, Host, Method, Prop, State, Watch } from '@stencil/core'; | ||
| import { Component, Element, Event, Fragment, h, Host, Method, Prop, State, Watch } from '@stencil/core'; | ||
| import { debounce, isIOS, isMobile, isRTL, unifyEvent } from '@deckdeckgo/utils'; | ||
@@ -627,3 +627,2 @@ import '@deckdeckgo/color'; | ||
| this.renderFontSizeAction(), | ||
| this.renderSeparator(), | ||
| this.renderColorActions(), | ||
@@ -687,6 +686,8 @@ this.renderSeparator(), | ||
| } | ||
| return (h("deckgo-ie-action-button", { mobile: this.mobile, onAction: () => this.openFontSizeActions() }, | ||
| h("span", null, | ||
| "A", | ||
| h("small", null, "A")))); | ||
| return (h(Fragment, null, | ||
| h("deckgo-ie-action-button", { mobile: this.mobile, onAction: () => this.openFontSizeActions() }, | ||
| h("span", null, | ||
| "A", | ||
| h("small", null, "A"))), | ||
| this.renderSeparator())); | ||
| } | ||
@@ -693,0 +694,0 @@ static get is() { return "deckgo-inline-editor"; } |
@@ -1,1 +0,1 @@ | ||
| import{p as o,b as t}from"./p-7cbe893b.js";(()=>{const t=import.meta.url,e={};return""!==t&&(e.resourcesUrl=new URL(".",t).href),o(e)})().then((o=>t([["p-df58bcc0",[[1,"deckgo-inline-editor",{palette:[16],mobile:[1028],stickyDesktop:[4,"sticky-desktop"],stickyMobile:[4,"sticky-mobile"],attachTo:[16],containers:[1],imgAnchor:[1,"img-anchor"],imgPropertyWidth:[1,"img-property-width"],imgPropertyCssFloat:[1,"img-property-css-float"],imgEditable:[4,"img-editable"],list:[4],align:[4],fontSize:[4,"font-size"],backgroundColor:[4,"background-color"],customActions:[1,"custom-actions"],handleGlobalEvents:[4,"handle-global-events"],command:[1],bold:[32],italic:[32],underline:[32],strikethrough:[32],contentAlign:[32],contentList:[32],contentFontSize:[32],disabledTitle:[32],toolsActivated:[32],displayToolsActivated:[32],link:[32],toolbarActions:[32],toolsLeft:[32],toolsTop:[32],anchorEventLeft:[32],displayTools:[64],reset:[64]}],[1,"deckgo-ie-image-actions",{anchorEvent:[16],imgPropertyWidth:[1,"img-property-width"],imgPropertyCssFloat:[1,"img-property-css-float"],imgDidChange:[16],containers:[1],imgAnchor:[1,"img-anchor"],mobile:[4],imageSize:[32],imageAlign:[32]}],[1,"deckgo-ie-align-actions",{anchorEvent:[16],mobile:[4],sticky:[4],contentAlign:[1,"content-align"],containers:[1],command:[1]}],[1,"deckgo-ie-color-actions",{action:[1],palette:[16],mobile:[4],containers:[1],colorRgb:[32]}],[1,"deckgo-ie-list-actions",{disabledTitle:[4,"disabled-title"],mobile:[4],sticky:[4],contentList:[1,"content-list"]}],[1,"deckgo-ie-font-size-actions",{mobile:[4],sticky:[4],fontSize:[1,"font-size"]}],[1,"deckgo-ie-style-actions",{disabledTitle:[4,"disabled-title"],mobile:[4],bold:[4],italic:[4],underline:[4],strikethrough:[4]}],[1,"deckgo-ie-link-actions",{toolbarActions:[2,"toolbar-actions"],anchorLink:[16],linkCreated:[16],mobile:[4],containers:[1]}],[1,"deckgo-ie-triangle",{mobile:[4]}],[1,"deckgo-color",{palette:[1040],inputAlt:[1,"input-alt"],colorHex:[1,"color-hex"],colorRgb:[1,"color-rgb"],selectedColorHex:[32],selectedColorRgb:[32],selectedColorPalette:[32],selectedCustomColorRgb:[32]}],[1,"deckgo-ie-separator",{mobile:[4]}],[1,"deckgo-color-input",{colorHex:[1,"color-hex"],colorRgb:[1,"color-rgb"],customColorRgb:[1,"custom-color-rgb"],inputAlt:[1,"input-alt"],color:[32]}],[1,"deckgo-ie-action-image",{cssClass:[1,"css-class"]}],[1,"deckgo-ie-action-button",{disableAction:[4,"disable-action"],cssClass:[1,"css-class"],mobile:[4]}]]]],o))); | ||
| import{p as o,b as e}from"./p-ee0948e7.js";(()=>{const e=import.meta.url,t={};return""!==e&&(t.resourcesUrl=new URL(".",e).href),o(t)})().then((o=>e([["p-171ffb37",[[1,"deckgo-inline-editor",{palette:[16],mobile:[1028],stickyDesktop:[4,"sticky-desktop"],stickyMobile:[4,"sticky-mobile"],attachTo:[16],containers:[1],imgAnchor:[1,"img-anchor"],imgPropertyWidth:[1,"img-property-width"],imgPropertyCssFloat:[1,"img-property-css-float"],imgEditable:[4,"img-editable"],list:[4],align:[4],fontSize:[4,"font-size"],backgroundColor:[4,"background-color"],customActions:[1,"custom-actions"],handleGlobalEvents:[4,"handle-global-events"],command:[1],bold:[32],italic:[32],underline:[32],strikethrough:[32],contentAlign:[32],contentList:[32],contentFontSize:[32],disabledTitle:[32],toolsActivated:[32],displayToolsActivated:[32],link:[32],toolbarActions:[32],toolsLeft:[32],toolsTop:[32],anchorEventLeft:[32],displayTools:[64],reset:[64]}],[1,"deckgo-ie-image-actions",{anchorEvent:[16],imgPropertyWidth:[1,"img-property-width"],imgPropertyCssFloat:[1,"img-property-css-float"],imgDidChange:[16],containers:[1],imgAnchor:[1,"img-anchor"],mobile:[4],imageSize:[32],imageAlign:[32]}],[1,"deckgo-ie-align-actions",{anchorEvent:[16],mobile:[4],sticky:[4],contentAlign:[1,"content-align"],containers:[1],command:[1]}],[1,"deckgo-ie-color-actions",{action:[1],palette:[16],mobile:[4],containers:[1],colorRgb:[32]}],[1,"deckgo-ie-list-actions",{disabledTitle:[4,"disabled-title"],mobile:[4],sticky:[4],contentList:[1,"content-list"]}],[1,"deckgo-ie-font-size-actions",{mobile:[4],sticky:[4],fontSize:[1,"font-size"]}],[1,"deckgo-ie-style-actions",{disabledTitle:[4,"disabled-title"],mobile:[4],bold:[4],italic:[4],underline:[4],strikethrough:[4]}],[1,"deckgo-ie-link-actions",{toolbarActions:[2,"toolbar-actions"],anchorLink:[16],linkCreated:[16],mobile:[4],containers:[1]}],[1,"deckgo-ie-triangle",{mobile:[4]}],[1,"deckgo-color",{palette:[1040],inputAlt:[1,"input-alt"],colorHex:[1,"color-hex"],colorRgb:[1,"color-rgb"],selectedColorHex:[32],selectedColorRgb:[32],selectedColorPalette:[32],selectedCustomColorRgb:[32]}],[1,"deckgo-ie-separator",{mobile:[4]}],[1,"deckgo-color-input",{colorHex:[1,"color-hex"],colorRgb:[1,"color-rgb"],customColorRgb:[1,"custom-color-rgb"],inputAlt:[1,"input-alt"],color:[32]}],[1,"deckgo-ie-action-image",{cssClass:[1,"css-class"]}],[1,"deckgo-ie-action-button",{disableAction:[4,"disable-action"],cssClass:[1,"css-class"],mobile:[4]}]]]],o))); |
@@ -1,2 +0,2 @@ | ||
| import { p as promiseResolve, b as bootstrapLazy } from './index-9fff9927.js'; | ||
| import { p as promiseResolve, b as bootstrapLazy } from './index-406c6f7a.js'; | ||
@@ -3,0 +3,0 @@ /* |
@@ -1,2 +0,2 @@ | ||
| import { p as promiseResolve, b as bootstrapLazy } from './index-9fff9927.js'; | ||
| import { p as promiseResolve, b as bootstrapLazy } from './index-406c6f7a.js'; | ||
@@ -3,0 +3,0 @@ /* |
+1
-1
| { | ||
| "name": "@deckdeckgo/inline-editor", | ||
| "version": "4.0.2", | ||
| "version": "4.0.3", | ||
| "description": "A WYSIWYG HTML Inline Editor Web Component", | ||
@@ -5,0 +5,0 @@ "main": "dist/index.cjs.js", |
| 'use strict'; | ||
| function _interopNamespace(e) { | ||
| if (e && e.__esModule) return e; | ||
| var n = Object.create(null); | ||
| if (e) { | ||
| Object.keys(e).forEach(function (k) { | ||
| if (k !== 'default') { | ||
| var d = Object.getOwnPropertyDescriptor(e, k); | ||
| Object.defineProperty(n, k, d.get ? d : { | ||
| enumerable: true, | ||
| get: function () { | ||
| return e[k]; | ||
| } | ||
| }); | ||
| } | ||
| }); | ||
| } | ||
| n['default'] = e; | ||
| return Object.freeze(n); | ||
| } | ||
| const NAMESPACE = 'deckdeckgo-inline-editor'; | ||
| let scopeId; | ||
| let hostTagName; | ||
| let isSvgMode = false; | ||
| let queuePending = false; | ||
| const win = typeof window !== 'undefined' ? window : {}; | ||
| const doc = win.document || { head: {} }; | ||
| const plt = { | ||
| $flags$: 0, | ||
| $resourcesUrl$: '', | ||
| jmp: h => h(), | ||
| raf: h => requestAnimationFrame(h), | ||
| ael: (el, eventName, listener, opts) => el.addEventListener(eventName, listener, opts), | ||
| rel: (el, eventName, listener, opts) => el.removeEventListener(eventName, listener, opts), | ||
| ce: (eventName, opts) => new CustomEvent(eventName, opts), | ||
| }; | ||
| const promiseResolve = (v) => Promise.resolve(v); | ||
| const supportsConstructibleStylesheets = /*@__PURE__*/ (() => { | ||
| try { | ||
| new CSSStyleSheet(); | ||
| return typeof (new CSSStyleSheet()).replace === 'function'; | ||
| } | ||
| catch (e) { } | ||
| return false; | ||
| })() | ||
| ; | ||
| const HYDRATED_CSS = '{visibility:hidden}.hydrated{visibility:inherit}'; | ||
| const createTime = (fnName, tagName = '') => { | ||
| { | ||
| return () => { | ||
| return; | ||
| }; | ||
| } | ||
| }; | ||
| const uniqueTime = (key, measureText) => { | ||
| { | ||
| return () => { | ||
| return; | ||
| }; | ||
| } | ||
| }; | ||
| const rootAppliedStyles = new WeakMap(); | ||
| const registerStyle = (scopeId, cssText, allowCS) => { | ||
| let style = styles.get(scopeId); | ||
| if (supportsConstructibleStylesheets && allowCS) { | ||
| style = (style || new CSSStyleSheet()); | ||
| style.replace(cssText); | ||
| } | ||
| else { | ||
| style = cssText; | ||
| } | ||
| styles.set(scopeId, style); | ||
| }; | ||
| const addStyle = (styleContainerNode, cmpMeta, mode, hostElm) => { | ||
| let scopeId = getScopeId(cmpMeta); | ||
| let style = styles.get(scopeId); | ||
| // if an element is NOT connected then getRootNode() will return the wrong root node | ||
| // so the fallback is to always use the document for the root node in those cases | ||
| styleContainerNode = styleContainerNode.nodeType === 11 /* DocumentFragment */ ? styleContainerNode : doc; | ||
| if (style) { | ||
| if (typeof style === 'string') { | ||
| styleContainerNode = styleContainerNode.head || styleContainerNode; | ||
| let appliedStyles = rootAppliedStyles.get(styleContainerNode); | ||
| let styleElm; | ||
| if (!appliedStyles) { | ||
| rootAppliedStyles.set(styleContainerNode, (appliedStyles = new Set())); | ||
| } | ||
| if (!appliedStyles.has(scopeId)) { | ||
| { | ||
| { | ||
| styleElm = doc.createElement('style'); | ||
| styleElm.innerHTML = style; | ||
| } | ||
| styleContainerNode.insertBefore(styleElm, styleContainerNode.querySelector('link')); | ||
| } | ||
| if (appliedStyles) { | ||
| appliedStyles.add(scopeId); | ||
| } | ||
| } | ||
| } | ||
| else if (!styleContainerNode.adoptedStyleSheets.includes(style)) { | ||
| styleContainerNode.adoptedStyleSheets = [...styleContainerNode.adoptedStyleSheets, style]; | ||
| } | ||
| } | ||
| return scopeId; | ||
| }; | ||
| const attachStyles = (hostRef) => { | ||
| const cmpMeta = hostRef.$cmpMeta$; | ||
| const elm = hostRef.$hostElement$; | ||
| const flags = cmpMeta.$flags$; | ||
| const endAttachStyles = createTime('attachStyles', cmpMeta.$tagName$); | ||
| const scopeId = addStyle(elm.shadowRoot ? elm.shadowRoot : elm.getRootNode(), cmpMeta); | ||
| if (flags & 10 /* needsScopedEncapsulation */) { | ||
| // 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 | ||
| // DOM WRITE!! | ||
| elm['s-sc'] = scopeId; | ||
| elm.classList.add(scopeId + '-h'); | ||
| } | ||
| endAttachStyles(); | ||
| }; | ||
| const getScopeId = (cmp, mode) => 'sc-' + (cmp.$tagName$); | ||
| /** | ||
| * Default style mode id | ||
| */ | ||
| /** | ||
| * Reusable empty obj/array | ||
| * Don't add values to these!! | ||
| */ | ||
| const EMPTY_OBJ = {}; | ||
| const isDef = (v) => v != null; | ||
| const isComplexType = (o) => { | ||
| // https://jsperf.com/typeof-fn-object/5 | ||
| o = typeof o; | ||
| return o === 'object' || o === 'function'; | ||
| }; | ||
| /** | ||
| * Production h() function based on Preact by | ||
| * Jason Miller (@developit) | ||
| * Licensed under the MIT License | ||
| * https://github.com/developit/preact/blob/master/LICENSE | ||
| * | ||
| * Modified for Stencil's compiler and vdom | ||
| */ | ||
| // const stack: any[] = []; | ||
| // export function h(nodeName: string | d.FunctionalComponent, vnodeData: d.PropsType, child?: d.ChildType): d.VNode; | ||
| // export function h(nodeName: string | d.FunctionalComponent, vnodeData: d.PropsType, ...children: d.ChildType[]): d.VNode; | ||
| const h = (nodeName, vnodeData, ...children) => { | ||
| let child = null; | ||
| let simple = false; | ||
| let lastSimple = false; | ||
| let vNodeChildren = []; | ||
| const walk = (c) => { | ||
| for (let i = 0; i < c.length; i++) { | ||
| child = c[i]; | ||
| if (Array.isArray(child)) { | ||
| walk(child); | ||
| } | ||
| else if (child != null && typeof child !== 'boolean') { | ||
| if ((simple = typeof nodeName !== 'function' && !isComplexType(child))) { | ||
| child = String(child); | ||
| } | ||
| if (simple && lastSimple) { | ||
| // If the previous child was simple (string), we merge both | ||
| vNodeChildren[vNodeChildren.length - 1].$text$ += child; | ||
| } | ||
| else { | ||
| // Append a new vNode, if it's text, we create a text vNode | ||
| vNodeChildren.push(simple ? newVNode(null, child) : child); | ||
| } | ||
| lastSimple = simple; | ||
| } | ||
| } | ||
| }; | ||
| walk(children); | ||
| if (vnodeData) { | ||
| { | ||
| const classData = vnodeData.className || vnodeData.class; | ||
| if (classData) { | ||
| vnodeData.class = | ||
| typeof classData !== 'object' | ||
| ? classData | ||
| : Object.keys(classData) | ||
| .filter(k => classData[k]) | ||
| .join(' '); | ||
| } | ||
| } | ||
| } | ||
| const vnode = newVNode(nodeName, null); | ||
| vnode.$attrs$ = vnodeData; | ||
| if (vNodeChildren.length > 0) { | ||
| vnode.$children$ = vNodeChildren; | ||
| } | ||
| return vnode; | ||
| }; | ||
| const newVNode = (tag, text) => { | ||
| const vnode = { | ||
| $flags$: 0, | ||
| $tag$: tag, | ||
| $text$: text, | ||
| $elm$: null, | ||
| $children$: null, | ||
| }; | ||
| { | ||
| vnode.$attrs$ = null; | ||
| } | ||
| return vnode; | ||
| }; | ||
| const Host = {}; | ||
| const isHost = (node) => node && node.$tag$ === Host; | ||
| /** | ||
| * Production setAccessor() function based on Preact by | ||
| * Jason Miller (@developit) | ||
| * Licensed under the MIT License | ||
| * https://github.com/developit/preact/blob/master/LICENSE | ||
| * | ||
| * Modified for Stencil's compiler and vdom | ||
| */ | ||
| const setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags) => { | ||
| if (oldValue !== newValue) { | ||
| let isProp = isMemberInElement(elm, memberName); | ||
| let ln = memberName.toLowerCase(); | ||
| if (memberName === 'class') { | ||
| const classList = elm.classList; | ||
| const oldClasses = parseClassList(oldValue); | ||
| const newClasses = parseClassList(newValue); | ||
| classList.remove(...oldClasses.filter(c => c && !newClasses.includes(c))); | ||
| classList.add(...newClasses.filter(c => c && !oldClasses.includes(c))); | ||
| } | ||
| else if (memberName === 'style') { | ||
| // update style attribute, css properties and values | ||
| { | ||
| for (const prop in oldValue) { | ||
| if (!newValue || newValue[prop] == null) { | ||
| if (prop.includes('-')) { | ||
| elm.style.removeProperty(prop); | ||
| } | ||
| else { | ||
| elm.style[prop] = ''; | ||
| } | ||
| } | ||
| } | ||
| } | ||
| for (const prop in newValue) { | ||
| if (!oldValue || newValue[prop] !== oldValue[prop]) { | ||
| if (prop.includes('-')) { | ||
| elm.style.setProperty(prop, newValue[prop]); | ||
| } | ||
| else { | ||
| elm.style[prop] = newValue[prop]; | ||
| } | ||
| } | ||
| } | ||
| } | ||
| else if (memberName === 'ref') { | ||
| // minifier will clean this up | ||
| if (newValue) { | ||
| newValue(elm); | ||
| } | ||
| } | ||
| else if ((!isProp ) && memberName[0] === 'o' && memberName[1] === 'n') { | ||
| // Event Handlers | ||
| // so if the member name starts with "on" and the 3rd characters is | ||
| // a capital letter, and it's not already a member on the element, | ||
| // then we're assuming it's an event listener | ||
| if (memberName[2] === '-') { | ||
| // on- prefixed events | ||
| // allows to be explicit about the dom event to listen without any magic | ||
| // under the hood: | ||
| // <my-cmp on-click> // listens for "click" | ||
| // <my-cmp on-Click> // listens for "Click" | ||
| // <my-cmp on-ionChange> // listens for "ionChange" | ||
| // <my-cmp on-EVENTS> // listens for "EVENTS" | ||
| memberName = memberName.slice(3); | ||
| } | ||
| else if (isMemberInElement(win, ln)) { | ||
| // standard event | ||
| // the JSX attribute could have been "onMouseOver" and the | ||
| // member name "onmouseover" is on the window's prototype | ||
| // so let's add the listener "mouseover", which is all lowercased | ||
| memberName = ln.slice(2); | ||
| } | ||
| else { | ||
| // custom event | ||
| // the JSX attribute could have been "onMyCustomEvent" | ||
| // so let's trim off the "on" prefix and lowercase the first character | ||
| // and add the listener "myCustomEvent" | ||
| // except for the first character, we keep the event name case | ||
| memberName = ln[2] + memberName.slice(3); | ||
| } | ||
| if (oldValue) { | ||
| plt.rel(elm, memberName, oldValue, false); | ||
| } | ||
| if (newValue) { | ||
| plt.ael(elm, memberName, newValue, false); | ||
| } | ||
| } | ||
| else { | ||
| // Set property if it exists and it's not a SVG | ||
| const isComplex = isComplexType(newValue); | ||
| if ((isProp || (isComplex && newValue !== null)) && !isSvg) { | ||
| try { | ||
| if (!elm.tagName.includes('-')) { | ||
| let n = newValue == null ? '' : newValue; | ||
| // Workaround for Safari, moving the <input> caret when re-assigning the same valued | ||
| if (memberName === 'list') { | ||
| isProp = false; | ||
| // tslint:disable-next-line: triple-equals | ||
| } | ||
| else if (oldValue == null || elm[memberName] != n) { | ||
| elm[memberName] = n; | ||
| } | ||
| } | ||
| else { | ||
| elm[memberName] = newValue; | ||
| } | ||
| } | ||
| catch (e) { } | ||
| } | ||
| if (newValue == null || newValue === false) { | ||
| if (newValue !== false || elm.getAttribute(memberName) === '') { | ||
| { | ||
| elm.removeAttribute(memberName); | ||
| } | ||
| } | ||
| } | ||
| else if ((!isProp || flags & 4 /* isHost */ || isSvg) && !isComplex) { | ||
| newValue = newValue === true ? '' : newValue; | ||
| { | ||
| elm.setAttribute(memberName, newValue); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| }; | ||
| const parseClassListRegex = /\s/; | ||
| const parseClassList = (value) => (!value ? [] : value.split(parseClassListRegex)); | ||
| const updateElement = (oldVnode, newVnode, isSvgMode, memberName) => { | ||
| // if the element passed in is a shadow root, which is a document fragment | ||
| // then we want to be adding attrs/props to the shadow root's "host" element | ||
| // if it's not a shadow root, then we add attrs/props to the same element | ||
| const elm = newVnode.$elm$.nodeType === 11 /* DocumentFragment */ && newVnode.$elm$.host ? newVnode.$elm$.host : newVnode.$elm$; | ||
| const oldVnodeAttrs = (oldVnode && oldVnode.$attrs$) || EMPTY_OBJ; | ||
| const newVnodeAttrs = newVnode.$attrs$ || EMPTY_OBJ; | ||
| { | ||
| // remove attributes no longer present on the vnode by setting them to undefined | ||
| for (memberName in oldVnodeAttrs) { | ||
| if (!(memberName in newVnodeAttrs)) { | ||
| setAccessor(elm, memberName, oldVnodeAttrs[memberName], undefined, isSvgMode, newVnode.$flags$); | ||
| } | ||
| } | ||
| } | ||
| // add new & update changed attributes | ||
| for (memberName in newVnodeAttrs) { | ||
| setAccessor(elm, memberName, oldVnodeAttrs[memberName], newVnodeAttrs[memberName], isSvgMode, newVnode.$flags$); | ||
| } | ||
| }; | ||
| const createElm = (oldParentVNode, newParentVNode, childIndex, parentElm) => { | ||
| // tslint:disable-next-line: prefer-const | ||
| let newVNode = newParentVNode.$children$[childIndex]; | ||
| 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. | ||
| { | ||
| updateElement(null, newVNode, isSvgMode); | ||
| } | ||
| if (isDef(scopeId) && elm['s-si'] !== scopeId) { | ||
| // if there is a scopeId and this is the initial render | ||
| // then let's add the scopeId as a css class | ||
| elm.classList.add((elm['s-si'] = scopeId)); | ||
| } | ||
| if (newVNode.$children$) { | ||
| for (i = 0; i < newVNode.$children$.length; ++i) { | ||
| // create the node | ||
| childNode = createElm(oldParentVNode, newVNode, i); | ||
| // return node could have been null | ||
| if (childNode) { | ||
| // append our new node | ||
| elm.appendChild(childNode); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| return elm; | ||
| }; | ||
| const addVnodes = (parentElm, before, parentVNode, vnodes, startIdx, endIdx) => { | ||
| 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); | ||
| if (childNode) { | ||
| vnodes[startIdx].$elm$ = childNode; | ||
| containerElm.insertBefore(childNode, before); | ||
| } | ||
| } | ||
| } | ||
| }; | ||
| const removeVnodes = (vnodes, startIdx, endIdx, vnode, elm) => { | ||
| for (; startIdx <= endIdx; ++startIdx) { | ||
| if ((vnode = vnodes[startIdx])) { | ||
| elm = vnode.$elm$; | ||
| callNodeRefs(vnode); | ||
| // remove the vnode's element from the dom | ||
| elm.remove(); | ||
| } | ||
| } | ||
| }; | ||
| const updateChildren = (parentElm, oldCh, newVNode, newCh) => { | ||
| let oldStartIdx = 0; | ||
| let newStartIdx = 0; | ||
| let oldEndIdx = oldCh.length - 1; | ||
| let oldStartVnode = oldCh[0]; | ||
| let oldEndVnode = oldCh[oldEndIdx]; | ||
| let newEndIdx = newCh.length - 1; | ||
| let newStartVnode = newCh[0]; | ||
| let newEndVnode = newCh[newEndIdx]; | ||
| let node; | ||
| while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) { | ||
| if (oldStartVnode == null) { | ||
| // Vnode might have been moved left | ||
| oldStartVnode = oldCh[++oldStartIdx]; | ||
| } | ||
| else if (oldEndVnode == null) { | ||
| oldEndVnode = oldCh[--oldEndIdx]; | ||
| } | ||
| else if (newStartVnode == null) { | ||
| newStartVnode = newCh[++newStartIdx]; | ||
| } | ||
| else if (newEndVnode == null) { | ||
| newEndVnode = newCh[--newEndIdx]; | ||
| } | ||
| else if (isSameVnode(oldStartVnode, newStartVnode)) { | ||
| patch(oldStartVnode, newStartVnode); | ||
| oldStartVnode = oldCh[++oldStartIdx]; | ||
| newStartVnode = newCh[++newStartIdx]; | ||
| } | ||
| else if (isSameVnode(oldEndVnode, newEndVnode)) { | ||
| patch(oldEndVnode, newEndVnode); | ||
| oldEndVnode = oldCh[--oldEndIdx]; | ||
| newEndVnode = newCh[--newEndIdx]; | ||
| } | ||
| else if (isSameVnode(oldStartVnode, newEndVnode)) { | ||
| patch(oldStartVnode, newEndVnode); | ||
| parentElm.insertBefore(oldStartVnode.$elm$, oldEndVnode.$elm$.nextSibling); | ||
| oldStartVnode = oldCh[++oldStartIdx]; | ||
| newEndVnode = newCh[--newEndIdx]; | ||
| } | ||
| else if (isSameVnode(oldEndVnode, newStartVnode)) { | ||
| patch(oldEndVnode, newStartVnode); | ||
| parentElm.insertBefore(oldEndVnode.$elm$, oldStartVnode.$elm$); | ||
| oldEndVnode = oldCh[--oldEndIdx]; | ||
| newStartVnode = newCh[++newStartIdx]; | ||
| } | ||
| else { | ||
| { | ||
| // new element | ||
| node = createElm(oldCh && oldCh[newStartIdx], newVNode, newStartIdx); | ||
| newStartVnode = newCh[++newStartIdx]; | ||
| } | ||
| if (node) { | ||
| { | ||
| oldStartVnode.$elm$.parentNode.insertBefore(node, oldStartVnode.$elm$); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| if (oldStartIdx > oldEndIdx) { | ||
| addVnodes(parentElm, newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].$elm$, newVNode, newCh, newStartIdx, newEndIdx); | ||
| } | ||
| else if (newStartIdx > newEndIdx) { | ||
| removeVnodes(oldCh, oldStartIdx, oldEndIdx); | ||
| } | ||
| }; | ||
| 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$) { | ||
| return true; | ||
| } | ||
| return false; | ||
| }; | ||
| 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$; | ||
| if (text === null) { | ||
| // element node | ||
| { | ||
| if (tag === 'slot') | ||
| ; | ||
| else { | ||
| // either this is the first render of an element OR it's an update | ||
| // AND we already know it's possible it could have changed | ||
| // this updates the element's css classes, attrs, props, listeners, etc. | ||
| updateElement(oldVNode, newVNode, isSvgMode); | ||
| } | ||
| } | ||
| if (oldChildren !== null && newChildren !== null) { | ||
| // looks like there's child vnodes for both the old and new vnodes | ||
| 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); | ||
| } | ||
| else if (oldChildren !== null) { | ||
| // no new child vnodes, but there are old child vnodes to remove | ||
| 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; | ||
| } | ||
| }; | ||
| const callNodeRefs = (vNode) => { | ||
| { | ||
| vNode.$attrs$ && vNode.$attrs$.ref && vNode.$attrs$.ref(null); | ||
| vNode.$children$ && vNode.$children$.map(callNodeRefs); | ||
| } | ||
| }; | ||
| const renderVdom = (hostRef, renderFnResults) => { | ||
| const hostElm = hostRef.$hostElement$; | ||
| const oldVNode = hostRef.$vnode$ || newVNode(null, null); | ||
| const rootVnode = isHost(renderFnResults) ? renderFnResults : h(null, null, renderFnResults); | ||
| hostTagName = hostElm.tagName; | ||
| rootVnode.$tag$ = null; | ||
| rootVnode.$flags$ |= 4 /* isHost */; | ||
| hostRef.$vnode$ = rootVnode; | ||
| rootVnode.$elm$ = oldVNode.$elm$ = (hostElm.shadowRoot || hostElm ); | ||
| { | ||
| scopeId = hostElm['s-sc']; | ||
| } | ||
| // synchronous patch | ||
| patch(oldVNode, rootVnode); | ||
| }; | ||
| const getElement = (ref) => (getHostRef(ref).$hostElement$ ); | ||
| const createEvent = (ref, name, flags) => { | ||
| const elm = getElement(ref); | ||
| return { | ||
| emit: (detail) => { | ||
| return emitEvent(elm, name, { | ||
| bubbles: !!(flags & 4 /* Bubbles */), | ||
| composed: !!(flags & 2 /* Composed */), | ||
| cancelable: !!(flags & 1 /* Cancellable */), | ||
| detail, | ||
| }); | ||
| }, | ||
| }; | ||
| }; | ||
| const emitEvent = (elm, name, opts) => { | ||
| const ev = plt.ce(name, opts); | ||
| elm.dispatchEvent(ev); | ||
| return ev; | ||
| }; | ||
| const attachToAncestor = (hostRef, ancestorComponent) => { | ||
| if (ancestorComponent && !hostRef.$onRenderResolve$ && ancestorComponent['s-p']) { | ||
| ancestorComponent['s-p'].push(new Promise(r => (hostRef.$onRenderResolve$ = r))); | ||
| } | ||
| }; | ||
| const scheduleUpdate = (hostRef, isInitialLoad) => { | ||
| { | ||
| hostRef.$flags$ |= 16 /* isQueuedForUpdate */; | ||
| } | ||
| if (hostRef.$flags$ & 4 /* isWaitingForChildren */) { | ||
| hostRef.$flags$ |= 512 /* needsRerender */; | ||
| return; | ||
| } | ||
| attachToAncestor(hostRef, hostRef.$ancestorComponent$); | ||
| // there is no ancestor component or the ancestor component | ||
| // has already fired off its lifecycle update then | ||
| // fire off the initial update | ||
| const dispatch = () => dispatchHooks(hostRef, isInitialLoad); | ||
| return writeTask(dispatch) ; | ||
| }; | ||
| const dispatchHooks = (hostRef, isInitialLoad) => { | ||
| const endSchedule = createTime('scheduleUpdate', hostRef.$cmpMeta$.$tagName$); | ||
| const instance = hostRef.$lazyInstance$ ; | ||
| let promise; | ||
| if (isInitialLoad) { | ||
| { | ||
| promise = safeCall(instance, 'componentWillLoad'); | ||
| } | ||
| } | ||
| endSchedule(); | ||
| return then(promise, () => updateComponent(hostRef, instance, isInitialLoad)); | ||
| }; | ||
| const updateComponent = async (hostRef, instance, isInitialLoad) => { | ||
| // updateComponent | ||
| const elm = hostRef.$hostElement$; | ||
| const endUpdate = createTime('update', hostRef.$cmpMeta$.$tagName$); | ||
| const rc = elm['s-rc']; | ||
| if (isInitialLoad) { | ||
| // DOM WRITE! | ||
| attachStyles(hostRef); | ||
| } | ||
| const endRender = createTime('render', hostRef.$cmpMeta$.$tagName$); | ||
| { | ||
| callRender(hostRef, instance); | ||
| } | ||
| if (rc) { | ||
| // ok, so turns out there are some child host elements | ||
| // waiting on this parent element to load | ||
| // let's fire off all update callbacks waiting | ||
| rc.map(cb => cb()); | ||
| elm['s-rc'] = undefined; | ||
| } | ||
| endRender(); | ||
| endUpdate(); | ||
| { | ||
| const childrenPromises = elm['s-p']; | ||
| const postUpdate = () => postUpdateComponent(hostRef); | ||
| if (childrenPromises.length === 0) { | ||
| postUpdate(); | ||
| } | ||
| else { | ||
| Promise.all(childrenPromises).then(postUpdate); | ||
| hostRef.$flags$ |= 4 /* isWaitingForChildren */; | ||
| childrenPromises.length = 0; | ||
| } | ||
| } | ||
| }; | ||
| const callRender = (hostRef, instance, elm) => { | ||
| try { | ||
| instance = instance.render() ; | ||
| { | ||
| hostRef.$flags$ &= ~16 /* isQueuedForUpdate */; | ||
| } | ||
| { | ||
| hostRef.$flags$ |= 2 /* hasRendered */; | ||
| } | ||
| { | ||
| { | ||
| // looks like we've got child nodes to render into this host element | ||
| // or we need to update the css class/attrs on the host element | ||
| // DOM WRITE! | ||
| { | ||
| renderVdom(hostRef, instance); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| catch (e) { | ||
| consoleError(e, hostRef.$hostElement$); | ||
| } | ||
| return null; | ||
| }; | ||
| const postUpdateComponent = (hostRef) => { | ||
| const tagName = hostRef.$cmpMeta$.$tagName$; | ||
| const elm = hostRef.$hostElement$; | ||
| const endPostUpdate = createTime('postUpdate', tagName); | ||
| const instance = hostRef.$lazyInstance$ ; | ||
| const ancestorComponent = hostRef.$ancestorComponent$; | ||
| if (!(hostRef.$flags$ & 64 /* hasLoadedComponent */)) { | ||
| hostRef.$flags$ |= 64 /* hasLoadedComponent */; | ||
| { | ||
| // DOM WRITE! | ||
| addHydratedFlag(elm); | ||
| } | ||
| { | ||
| safeCall(instance, 'componentDidLoad'); | ||
| } | ||
| endPostUpdate(); | ||
| { | ||
| hostRef.$onReadyResolve$(elm); | ||
| if (!ancestorComponent) { | ||
| appDidLoad(); | ||
| } | ||
| } | ||
| } | ||
| else { | ||
| endPostUpdate(); | ||
| } | ||
| { | ||
| hostRef.$onInstanceResolve$(elm); | ||
| } | ||
| // load events fire from bottom to top | ||
| // the deepest elements load first then bubbles up | ||
| { | ||
| if (hostRef.$onRenderResolve$) { | ||
| hostRef.$onRenderResolve$(); | ||
| hostRef.$onRenderResolve$ = undefined; | ||
| } | ||
| if (hostRef.$flags$ & 512 /* needsRerender */) { | ||
| nextTick(() => scheduleUpdate(hostRef, false)); | ||
| } | ||
| hostRef.$flags$ &= ~(4 /* isWaitingForChildren */ | 512 /* needsRerender */); | ||
| } | ||
| // ( •_•) | ||
| // ( •_•)>⌐■-■ | ||
| // (⌐■_■) | ||
| }; | ||
| const appDidLoad = (who) => { | ||
| // on appload | ||
| // we have finish the first big initial render | ||
| { | ||
| addHydratedFlag(doc.documentElement); | ||
| } | ||
| nextTick(() => emitEvent(win, 'appload', { detail: { namespace: NAMESPACE } })); | ||
| }; | ||
| const safeCall = (instance, method, arg) => { | ||
| if (instance && instance[method]) { | ||
| try { | ||
| return instance[method](arg); | ||
| } | ||
| catch (e) { | ||
| consoleError(e); | ||
| } | ||
| } | ||
| return undefined; | ||
| }; | ||
| const then = (promise, thenFn) => { | ||
| return promise && promise.then ? promise.then(thenFn) : thenFn(); | ||
| }; | ||
| const addHydratedFlag = (elm) => (elm.classList.add('hydrated') ); | ||
| const parsePropertyValue = (propValue, propType) => { | ||
| // ensure this value is of the correct prop type | ||
| if (propValue != null && !isComplexType(propValue)) { | ||
| if (propType & 4 /* Boolean */) { | ||
| // per the HTML spec, any string value means it is a boolean true value | ||
| // but we'll cheat here and say that the string "false" is the boolean false | ||
| return propValue === 'false' ? false : propValue === '' || !!propValue; | ||
| } | ||
| if (propType & 2 /* Number */) { | ||
| // force it to be a number | ||
| return parseFloat(propValue); | ||
| } | ||
| if (propType & 1 /* String */) { | ||
| // could have been passed as a number or boolean | ||
| // but we still want it as a string | ||
| return String(propValue); | ||
| } | ||
| // redundant return here for better minification | ||
| return propValue; | ||
| } | ||
| // not sure exactly what type we want | ||
| // so no need to change to a different type | ||
| return propValue; | ||
| }; | ||
| const getValue = (ref, propName) => getHostRef(ref).$instanceValues$.get(propName); | ||
| const setValue = (ref, propName, newVal, cmpMeta) => { | ||
| // check our new property value against our internal value | ||
| const hostRef = getHostRef(ref); | ||
| const elm = hostRef.$hostElement$ ; | ||
| const oldVal = hostRef.$instanceValues$.get(propName); | ||
| const flags = hostRef.$flags$; | ||
| const instance = hostRef.$lazyInstance$ ; | ||
| newVal = parsePropertyValue(newVal, cmpMeta.$members$[propName][0]); | ||
| if ((!(flags & 8 /* isConstructingInstance */) || oldVal === undefined) && newVal !== oldVal) { | ||
| // gadzooks! the property's value has changed!! | ||
| // set our new value! | ||
| hostRef.$instanceValues$.set(propName, newVal); | ||
| if (instance) { | ||
| // get an array of method names of watch functions to call | ||
| if (cmpMeta.$watchers$ && flags & 128 /* isWatchReady */) { | ||
| const watchMethods = cmpMeta.$watchers$[propName]; | ||
| if (watchMethods) { | ||
| // this instance is watching for when this property changed | ||
| watchMethods.map(watchMethodName => { | ||
| try { | ||
| // fire off each of the watch methods that are watching this property | ||
| instance[watchMethodName](newVal, oldVal, propName); | ||
| } | ||
| catch (e) { | ||
| consoleError(e, elm); | ||
| } | ||
| }); | ||
| } | ||
| } | ||
| if ((flags & (2 /* hasRendered */ | 16 /* isQueuedForUpdate */)) === 2 /* hasRendered */) { | ||
| // looks like this value actually changed, so we've got work to do! | ||
| // but only if we've already rendered, otherwise just chill out | ||
| // queue that we need to do an update, but don't worry about queuing | ||
| // up millions cuz this function ensures it only runs once | ||
| scheduleUpdate(hostRef, false); | ||
| } | ||
| } | ||
| } | ||
| }; | ||
| const proxyComponent = (Cstr, cmpMeta, flags) => { | ||
| if (cmpMeta.$members$) { | ||
| if (Cstr.watchers) { | ||
| cmpMeta.$watchers$ = Cstr.watchers; | ||
| } | ||
| // It's better to have a const than two Object.entries() | ||
| const members = Object.entries(cmpMeta.$members$); | ||
| const prototype = Cstr.prototype; | ||
| members.map(([memberName, [memberFlags]]) => { | ||
| if ((memberFlags & 31 /* Prop */ || ((flags & 2 /* proxyState */) && memberFlags & 32 /* State */))) { | ||
| // proxyComponent - prop | ||
| Object.defineProperty(prototype, memberName, { | ||
| get() { | ||
| // proxyComponent, get value | ||
| return getValue(this, memberName); | ||
| }, | ||
| set(newValue) { | ||
| // proxyComponent, set value | ||
| setValue(this, memberName, newValue, cmpMeta); | ||
| }, | ||
| configurable: true, | ||
| enumerable: true, | ||
| }); | ||
| } | ||
| else if (flags & 1 /* isElementConstructor */ && memberFlags & 64 /* Method */) { | ||
| // proxyComponent - method | ||
| Object.defineProperty(prototype, memberName, { | ||
| value(...args) { | ||
| const ref = getHostRef(this); | ||
| return ref.$onInstancePromise$.then(() => ref.$lazyInstance$[memberName](...args)); | ||
| }, | ||
| }); | ||
| } | ||
| }); | ||
| if ((flags & 1 /* isElementConstructor */)) { | ||
| const attrNameToPropName = new Map(); | ||
| prototype.attributeChangedCallback = function (attrName, _oldValue, newValue) { | ||
| plt.jmp(() => { | ||
| const propName = attrNameToPropName.get(attrName); | ||
| this[propName] = newValue === null && typeof this[propName] === 'boolean' ? false : newValue; | ||
| }); | ||
| }; | ||
| // create an array of attributes to observe | ||
| // and also create a map of html attribute name to js property name | ||
| Cstr.observedAttributes = members | ||
| .filter(([_, m]) => m[0] & 15 /* HasAttribute */) // filter to only keep props that should match attributes | ||
| .map(([propName, m]) => { | ||
| const attrName = m[1] || propName; | ||
| attrNameToPropName.set(attrName, propName); | ||
| return attrName; | ||
| }); | ||
| } | ||
| } | ||
| return Cstr; | ||
| }; | ||
| const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId, Cstr) => { | ||
| // initializeComponent | ||
| if ((hostRef.$flags$ & 32 /* hasInitializedComponent */) === 0) { | ||
| { | ||
| // we haven't initialized this element yet | ||
| hostRef.$flags$ |= 32 /* hasInitializedComponent */; | ||
| // lazy loaded components | ||
| // request the component's implementation to be | ||
| // wired up with the host element | ||
| Cstr = loadModule(cmpMeta); | ||
| if (Cstr.then) { | ||
| // Await creates a micro-task avoid if possible | ||
| const endLoad = uniqueTime(); | ||
| Cstr = await Cstr; | ||
| endLoad(); | ||
| } | ||
| if (!Cstr.isProxied) { | ||
| // we'eve never proxied this Constructor before | ||
| // let's add the getters/setters to its prototype before | ||
| // the first time we create an instance of the implementation | ||
| { | ||
| cmpMeta.$watchers$ = Cstr.watchers; | ||
| } | ||
| proxyComponent(Cstr, cmpMeta, 2 /* proxyState */); | ||
| Cstr.isProxied = true; | ||
| } | ||
| const endNewInstance = createTime('createInstance', cmpMeta.$tagName$); | ||
| // ok, time to construct the instance | ||
| // but let's keep track of when we start and stop | ||
| // so that the getters/setters don't incorrectly step on data | ||
| { | ||
| hostRef.$flags$ |= 8 /* isConstructingInstance */; | ||
| } | ||
| // construct the lazy-loaded component implementation | ||
| // passing the hostRef is very important during | ||
| // construction in order to directly wire together the | ||
| // host element and the lazy-loaded instance | ||
| try { | ||
| new Cstr(hostRef); | ||
| } | ||
| catch (e) { | ||
| consoleError(e); | ||
| } | ||
| { | ||
| hostRef.$flags$ &= ~8 /* isConstructingInstance */; | ||
| } | ||
| { | ||
| hostRef.$flags$ |= 128 /* isWatchReady */; | ||
| } | ||
| endNewInstance(); | ||
| fireConnectedCallback(hostRef.$lazyInstance$); | ||
| } | ||
| if (Cstr.style) { | ||
| // this component has styles but we haven't registered them yet | ||
| let style = Cstr.style; | ||
| const scopeId = getScopeId(cmpMeta); | ||
| if (!styles.has(scopeId)) { | ||
| const endRegisterStyles = createTime('registerStyles', cmpMeta.$tagName$); | ||
| registerStyle(scopeId, style, !!(cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */)); | ||
| endRegisterStyles(); | ||
| } | ||
| } | ||
| } | ||
| // we've successfully created a lazy instance | ||
| const ancestorComponent = hostRef.$ancestorComponent$; | ||
| const schedule = () => scheduleUpdate(hostRef, true); | ||
| if (ancestorComponent && ancestorComponent['s-rc']) { | ||
| // this is the intial load and this component it has an ancestor component | ||
| // but the ancestor component has NOT fired its will update lifecycle yet | ||
| // so let's just cool our jets and wait for the ancestor to continue first | ||
| // this will get fired off when the ancestor component | ||
| // finally gets around to rendering its lazy self | ||
| // fire off the initial update | ||
| ancestorComponent['s-rc'].push(schedule); | ||
| } | ||
| else { | ||
| schedule(); | ||
| } | ||
| }; | ||
| const fireConnectedCallback = (instance) => { | ||
| { | ||
| safeCall(instance, 'connectedCallback'); | ||
| } | ||
| }; | ||
| const connectedCallback = (elm) => { | ||
| if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0) { | ||
| const hostRef = getHostRef(elm); | ||
| const cmpMeta = hostRef.$cmpMeta$; | ||
| const endConnected = createTime('connectedCallback', cmpMeta.$tagName$); | ||
| if (!(hostRef.$flags$ & 1 /* hasConnected */)) { | ||
| // first time this component has connected | ||
| hostRef.$flags$ |= 1 /* hasConnected */; | ||
| { | ||
| // find the first ancestor component (if there is one) and register | ||
| // this component as one of the actively loading child components for its ancestor | ||
| let ancestorComponent = elm; | ||
| while ((ancestorComponent = ancestorComponent.parentNode || ancestorComponent.host)) { | ||
| // climb up the ancestors looking for the first | ||
| // component that hasn't finished its lifecycle update yet | ||
| if (ancestorComponent['s-p']) { | ||
| // we found this components first ancestor component | ||
| // keep a reference to this component's ancestor component | ||
| attachToAncestor(hostRef, (hostRef.$ancestorComponent$ = ancestorComponent)); | ||
| break; | ||
| } | ||
| } | ||
| } | ||
| // Lazy properties | ||
| // https://developers.google.com/web/fundamentals/web-components/best-practices#lazy-properties | ||
| if (cmpMeta.$members$) { | ||
| Object.entries(cmpMeta.$members$).map(([memberName, [memberFlags]]) => { | ||
| if (memberFlags & 31 /* Prop */ && elm.hasOwnProperty(memberName)) { | ||
| const value = elm[memberName]; | ||
| delete elm[memberName]; | ||
| elm[memberName] = value; | ||
| } | ||
| }); | ||
| } | ||
| { | ||
| initializeComponent(elm, hostRef, cmpMeta); | ||
| } | ||
| } | ||
| else { | ||
| // fire off connectedCallback() on component instance | ||
| fireConnectedCallback(hostRef.$lazyInstance$); | ||
| } | ||
| endConnected(); | ||
| } | ||
| }; | ||
| const disconnectedCallback = (elm) => { | ||
| if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0) { | ||
| const hostRef = getHostRef(elm); | ||
| const instance = hostRef.$lazyInstance$ ; | ||
| { | ||
| safeCall(instance, 'disconnectedCallback'); | ||
| } | ||
| } | ||
| }; | ||
| const bootstrapLazy = (lazyBundles, options = {}) => { | ||
| const endBootstrap = createTime(); | ||
| const cmpTags = []; | ||
| const exclude = options.exclude || []; | ||
| const customElements = win.customElements; | ||
| const head = doc.head; | ||
| const metaCharset = /*@__PURE__*/ head.querySelector('meta[charset]'); | ||
| const visibilityStyle = /*@__PURE__*/ doc.createElement('style'); | ||
| const deferredConnectedCallbacks = []; | ||
| let appLoadFallback; | ||
| let isBootstrapping = true; | ||
| Object.assign(plt, options); | ||
| plt.$resourcesUrl$ = new URL(options.resourcesUrl || './', doc.baseURI).href; | ||
| lazyBundles.map(lazyBundle => lazyBundle[1].map(compactMeta => { | ||
| const cmpMeta = { | ||
| $flags$: compactMeta[0], | ||
| $tagName$: compactMeta[1], | ||
| $members$: compactMeta[2], | ||
| $listeners$: compactMeta[3], | ||
| }; | ||
| { | ||
| cmpMeta.$members$ = compactMeta[2]; | ||
| } | ||
| { | ||
| cmpMeta.$watchers$ = {}; | ||
| } | ||
| const tagName = cmpMeta.$tagName$; | ||
| const HostElement = class extends HTMLElement { | ||
| // StencilLazyHost | ||
| constructor(self) { | ||
| // @ts-ignore | ||
| super(self); | ||
| self = this; | ||
| registerHost(self, cmpMeta); | ||
| if (cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) { | ||
| // this component is using shadow dom | ||
| // and this browser supports shadow dom | ||
| // add the read-only property "shadowRoot" to the host element | ||
| // adding the shadow root build conditionals to minimize runtime | ||
| { | ||
| { | ||
| self.attachShadow({ mode: 'open' }); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| connectedCallback() { | ||
| if (appLoadFallback) { | ||
| clearTimeout(appLoadFallback); | ||
| appLoadFallback = null; | ||
| } | ||
| if (isBootstrapping) { | ||
| // connectedCallback will be processed once all components have been registered | ||
| deferredConnectedCallbacks.push(this); | ||
| } | ||
| else { | ||
| plt.jmp(() => connectedCallback(this)); | ||
| } | ||
| } | ||
| disconnectedCallback() { | ||
| plt.jmp(() => disconnectedCallback(this)); | ||
| } | ||
| componentOnReady() { | ||
| return getHostRef(this).$onReadyPromise$; | ||
| } | ||
| }; | ||
| cmpMeta.$lazyBundleId$ = lazyBundle[0]; | ||
| if (!exclude.includes(tagName) && !customElements.get(tagName)) { | ||
| cmpTags.push(tagName); | ||
| customElements.define(tagName, proxyComponent(HostElement, cmpMeta, 1 /* isElementConstructor */)); | ||
| } | ||
| })); | ||
| { | ||
| visibilityStyle.innerHTML = cmpTags + HYDRATED_CSS; | ||
| visibilityStyle.setAttribute('data-styles', ''); | ||
| head.insertBefore(visibilityStyle, metaCharset ? metaCharset.nextSibling : head.firstChild); | ||
| } | ||
| // Process deferred connectedCallbacks now all components have been registered | ||
| isBootstrapping = false; | ||
| if (deferredConnectedCallbacks.length) { | ||
| deferredConnectedCallbacks.map(host => host.connectedCallback()); | ||
| } | ||
| else { | ||
| { | ||
| plt.jmp(() => (appLoadFallback = setTimeout(appDidLoad, 30))); | ||
| } | ||
| } | ||
| // Fallback appLoad event | ||
| endBootstrap(); | ||
| }; | ||
| const hostRefs = new WeakMap(); | ||
| const getHostRef = (ref) => hostRefs.get(ref); | ||
| const registerInstance = (lazyInstance, hostRef) => hostRefs.set((hostRef.$lazyInstance$ = lazyInstance), hostRef); | ||
| const registerHost = (elm, cmpMeta) => { | ||
| const hostRef = { | ||
| $flags$: 0, | ||
| $hostElement$: elm, | ||
| $cmpMeta$: cmpMeta, | ||
| $instanceValues$: new Map(), | ||
| }; | ||
| { | ||
| hostRef.$onInstancePromise$ = new Promise(r => (hostRef.$onInstanceResolve$ = r)); | ||
| } | ||
| { | ||
| hostRef.$onReadyPromise$ = new Promise(r => (hostRef.$onReadyResolve$ = r)); | ||
| elm['s-p'] = []; | ||
| elm['s-rc'] = []; | ||
| } | ||
| return hostRefs.set(elm, hostRef); | ||
| }; | ||
| const isMemberInElement = (elm, memberName) => memberName in elm; | ||
| const consoleError = (e, el) => (0, console.error)(e, el); | ||
| const cmpModules = /*@__PURE__*/ new Map(); | ||
| const loadModule = (cmpMeta, hostRef, hmrVersionId) => { | ||
| // loadModuleImport | ||
| const exportName = cmpMeta.$tagName$.replace(/-/g, '_'); | ||
| const bundleId = cmpMeta.$lazyBundleId$; | ||
| const module = cmpModules.get(bundleId) ; | ||
| if (module) { | ||
| return module[exportName]; | ||
| } | ||
| return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require( | ||
| /* webpackInclude: /\.entry\.js$/ */ | ||
| /* webpackExclude: /\.system\.entry\.js$/ */ | ||
| /* webpackMode: "lazy" */ | ||
| `./${bundleId}.entry.js${''}`)); }).then(importedModule => { | ||
| { | ||
| cmpModules.set(bundleId, importedModule); | ||
| } | ||
| return importedModule[exportName]; | ||
| }, consoleError); | ||
| }; | ||
| const styles = new Map(); | ||
| const queueDomReads = []; | ||
| const queueDomWrites = []; | ||
| const queueTask = (queue, write) => (cb) => { | ||
| queue.push(cb); | ||
| if (!queuePending) { | ||
| queuePending = true; | ||
| if (write && plt.$flags$ & 4 /* queueSync */) { | ||
| nextTick(flush); | ||
| } | ||
| else { | ||
| plt.raf(flush); | ||
| } | ||
| } | ||
| }; | ||
| const consume = (queue) => { | ||
| for (let i = 0; i < queue.length; i++) { | ||
| try { | ||
| queue[i](performance.now()); | ||
| } | ||
| catch (e) { | ||
| consoleError(e); | ||
| } | ||
| } | ||
| queue.length = 0; | ||
| }; | ||
| const flush = () => { | ||
| // always force a bunch of medium callbacks to run, but still have | ||
| // a throttle on how many can run in a certain time | ||
| // DOM READS!!! | ||
| consume(queueDomReads); | ||
| // DOM WRITES!!! | ||
| { | ||
| consume(queueDomWrites); | ||
| if ((queuePending = queueDomReads.length > 0)) { | ||
| // still more to do yet, but we've run out of time | ||
| // let's let this thing cool off and try again in the next tick | ||
| plt.raf(flush); | ||
| } | ||
| } | ||
| }; | ||
| const nextTick = /*@__PURE__*/ (cb) => promiseResolve().then(cb); | ||
| const writeTask = /*@__PURE__*/ queueTask(queueDomWrites, true); | ||
| exports.Host = Host; | ||
| exports.bootstrapLazy = bootstrapLazy; | ||
| exports.createEvent = createEvent; | ||
| exports.getElement = getElement; | ||
| exports.h = h; | ||
| exports.promiseResolve = promiseResolve; | ||
| exports.registerInstance = registerInstance; |
| let e,t,n=!1;const l="undefined"!=typeof window?window:{},s=l.document||{head:{}},o={t:0,l:"",jmp:e=>e(),raf:e=>requestAnimationFrame(e),ael:(e,t,n,l)=>e.addEventListener(t,n,l),rel:(e,t,n,l)=>e.removeEventListener(t,n,l),ce:(e,t)=>new CustomEvent(e,t)},c=e=>Promise.resolve(e),r=(()=>{try{return new CSSStyleSheet,"function"==typeof(new CSSStyleSheet).replace}catch(e){}return!1})(),i=new WeakMap,a=e=>"sc-"+e.o,u={},f=e=>"object"==(e=typeof e)||"function"===e,d=(e,t,...n)=>{let l=null,s=!1,o=!1,c=[];const r=t=>{for(let n=0;n<t.length;n++)l=t[n],Array.isArray(l)?r(l):null!=l&&"boolean"!=typeof l&&((s="function"!=typeof e&&!f(l))&&(l+=""),s&&o?c[c.length-1].i+=l:c.push(s?$(null,l):l),o=s)};if(r(n),t){const e=t.className||t.class;e&&(t.class="object"!=typeof e?e:Object.keys(e).filter((t=>e[t])).join(" "))}const i=$(e,null);return i.u=t,c.length>0&&(i.$=c),i},$=(e,t)=>({t:0,p:e,i:t,h:null,$:null,u:null}),y={},p=(e,t,n,s,c,r)=>{if(n!==s){let i=B(e,t),a=t.toLowerCase();if("class"===t){const t=e.classList,l=m(n),o=m(s);t.remove(...l.filter((e=>e&&!o.includes(e)))),t.add(...o.filter((e=>e&&!l.includes(e))))}else if("style"===t){for(const t in n)s&&null!=s[t]||(t.includes("-")?e.style.removeProperty(t):e.style[t]="");for(const t in s)n&&s[t]===n[t]||(t.includes("-")?e.style.setProperty(t,s[t]):e.style[t]=s[t])}else if("ref"===t)s&&s(e);else if(i||"o"!==t[0]||"n"!==t[1]){const l=f(s);if((i||l&&null!==s)&&!c)try{if(e.tagName.includes("-"))e[t]=s;else{let l=null==s?"":s;"list"===t?i=!1:null!=n&&e[t]==l||(e[t]=l)}}catch(e){}null==s||!1===s?!1===s&&""!==e.getAttribute(t)||e.removeAttribute(t):(!i||4&r||c)&&!l&&e.setAttribute(t,s=!0===s?"":s)}else t="-"===t[2]?t.slice(3):B(l,a)?a.slice(2):a[2]+t.slice(3),n&&o.rel(e,t,n,!1),s&&o.ael(e,t,s,!1)}},h=/\s/,m=e=>e?e.split(h):[],b=(e,t,n,l)=>{const s=11===t.h.nodeType&&t.h.host?t.h.host:t.h,o=e&&e.u||u,c=t.u||u;for(l in o)l in c||p(s,l,o[l],void 0,n,t.t);for(l in c)p(s,l,o[l],c[l],n,t.t)},w=(t,n,l)=>{let o,c,r=n.$[l],i=0;if(null!==r.i)o=r.h=s.createTextNode(r.i);else if(o=r.h=s.createElement(r.p),b(null,r,!1),null!=e&&o["s-si"]!==e&&o.classList.add(o["s-si"]=e),r.$)for(i=0;i<r.$.length;++i)c=w(t,r,i),c&&o.appendChild(c);return o},S=(e,n,l,s,o,c)=>{let r,i=e;for(i.shadowRoot&&i.tagName===t&&(i=i.shadowRoot);o<=c;++o)s[o]&&(r=w(null,l,o),r&&(s[o].h=r,i.insertBefore(r,n)))},g=(e,t,n,l,s)=>{for(;t<=n;++t)(l=e[t])&&(s=l.h,v(l),s.remove())},j=(e,t)=>e.p===t.p,k=(e,t)=>{const n=t.h=e.h,l=e.$,s=t.$,o=t.i;null===o?("slot"===t.p||b(e,t,!1),null!==l&&null!==s?((e,t,n,l)=>{let s,o=0,c=0,r=t.length-1,i=t[0],a=t[r],u=l.length-1,f=l[0],d=l[u];for(;o<=r&&c<=u;)null==i?i=t[++o]:null==a?a=t[--r]:null==f?f=l[++c]:null==d?d=l[--u]:j(i,f)?(k(i,f),i=t[++o],f=l[++c]):j(a,d)?(k(a,d),a=t[--r],d=l[--u]):j(i,d)?(k(i,d),e.insertBefore(i.h,a.h.nextSibling),i=t[++o],d=l[--u]):j(a,f)?(k(a,f),e.insertBefore(a.h,i.h),a=t[--r],f=l[++c]):(s=w(t&&t[c],n,c),f=l[++c],s&&i.h.parentNode.insertBefore(s,i.h));o>r?S(e,null==l[u+1]?null:l[u+1].h,n,l,c,u):c>u&&g(t,o,r)})(n,l,t,s):null!==s?(null!==e.i&&(n.textContent=""),S(n,null,t,s,0,s.length-1)):null!==l&&g(l,0,l.length-1)):e.i!==o&&(n.data=o)},v=e=>{e.u&&e.u.ref&&e.u.ref(null),e.$&&e.$.map(v)},C=e=>V(e).m,M=(e,t,n)=>{const l=C(e);return{emit:e=>O(l,t,{bubbles:!!(4&n),composed:!!(2&n),cancelable:!!(1&n),detail:e})}},O=(e,t,n)=>{const l=o.ce(t,n);return e.dispatchEvent(l),l},P=(e,t)=>{t&&!e.S&&t["s-p"]&&t["s-p"].push(new Promise((t=>e.S=t)))},L=(e,t)=>{if(e.t|=16,!(4&e.t))return P(e,e.g),ne((()=>x(e,t)));e.t|=512},x=(e,t)=>{const n=e.j;let l;return t&&(l=F(n,"componentWillLoad")),H(l,(()=>E(e,n,t)))},E=async(e,t,n)=>{const l=e.m,o=l["s-rc"];n&&(e=>{const t=e.k,n=e.m,l=t.t,o=((e,t)=>{let n=a(t),l=K.get(n);if(e=11===e.nodeType?e:s,l)if("string"==typeof l){let t,o=i.get(e=e.head||e);o||i.set(e,o=new Set),o.has(n)||(t=s.createElement("style"),t.innerHTML=l,e.insertBefore(t,e.querySelector("link")),o&&o.add(n))}else e.adoptedStyleSheets.includes(l)||(e.adoptedStyleSheets=[...e.adoptedStyleSheets,l]);return n})(n.shadowRoot?n.shadowRoot:n.getRootNode(),t);10&l&&(n["s-sc"]=o,n.classList.add(o+"-h"))})(e);T(e,t),o&&(o.map((e=>e())),l["s-rc"]=void 0);{const t=l["s-p"],n=()=>W(e);0===t.length?n():(Promise.all(t).then(n),e.t|=4,t.length=0)}},T=(n,l)=>{try{l=l.render(),n.t&=-17,n.t|=2,((n,l)=>{const s=n.m,o=n.v||$(null,null),c=(e=>e&&e.p===y)(l)?l:d(null,null,l);t=s.tagName,c.p=null,c.t|=4,n.v=c,c.h=o.h=s.shadowRoot||s,e=s["s-sc"],k(o,c)})(n,l)}catch(e){G(e,n.m)}return null},W=e=>{const t=e.m,n=e.j,l=e.g;64&e.t||(e.t|=64,R(t),F(n,"componentDidLoad"),e.C(t),l||A()),e.M(t),e.S&&(e.S(),e.S=void 0),512&e.t&&te((()=>L(e,!1))),e.t&=-517},A=()=>{R(s.documentElement),te((()=>O(l,"appload",{detail:{namespace:"deckdeckgo-inline-editor"}})))},F=(e,t,n)=>{if(e&&e[t])try{return e[t](n)}catch(e){G(e)}},H=(e,t)=>e&&e.then?e.then(t):t(),R=e=>e.classList.add("hydrated"),U=(e,t,n)=>{if(t.O){e.watchers&&(t.P=e.watchers);const l=Object.entries(t.O),s=e.prototype;if(l.map((([e,[l]])=>{31&l||2&n&&32&l?Object.defineProperty(s,e,{get(){return((e,t)=>V(this).L.get(t))(0,e)},set(n){((e,t,n,l)=>{const s=V(e),o=s.m,c=s.L.get(t),r=s.t,i=s.j;if(n=((e,t)=>null==e||f(e)?e:4&t?"false"!==e&&(""===e||!!e):2&t?parseFloat(e):1&t?e+"":e)(n,l.O[t][0]),!(8&r&&void 0!==c||n===c)&&(s.L.set(t,n),i)){if(l.P&&128&r){const e=l.P[t];e&&e.map((e=>{try{i[e](n,c,t)}catch(e){G(e,o)}}))}2==(18&r)&&L(s,!1)}})(this,e,n,t)},configurable:!0,enumerable:!0}):1&n&&64&l&&Object.defineProperty(s,e,{value(...t){const n=V(this);return n.T.then((()=>n.j[e](...t)))}})})),1&n){const t=new Map;s.attributeChangedCallback=function(e,n,l){o.jmp((()=>{const n=t.get(e);this[n]=(null!==l||"boolean"!=typeof this[n])&&l}))},e.observedAttributes=l.filter((([e,t])=>15&t[0])).map((([e,n])=>{const l=n[1]||e;return t.set(l,e),l}))}}return e},q=e=>{F(e,"connectedCallback")},D=(e,t={})=>{const n=[],c=t.exclude||[],i=l.customElements,u=s.head,f=u.querySelector("meta[charset]"),d=s.createElement("style"),$=[];let y,p=!0;Object.assign(o,t),o.l=new URL(t.resourcesUrl||"./",s.baseURI).href,e.map((e=>e[1].map((t=>{const l={t:t[0],o:t[1],O:t[2],W:t[3]};l.O=t[2],l.P={};const s=l.o,u=class extends HTMLElement{constructor(e){super(e),z(e=this,l),1&l.t&&e.attachShadow({mode:"open"})}connectedCallback(){y&&(clearTimeout(y),y=null),p?$.push(this):o.jmp((()=>(e=>{if(0==(1&o.t)){const t=V(e),n=t.k,l=()=>{};if(1&t.t)q(t.j);else{t.t|=1;{let n=e;for(;n=n.parentNode||n.host;)if(n["s-p"]){P(t,t.g=n);break}}n.O&&Object.entries(n.O).map((([t,[n]])=>{if(31&n&&e.hasOwnProperty(t)){const n=e[t];delete e[t],e[t]=n}})),(async(e,t,n,l,s)=>{if(0==(32&t.t)){{if(t.t|=32,(s=J(n)).then){const e=()=>{};s=await s,e()}s.isProxied||(n.P=s.watchers,U(s,n,2),s.isProxied=!0);const e=()=>{};t.t|=8;try{new s(t)}catch(e){G(e)}t.t&=-9,t.t|=128,e(),q(t.j)}if(s.style){let e=s.style;const t=a(n);if(!K.has(t)){const l=()=>{};((e,t,n)=>{let l=K.get(e);r&&n?(l=l||new CSSStyleSheet,l.replace(t)):l=t,K.set(e,l)})(t,e,!!(1&n.t)),l()}}}const o=t.g,c=()=>L(t,!0);o&&o["s-rc"]?o["s-rc"].push(c):c()})(0,t,n)}l()}})(this)))}disconnectedCallback(){o.jmp((()=>(()=>{0==(1&o.t)&&F(V(this).j,"disconnectedCallback")})()))}componentOnReady(){return V(this).A}};l.F=e[0],c.includes(s)||i.get(s)||(n.push(s),i.define(s,U(u,l,1)))})))),d.innerHTML=n+"{visibility:hidden}.hydrated{visibility:inherit}",d.setAttribute("data-styles",""),u.insertBefore(d,f?f.nextSibling:u.firstChild),p=!1,$.length?$.map((e=>e.connectedCallback())):o.jmp((()=>y=setTimeout(A,30)))},N=new WeakMap,V=e=>N.get(e),_=(e,t)=>N.set(t.j=e,t),z=(e,t)=>{const n={t:0,m:e,k:t,L:new Map};return n.T=new Promise((e=>n.M=e)),n.A=new Promise((e=>n.C=e)),e["s-p"]=[],e["s-rc"]=[],N.set(e,n)},B=(e,t)=>t in e,G=(e,t)=>(0,console.error)(e,t),I=new Map,J=e=>{const t=e.o.replace(/-/g,"_"),n=e.F,l=I.get(n);return l?l[t]:import(`./${n}.entry.js`).then((e=>(I.set(n,e),e[t])),G)},K=new Map,Q=[],X=[],Y=(e,t)=>l=>{e.push(l),n||(n=!0,t&&4&o.t?te(ee):o.raf(ee))},Z=e=>{for(let t=0;t<e.length;t++)try{e[t](performance.now())}catch(e){G(e)}e.length=0},ee=()=>{Z(Q),Z(X),(n=Q.length>0)&&o.raf(ee)},te=e=>c().then(e),ne=Y(X,!0);export{y as H,D as b,M as c,C as g,d as h,c as p,_ as r} |
Sorry, the diff of this file is too big to display
| const NAMESPACE = 'deckdeckgo-inline-editor'; | ||
| let scopeId; | ||
| let hostTagName; | ||
| let isSvgMode = false; | ||
| let queuePending = false; | ||
| const win = typeof window !== 'undefined' ? window : {}; | ||
| const doc = win.document || { head: {} }; | ||
| const plt = { | ||
| $flags$: 0, | ||
| $resourcesUrl$: '', | ||
| jmp: h => h(), | ||
| raf: h => requestAnimationFrame(h), | ||
| ael: (el, eventName, listener, opts) => el.addEventListener(eventName, listener, opts), | ||
| rel: (el, eventName, listener, opts) => el.removeEventListener(eventName, listener, opts), | ||
| ce: (eventName, opts) => new CustomEvent(eventName, opts), | ||
| }; | ||
| const promiseResolve = (v) => Promise.resolve(v); | ||
| const supportsConstructibleStylesheets = /*@__PURE__*/ (() => { | ||
| try { | ||
| new CSSStyleSheet(); | ||
| return typeof (new CSSStyleSheet()).replace === 'function'; | ||
| } | ||
| catch (e) { } | ||
| return false; | ||
| })() | ||
| ; | ||
| const HYDRATED_CSS = '{visibility:hidden}.hydrated{visibility:inherit}'; | ||
| const createTime = (fnName, tagName = '') => { | ||
| { | ||
| return () => { | ||
| return; | ||
| }; | ||
| } | ||
| }; | ||
| const uniqueTime = (key, measureText) => { | ||
| { | ||
| return () => { | ||
| return; | ||
| }; | ||
| } | ||
| }; | ||
| const rootAppliedStyles = new WeakMap(); | ||
| const registerStyle = (scopeId, cssText, allowCS) => { | ||
| let style = styles.get(scopeId); | ||
| if (supportsConstructibleStylesheets && allowCS) { | ||
| style = (style || new CSSStyleSheet()); | ||
| style.replace(cssText); | ||
| } | ||
| else { | ||
| style = cssText; | ||
| } | ||
| styles.set(scopeId, style); | ||
| }; | ||
| const addStyle = (styleContainerNode, cmpMeta, mode, hostElm) => { | ||
| let scopeId = getScopeId(cmpMeta); | ||
| let style = styles.get(scopeId); | ||
| // if an element is NOT connected then getRootNode() will return the wrong root node | ||
| // so the fallback is to always use the document for the root node in those cases | ||
| styleContainerNode = styleContainerNode.nodeType === 11 /* DocumentFragment */ ? styleContainerNode : doc; | ||
| if (style) { | ||
| if (typeof style === 'string') { | ||
| styleContainerNode = styleContainerNode.head || styleContainerNode; | ||
| let appliedStyles = rootAppliedStyles.get(styleContainerNode); | ||
| let styleElm; | ||
| if (!appliedStyles) { | ||
| rootAppliedStyles.set(styleContainerNode, (appliedStyles = new Set())); | ||
| } | ||
| if (!appliedStyles.has(scopeId)) { | ||
| { | ||
| { | ||
| styleElm = doc.createElement('style'); | ||
| styleElm.innerHTML = style; | ||
| } | ||
| styleContainerNode.insertBefore(styleElm, styleContainerNode.querySelector('link')); | ||
| } | ||
| if (appliedStyles) { | ||
| appliedStyles.add(scopeId); | ||
| } | ||
| } | ||
| } | ||
| else if (!styleContainerNode.adoptedStyleSheets.includes(style)) { | ||
| styleContainerNode.adoptedStyleSheets = [...styleContainerNode.adoptedStyleSheets, style]; | ||
| } | ||
| } | ||
| return scopeId; | ||
| }; | ||
| const attachStyles = (hostRef) => { | ||
| const cmpMeta = hostRef.$cmpMeta$; | ||
| const elm = hostRef.$hostElement$; | ||
| const flags = cmpMeta.$flags$; | ||
| const endAttachStyles = createTime('attachStyles', cmpMeta.$tagName$); | ||
| const scopeId = addStyle(elm.shadowRoot ? elm.shadowRoot : elm.getRootNode(), cmpMeta); | ||
| if (flags & 10 /* needsScopedEncapsulation */) { | ||
| // 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 | ||
| // DOM WRITE!! | ||
| elm['s-sc'] = scopeId; | ||
| elm.classList.add(scopeId + '-h'); | ||
| } | ||
| endAttachStyles(); | ||
| }; | ||
| const getScopeId = (cmp, mode) => 'sc-' + (cmp.$tagName$); | ||
| /** | ||
| * Default style mode id | ||
| */ | ||
| /** | ||
| * Reusable empty obj/array | ||
| * Don't add values to these!! | ||
| */ | ||
| const EMPTY_OBJ = {}; | ||
| const isDef = (v) => v != null; | ||
| const isComplexType = (o) => { | ||
| // https://jsperf.com/typeof-fn-object/5 | ||
| o = typeof o; | ||
| return o === 'object' || o === 'function'; | ||
| }; | ||
| /** | ||
| * Production h() function based on Preact by | ||
| * Jason Miller (@developit) | ||
| * Licensed under the MIT License | ||
| * https://github.com/developit/preact/blob/master/LICENSE | ||
| * | ||
| * Modified for Stencil's compiler and vdom | ||
| */ | ||
| // const stack: any[] = []; | ||
| // export function h(nodeName: string | d.FunctionalComponent, vnodeData: d.PropsType, child?: d.ChildType): d.VNode; | ||
| // export function h(nodeName: string | d.FunctionalComponent, vnodeData: d.PropsType, ...children: d.ChildType[]): d.VNode; | ||
| const h = (nodeName, vnodeData, ...children) => { | ||
| let child = null; | ||
| let simple = false; | ||
| let lastSimple = false; | ||
| let vNodeChildren = []; | ||
| const walk = (c) => { | ||
| for (let i = 0; i < c.length; i++) { | ||
| child = c[i]; | ||
| if (Array.isArray(child)) { | ||
| walk(child); | ||
| } | ||
| else if (child != null && typeof child !== 'boolean') { | ||
| if ((simple = typeof nodeName !== 'function' && !isComplexType(child))) { | ||
| child = String(child); | ||
| } | ||
| if (simple && lastSimple) { | ||
| // If the previous child was simple (string), we merge both | ||
| vNodeChildren[vNodeChildren.length - 1].$text$ += child; | ||
| } | ||
| else { | ||
| // Append a new vNode, if it's text, we create a text vNode | ||
| vNodeChildren.push(simple ? newVNode(null, child) : child); | ||
| } | ||
| lastSimple = simple; | ||
| } | ||
| } | ||
| }; | ||
| walk(children); | ||
| if (vnodeData) { | ||
| { | ||
| const classData = vnodeData.className || vnodeData.class; | ||
| if (classData) { | ||
| vnodeData.class = | ||
| typeof classData !== 'object' | ||
| ? classData | ||
| : Object.keys(classData) | ||
| .filter(k => classData[k]) | ||
| .join(' '); | ||
| } | ||
| } | ||
| } | ||
| const vnode = newVNode(nodeName, null); | ||
| vnode.$attrs$ = vnodeData; | ||
| if (vNodeChildren.length > 0) { | ||
| vnode.$children$ = vNodeChildren; | ||
| } | ||
| return vnode; | ||
| }; | ||
| const newVNode = (tag, text) => { | ||
| const vnode = { | ||
| $flags$: 0, | ||
| $tag$: tag, | ||
| $text$: text, | ||
| $elm$: null, | ||
| $children$: null, | ||
| }; | ||
| { | ||
| vnode.$attrs$ = null; | ||
| } | ||
| return vnode; | ||
| }; | ||
| const Host = {}; | ||
| const isHost = (node) => node && node.$tag$ === Host; | ||
| /** | ||
| * Production setAccessor() function based on Preact by | ||
| * Jason Miller (@developit) | ||
| * Licensed under the MIT License | ||
| * https://github.com/developit/preact/blob/master/LICENSE | ||
| * | ||
| * Modified for Stencil's compiler and vdom | ||
| */ | ||
| const setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags) => { | ||
| if (oldValue !== newValue) { | ||
| let isProp = isMemberInElement(elm, memberName); | ||
| let ln = memberName.toLowerCase(); | ||
| if (memberName === 'class') { | ||
| const classList = elm.classList; | ||
| const oldClasses = parseClassList(oldValue); | ||
| const newClasses = parseClassList(newValue); | ||
| classList.remove(...oldClasses.filter(c => c && !newClasses.includes(c))); | ||
| classList.add(...newClasses.filter(c => c && !oldClasses.includes(c))); | ||
| } | ||
| else if (memberName === 'style') { | ||
| // update style attribute, css properties and values | ||
| { | ||
| for (const prop in oldValue) { | ||
| if (!newValue || newValue[prop] == null) { | ||
| if (prop.includes('-')) { | ||
| elm.style.removeProperty(prop); | ||
| } | ||
| else { | ||
| elm.style[prop] = ''; | ||
| } | ||
| } | ||
| } | ||
| } | ||
| for (const prop in newValue) { | ||
| if (!oldValue || newValue[prop] !== oldValue[prop]) { | ||
| if (prop.includes('-')) { | ||
| elm.style.setProperty(prop, newValue[prop]); | ||
| } | ||
| else { | ||
| elm.style[prop] = newValue[prop]; | ||
| } | ||
| } | ||
| } | ||
| } | ||
| else if (memberName === 'ref') { | ||
| // minifier will clean this up | ||
| if (newValue) { | ||
| newValue(elm); | ||
| } | ||
| } | ||
| else if ((!isProp ) && memberName[0] === 'o' && memberName[1] === 'n') { | ||
| // Event Handlers | ||
| // so if the member name starts with "on" and the 3rd characters is | ||
| // a capital letter, and it's not already a member on the element, | ||
| // then we're assuming it's an event listener | ||
| if (memberName[2] === '-') { | ||
| // on- prefixed events | ||
| // allows to be explicit about the dom event to listen without any magic | ||
| // under the hood: | ||
| // <my-cmp on-click> // listens for "click" | ||
| // <my-cmp on-Click> // listens for "Click" | ||
| // <my-cmp on-ionChange> // listens for "ionChange" | ||
| // <my-cmp on-EVENTS> // listens for "EVENTS" | ||
| memberName = memberName.slice(3); | ||
| } | ||
| else if (isMemberInElement(win, ln)) { | ||
| // standard event | ||
| // the JSX attribute could have been "onMouseOver" and the | ||
| // member name "onmouseover" is on the window's prototype | ||
| // so let's add the listener "mouseover", which is all lowercased | ||
| memberName = ln.slice(2); | ||
| } | ||
| else { | ||
| // custom event | ||
| // the JSX attribute could have been "onMyCustomEvent" | ||
| // so let's trim off the "on" prefix and lowercase the first character | ||
| // and add the listener "myCustomEvent" | ||
| // except for the first character, we keep the event name case | ||
| memberName = ln[2] + memberName.slice(3); | ||
| } | ||
| if (oldValue) { | ||
| plt.rel(elm, memberName, oldValue, false); | ||
| } | ||
| if (newValue) { | ||
| plt.ael(elm, memberName, newValue, false); | ||
| } | ||
| } | ||
| else { | ||
| // Set property if it exists and it's not a SVG | ||
| const isComplex = isComplexType(newValue); | ||
| if ((isProp || (isComplex && newValue !== null)) && !isSvg) { | ||
| try { | ||
| if (!elm.tagName.includes('-')) { | ||
| let n = newValue == null ? '' : newValue; | ||
| // Workaround for Safari, moving the <input> caret when re-assigning the same valued | ||
| if (memberName === 'list') { | ||
| isProp = false; | ||
| // tslint:disable-next-line: triple-equals | ||
| } | ||
| else if (oldValue == null || elm[memberName] != n) { | ||
| elm[memberName] = n; | ||
| } | ||
| } | ||
| else { | ||
| elm[memberName] = newValue; | ||
| } | ||
| } | ||
| catch (e) { } | ||
| } | ||
| if (newValue == null || newValue === false) { | ||
| if (newValue !== false || elm.getAttribute(memberName) === '') { | ||
| { | ||
| elm.removeAttribute(memberName); | ||
| } | ||
| } | ||
| } | ||
| else if ((!isProp || flags & 4 /* isHost */ || isSvg) && !isComplex) { | ||
| newValue = newValue === true ? '' : newValue; | ||
| { | ||
| elm.setAttribute(memberName, newValue); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| }; | ||
| const parseClassListRegex = /\s/; | ||
| const parseClassList = (value) => (!value ? [] : value.split(parseClassListRegex)); | ||
| const updateElement = (oldVnode, newVnode, isSvgMode, memberName) => { | ||
| // if the element passed in is a shadow root, which is a document fragment | ||
| // then we want to be adding attrs/props to the shadow root's "host" element | ||
| // if it's not a shadow root, then we add attrs/props to the same element | ||
| const elm = newVnode.$elm$.nodeType === 11 /* DocumentFragment */ && newVnode.$elm$.host ? newVnode.$elm$.host : newVnode.$elm$; | ||
| const oldVnodeAttrs = (oldVnode && oldVnode.$attrs$) || EMPTY_OBJ; | ||
| const newVnodeAttrs = newVnode.$attrs$ || EMPTY_OBJ; | ||
| { | ||
| // remove attributes no longer present on the vnode by setting them to undefined | ||
| for (memberName in oldVnodeAttrs) { | ||
| if (!(memberName in newVnodeAttrs)) { | ||
| setAccessor(elm, memberName, oldVnodeAttrs[memberName], undefined, isSvgMode, newVnode.$flags$); | ||
| } | ||
| } | ||
| } | ||
| // add new & update changed attributes | ||
| for (memberName in newVnodeAttrs) { | ||
| setAccessor(elm, memberName, oldVnodeAttrs[memberName], newVnodeAttrs[memberName], isSvgMode, newVnode.$flags$); | ||
| } | ||
| }; | ||
| const createElm = (oldParentVNode, newParentVNode, childIndex, parentElm) => { | ||
| // tslint:disable-next-line: prefer-const | ||
| let newVNode = newParentVNode.$children$[childIndex]; | ||
| 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. | ||
| { | ||
| updateElement(null, newVNode, isSvgMode); | ||
| } | ||
| if (isDef(scopeId) && elm['s-si'] !== scopeId) { | ||
| // if there is a scopeId and this is the initial render | ||
| // then let's add the scopeId as a css class | ||
| elm.classList.add((elm['s-si'] = scopeId)); | ||
| } | ||
| if (newVNode.$children$) { | ||
| for (i = 0; i < newVNode.$children$.length; ++i) { | ||
| // create the node | ||
| childNode = createElm(oldParentVNode, newVNode, i); | ||
| // return node could have been null | ||
| if (childNode) { | ||
| // append our new node | ||
| elm.appendChild(childNode); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| return elm; | ||
| }; | ||
| const addVnodes = (parentElm, before, parentVNode, vnodes, startIdx, endIdx) => { | ||
| 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); | ||
| if (childNode) { | ||
| vnodes[startIdx].$elm$ = childNode; | ||
| containerElm.insertBefore(childNode, before); | ||
| } | ||
| } | ||
| } | ||
| }; | ||
| const removeVnodes = (vnodes, startIdx, endIdx, vnode, elm) => { | ||
| for (; startIdx <= endIdx; ++startIdx) { | ||
| if ((vnode = vnodes[startIdx])) { | ||
| elm = vnode.$elm$; | ||
| callNodeRefs(vnode); | ||
| // remove the vnode's element from the dom | ||
| elm.remove(); | ||
| } | ||
| } | ||
| }; | ||
| const updateChildren = (parentElm, oldCh, newVNode, newCh) => { | ||
| let oldStartIdx = 0; | ||
| let newStartIdx = 0; | ||
| let oldEndIdx = oldCh.length - 1; | ||
| let oldStartVnode = oldCh[0]; | ||
| let oldEndVnode = oldCh[oldEndIdx]; | ||
| let newEndIdx = newCh.length - 1; | ||
| let newStartVnode = newCh[0]; | ||
| let newEndVnode = newCh[newEndIdx]; | ||
| let node; | ||
| while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) { | ||
| if (oldStartVnode == null) { | ||
| // Vnode might have been moved left | ||
| oldStartVnode = oldCh[++oldStartIdx]; | ||
| } | ||
| else if (oldEndVnode == null) { | ||
| oldEndVnode = oldCh[--oldEndIdx]; | ||
| } | ||
| else if (newStartVnode == null) { | ||
| newStartVnode = newCh[++newStartIdx]; | ||
| } | ||
| else if (newEndVnode == null) { | ||
| newEndVnode = newCh[--newEndIdx]; | ||
| } | ||
| else if (isSameVnode(oldStartVnode, newStartVnode)) { | ||
| patch(oldStartVnode, newStartVnode); | ||
| oldStartVnode = oldCh[++oldStartIdx]; | ||
| newStartVnode = newCh[++newStartIdx]; | ||
| } | ||
| else if (isSameVnode(oldEndVnode, newEndVnode)) { | ||
| patch(oldEndVnode, newEndVnode); | ||
| oldEndVnode = oldCh[--oldEndIdx]; | ||
| newEndVnode = newCh[--newEndIdx]; | ||
| } | ||
| else if (isSameVnode(oldStartVnode, newEndVnode)) { | ||
| patch(oldStartVnode, newEndVnode); | ||
| parentElm.insertBefore(oldStartVnode.$elm$, oldEndVnode.$elm$.nextSibling); | ||
| oldStartVnode = oldCh[++oldStartIdx]; | ||
| newEndVnode = newCh[--newEndIdx]; | ||
| } | ||
| else if (isSameVnode(oldEndVnode, newStartVnode)) { | ||
| patch(oldEndVnode, newStartVnode); | ||
| parentElm.insertBefore(oldEndVnode.$elm$, oldStartVnode.$elm$); | ||
| oldEndVnode = oldCh[--oldEndIdx]; | ||
| newStartVnode = newCh[++newStartIdx]; | ||
| } | ||
| else { | ||
| { | ||
| // new element | ||
| node = createElm(oldCh && oldCh[newStartIdx], newVNode, newStartIdx); | ||
| newStartVnode = newCh[++newStartIdx]; | ||
| } | ||
| if (node) { | ||
| { | ||
| oldStartVnode.$elm$.parentNode.insertBefore(node, oldStartVnode.$elm$); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| if (oldStartIdx > oldEndIdx) { | ||
| addVnodes(parentElm, newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].$elm$, newVNode, newCh, newStartIdx, newEndIdx); | ||
| } | ||
| else if (newStartIdx > newEndIdx) { | ||
| removeVnodes(oldCh, oldStartIdx, oldEndIdx); | ||
| } | ||
| }; | ||
| 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$) { | ||
| return true; | ||
| } | ||
| return false; | ||
| }; | ||
| 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$; | ||
| if (text === null) { | ||
| // element node | ||
| { | ||
| if (tag === 'slot') | ||
| ; | ||
| else { | ||
| // either this is the first render of an element OR it's an update | ||
| // AND we already know it's possible it could have changed | ||
| // this updates the element's css classes, attrs, props, listeners, etc. | ||
| updateElement(oldVNode, newVNode, isSvgMode); | ||
| } | ||
| } | ||
| if (oldChildren !== null && newChildren !== null) { | ||
| // looks like there's child vnodes for both the old and new vnodes | ||
| 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); | ||
| } | ||
| else if (oldChildren !== null) { | ||
| // no new child vnodes, but there are old child vnodes to remove | ||
| 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; | ||
| } | ||
| }; | ||
| const callNodeRefs = (vNode) => { | ||
| { | ||
| vNode.$attrs$ && vNode.$attrs$.ref && vNode.$attrs$.ref(null); | ||
| vNode.$children$ && vNode.$children$.map(callNodeRefs); | ||
| } | ||
| }; | ||
| const renderVdom = (hostRef, renderFnResults) => { | ||
| const hostElm = hostRef.$hostElement$; | ||
| const oldVNode = hostRef.$vnode$ || newVNode(null, null); | ||
| const rootVnode = isHost(renderFnResults) ? renderFnResults : h(null, null, renderFnResults); | ||
| hostTagName = hostElm.tagName; | ||
| rootVnode.$tag$ = null; | ||
| rootVnode.$flags$ |= 4 /* isHost */; | ||
| hostRef.$vnode$ = rootVnode; | ||
| rootVnode.$elm$ = oldVNode.$elm$ = (hostElm.shadowRoot || hostElm ); | ||
| { | ||
| scopeId = hostElm['s-sc']; | ||
| } | ||
| // synchronous patch | ||
| patch(oldVNode, rootVnode); | ||
| }; | ||
| const getElement = (ref) => (getHostRef(ref).$hostElement$ ); | ||
| const createEvent = (ref, name, flags) => { | ||
| const elm = getElement(ref); | ||
| return { | ||
| emit: (detail) => { | ||
| return emitEvent(elm, name, { | ||
| bubbles: !!(flags & 4 /* Bubbles */), | ||
| composed: !!(flags & 2 /* Composed */), | ||
| cancelable: !!(flags & 1 /* Cancellable */), | ||
| detail, | ||
| }); | ||
| }, | ||
| }; | ||
| }; | ||
| const emitEvent = (elm, name, opts) => { | ||
| const ev = plt.ce(name, opts); | ||
| elm.dispatchEvent(ev); | ||
| return ev; | ||
| }; | ||
| const attachToAncestor = (hostRef, ancestorComponent) => { | ||
| if (ancestorComponent && !hostRef.$onRenderResolve$ && ancestorComponent['s-p']) { | ||
| ancestorComponent['s-p'].push(new Promise(r => (hostRef.$onRenderResolve$ = r))); | ||
| } | ||
| }; | ||
| const scheduleUpdate = (hostRef, isInitialLoad) => { | ||
| { | ||
| hostRef.$flags$ |= 16 /* isQueuedForUpdate */; | ||
| } | ||
| if (hostRef.$flags$ & 4 /* isWaitingForChildren */) { | ||
| hostRef.$flags$ |= 512 /* needsRerender */; | ||
| return; | ||
| } | ||
| attachToAncestor(hostRef, hostRef.$ancestorComponent$); | ||
| // there is no ancestor component or the ancestor component | ||
| // has already fired off its lifecycle update then | ||
| // fire off the initial update | ||
| const dispatch = () => dispatchHooks(hostRef, isInitialLoad); | ||
| return writeTask(dispatch) ; | ||
| }; | ||
| const dispatchHooks = (hostRef, isInitialLoad) => { | ||
| const endSchedule = createTime('scheduleUpdate', hostRef.$cmpMeta$.$tagName$); | ||
| const instance = hostRef.$lazyInstance$ ; | ||
| let promise; | ||
| if (isInitialLoad) { | ||
| { | ||
| promise = safeCall(instance, 'componentWillLoad'); | ||
| } | ||
| } | ||
| endSchedule(); | ||
| return then(promise, () => updateComponent(hostRef, instance, isInitialLoad)); | ||
| }; | ||
| const updateComponent = async (hostRef, instance, isInitialLoad) => { | ||
| // updateComponent | ||
| const elm = hostRef.$hostElement$; | ||
| const endUpdate = createTime('update', hostRef.$cmpMeta$.$tagName$); | ||
| const rc = elm['s-rc']; | ||
| if (isInitialLoad) { | ||
| // DOM WRITE! | ||
| attachStyles(hostRef); | ||
| } | ||
| const endRender = createTime('render', hostRef.$cmpMeta$.$tagName$); | ||
| { | ||
| callRender(hostRef, instance); | ||
| } | ||
| if (rc) { | ||
| // ok, so turns out there are some child host elements | ||
| // waiting on this parent element to load | ||
| // let's fire off all update callbacks waiting | ||
| rc.map(cb => cb()); | ||
| elm['s-rc'] = undefined; | ||
| } | ||
| endRender(); | ||
| endUpdate(); | ||
| { | ||
| const childrenPromises = elm['s-p']; | ||
| const postUpdate = () => postUpdateComponent(hostRef); | ||
| if (childrenPromises.length === 0) { | ||
| postUpdate(); | ||
| } | ||
| else { | ||
| Promise.all(childrenPromises).then(postUpdate); | ||
| hostRef.$flags$ |= 4 /* isWaitingForChildren */; | ||
| childrenPromises.length = 0; | ||
| } | ||
| } | ||
| }; | ||
| const callRender = (hostRef, instance, elm) => { | ||
| try { | ||
| instance = instance.render() ; | ||
| { | ||
| hostRef.$flags$ &= ~16 /* isQueuedForUpdate */; | ||
| } | ||
| { | ||
| hostRef.$flags$ |= 2 /* hasRendered */; | ||
| } | ||
| { | ||
| { | ||
| // looks like we've got child nodes to render into this host element | ||
| // or we need to update the css class/attrs on the host element | ||
| // DOM WRITE! | ||
| { | ||
| renderVdom(hostRef, instance); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| catch (e) { | ||
| consoleError(e, hostRef.$hostElement$); | ||
| } | ||
| return null; | ||
| }; | ||
| const postUpdateComponent = (hostRef) => { | ||
| const tagName = hostRef.$cmpMeta$.$tagName$; | ||
| const elm = hostRef.$hostElement$; | ||
| const endPostUpdate = createTime('postUpdate', tagName); | ||
| const instance = hostRef.$lazyInstance$ ; | ||
| const ancestorComponent = hostRef.$ancestorComponent$; | ||
| if (!(hostRef.$flags$ & 64 /* hasLoadedComponent */)) { | ||
| hostRef.$flags$ |= 64 /* hasLoadedComponent */; | ||
| { | ||
| // DOM WRITE! | ||
| addHydratedFlag(elm); | ||
| } | ||
| { | ||
| safeCall(instance, 'componentDidLoad'); | ||
| } | ||
| endPostUpdate(); | ||
| { | ||
| hostRef.$onReadyResolve$(elm); | ||
| if (!ancestorComponent) { | ||
| appDidLoad(); | ||
| } | ||
| } | ||
| } | ||
| else { | ||
| endPostUpdate(); | ||
| } | ||
| { | ||
| hostRef.$onInstanceResolve$(elm); | ||
| } | ||
| // load events fire from bottom to top | ||
| // the deepest elements load first then bubbles up | ||
| { | ||
| if (hostRef.$onRenderResolve$) { | ||
| hostRef.$onRenderResolve$(); | ||
| hostRef.$onRenderResolve$ = undefined; | ||
| } | ||
| if (hostRef.$flags$ & 512 /* needsRerender */) { | ||
| nextTick(() => scheduleUpdate(hostRef, false)); | ||
| } | ||
| hostRef.$flags$ &= ~(4 /* isWaitingForChildren */ | 512 /* needsRerender */); | ||
| } | ||
| // ( •_•) | ||
| // ( •_•)>⌐■-■ | ||
| // (⌐■_■) | ||
| }; | ||
| const appDidLoad = (who) => { | ||
| // on appload | ||
| // we have finish the first big initial render | ||
| { | ||
| addHydratedFlag(doc.documentElement); | ||
| } | ||
| nextTick(() => emitEvent(win, 'appload', { detail: { namespace: NAMESPACE } })); | ||
| }; | ||
| const safeCall = (instance, method, arg) => { | ||
| if (instance && instance[method]) { | ||
| try { | ||
| return instance[method](arg); | ||
| } | ||
| catch (e) { | ||
| consoleError(e); | ||
| } | ||
| } | ||
| return undefined; | ||
| }; | ||
| const then = (promise, thenFn) => { | ||
| return promise && promise.then ? promise.then(thenFn) : thenFn(); | ||
| }; | ||
| const addHydratedFlag = (elm) => (elm.classList.add('hydrated') ); | ||
| const parsePropertyValue = (propValue, propType) => { | ||
| // ensure this value is of the correct prop type | ||
| if (propValue != null && !isComplexType(propValue)) { | ||
| if (propType & 4 /* Boolean */) { | ||
| // per the HTML spec, any string value means it is a boolean true value | ||
| // but we'll cheat here and say that the string "false" is the boolean false | ||
| return propValue === 'false' ? false : propValue === '' || !!propValue; | ||
| } | ||
| if (propType & 2 /* Number */) { | ||
| // force it to be a number | ||
| return parseFloat(propValue); | ||
| } | ||
| if (propType & 1 /* String */) { | ||
| // could have been passed as a number or boolean | ||
| // but we still want it as a string | ||
| return String(propValue); | ||
| } | ||
| // redundant return here for better minification | ||
| return propValue; | ||
| } | ||
| // not sure exactly what type we want | ||
| // so no need to change to a different type | ||
| return propValue; | ||
| }; | ||
| const getValue = (ref, propName) => getHostRef(ref).$instanceValues$.get(propName); | ||
| const setValue = (ref, propName, newVal, cmpMeta) => { | ||
| // check our new property value against our internal value | ||
| const hostRef = getHostRef(ref); | ||
| const elm = hostRef.$hostElement$ ; | ||
| const oldVal = hostRef.$instanceValues$.get(propName); | ||
| const flags = hostRef.$flags$; | ||
| const instance = hostRef.$lazyInstance$ ; | ||
| newVal = parsePropertyValue(newVal, cmpMeta.$members$[propName][0]); | ||
| if ((!(flags & 8 /* isConstructingInstance */) || oldVal === undefined) && newVal !== oldVal) { | ||
| // gadzooks! the property's value has changed!! | ||
| // set our new value! | ||
| hostRef.$instanceValues$.set(propName, newVal); | ||
| if (instance) { | ||
| // get an array of method names of watch functions to call | ||
| if (cmpMeta.$watchers$ && flags & 128 /* isWatchReady */) { | ||
| const watchMethods = cmpMeta.$watchers$[propName]; | ||
| if (watchMethods) { | ||
| // this instance is watching for when this property changed | ||
| watchMethods.map(watchMethodName => { | ||
| try { | ||
| // fire off each of the watch methods that are watching this property | ||
| instance[watchMethodName](newVal, oldVal, propName); | ||
| } | ||
| catch (e) { | ||
| consoleError(e, elm); | ||
| } | ||
| }); | ||
| } | ||
| } | ||
| if ((flags & (2 /* hasRendered */ | 16 /* isQueuedForUpdate */)) === 2 /* hasRendered */) { | ||
| // looks like this value actually changed, so we've got work to do! | ||
| // but only if we've already rendered, otherwise just chill out | ||
| // queue that we need to do an update, but don't worry about queuing | ||
| // up millions cuz this function ensures it only runs once | ||
| scheduleUpdate(hostRef, false); | ||
| } | ||
| } | ||
| } | ||
| }; | ||
| const proxyComponent = (Cstr, cmpMeta, flags) => { | ||
| if (cmpMeta.$members$) { | ||
| if (Cstr.watchers) { | ||
| cmpMeta.$watchers$ = Cstr.watchers; | ||
| } | ||
| // It's better to have a const than two Object.entries() | ||
| const members = Object.entries(cmpMeta.$members$); | ||
| const prototype = Cstr.prototype; | ||
| members.map(([memberName, [memberFlags]]) => { | ||
| if ((memberFlags & 31 /* Prop */ || ((flags & 2 /* proxyState */) && memberFlags & 32 /* State */))) { | ||
| // proxyComponent - prop | ||
| Object.defineProperty(prototype, memberName, { | ||
| get() { | ||
| // proxyComponent, get value | ||
| return getValue(this, memberName); | ||
| }, | ||
| set(newValue) { | ||
| // proxyComponent, set value | ||
| setValue(this, memberName, newValue, cmpMeta); | ||
| }, | ||
| configurable: true, | ||
| enumerable: true, | ||
| }); | ||
| } | ||
| else if (flags & 1 /* isElementConstructor */ && memberFlags & 64 /* Method */) { | ||
| // proxyComponent - method | ||
| Object.defineProperty(prototype, memberName, { | ||
| value(...args) { | ||
| const ref = getHostRef(this); | ||
| return ref.$onInstancePromise$.then(() => ref.$lazyInstance$[memberName](...args)); | ||
| }, | ||
| }); | ||
| } | ||
| }); | ||
| if ((flags & 1 /* isElementConstructor */)) { | ||
| const attrNameToPropName = new Map(); | ||
| prototype.attributeChangedCallback = function (attrName, _oldValue, newValue) { | ||
| plt.jmp(() => { | ||
| const propName = attrNameToPropName.get(attrName); | ||
| this[propName] = newValue === null && typeof this[propName] === 'boolean' ? false : newValue; | ||
| }); | ||
| }; | ||
| // create an array of attributes to observe | ||
| // and also create a map of html attribute name to js property name | ||
| Cstr.observedAttributes = members | ||
| .filter(([_, m]) => m[0] & 15 /* HasAttribute */) // filter to only keep props that should match attributes | ||
| .map(([propName, m]) => { | ||
| const attrName = m[1] || propName; | ||
| attrNameToPropName.set(attrName, propName); | ||
| return attrName; | ||
| }); | ||
| } | ||
| } | ||
| return Cstr; | ||
| }; | ||
| const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId, Cstr) => { | ||
| // initializeComponent | ||
| if ((hostRef.$flags$ & 32 /* hasInitializedComponent */) === 0) { | ||
| { | ||
| // we haven't initialized this element yet | ||
| hostRef.$flags$ |= 32 /* hasInitializedComponent */; | ||
| // lazy loaded components | ||
| // request the component's implementation to be | ||
| // wired up with the host element | ||
| Cstr = loadModule(cmpMeta); | ||
| if (Cstr.then) { | ||
| // Await creates a micro-task avoid if possible | ||
| const endLoad = uniqueTime(); | ||
| Cstr = await Cstr; | ||
| endLoad(); | ||
| } | ||
| if (!Cstr.isProxied) { | ||
| // we'eve never proxied this Constructor before | ||
| // let's add the getters/setters to its prototype before | ||
| // the first time we create an instance of the implementation | ||
| { | ||
| cmpMeta.$watchers$ = Cstr.watchers; | ||
| } | ||
| proxyComponent(Cstr, cmpMeta, 2 /* proxyState */); | ||
| Cstr.isProxied = true; | ||
| } | ||
| const endNewInstance = createTime('createInstance', cmpMeta.$tagName$); | ||
| // ok, time to construct the instance | ||
| // but let's keep track of when we start and stop | ||
| // so that the getters/setters don't incorrectly step on data | ||
| { | ||
| hostRef.$flags$ |= 8 /* isConstructingInstance */; | ||
| } | ||
| // construct the lazy-loaded component implementation | ||
| // passing the hostRef is very important during | ||
| // construction in order to directly wire together the | ||
| // host element and the lazy-loaded instance | ||
| try { | ||
| new Cstr(hostRef); | ||
| } | ||
| catch (e) { | ||
| consoleError(e); | ||
| } | ||
| { | ||
| hostRef.$flags$ &= ~8 /* isConstructingInstance */; | ||
| } | ||
| { | ||
| hostRef.$flags$ |= 128 /* isWatchReady */; | ||
| } | ||
| endNewInstance(); | ||
| fireConnectedCallback(hostRef.$lazyInstance$); | ||
| } | ||
| if (Cstr.style) { | ||
| // this component has styles but we haven't registered them yet | ||
| let style = Cstr.style; | ||
| const scopeId = getScopeId(cmpMeta); | ||
| if (!styles.has(scopeId)) { | ||
| const endRegisterStyles = createTime('registerStyles', cmpMeta.$tagName$); | ||
| registerStyle(scopeId, style, !!(cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */)); | ||
| endRegisterStyles(); | ||
| } | ||
| } | ||
| } | ||
| // we've successfully created a lazy instance | ||
| const ancestorComponent = hostRef.$ancestorComponent$; | ||
| const schedule = () => scheduleUpdate(hostRef, true); | ||
| if (ancestorComponent && ancestorComponent['s-rc']) { | ||
| // this is the intial load and this component it has an ancestor component | ||
| // but the ancestor component has NOT fired its will update lifecycle yet | ||
| // so let's just cool our jets and wait for the ancestor to continue first | ||
| // this will get fired off when the ancestor component | ||
| // finally gets around to rendering its lazy self | ||
| // fire off the initial update | ||
| ancestorComponent['s-rc'].push(schedule); | ||
| } | ||
| else { | ||
| schedule(); | ||
| } | ||
| }; | ||
| const fireConnectedCallback = (instance) => { | ||
| { | ||
| safeCall(instance, 'connectedCallback'); | ||
| } | ||
| }; | ||
| const connectedCallback = (elm) => { | ||
| if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0) { | ||
| const hostRef = getHostRef(elm); | ||
| const cmpMeta = hostRef.$cmpMeta$; | ||
| const endConnected = createTime('connectedCallback', cmpMeta.$tagName$); | ||
| if (!(hostRef.$flags$ & 1 /* hasConnected */)) { | ||
| // first time this component has connected | ||
| hostRef.$flags$ |= 1 /* hasConnected */; | ||
| { | ||
| // find the first ancestor component (if there is one) and register | ||
| // this component as one of the actively loading child components for its ancestor | ||
| let ancestorComponent = elm; | ||
| while ((ancestorComponent = ancestorComponent.parentNode || ancestorComponent.host)) { | ||
| // climb up the ancestors looking for the first | ||
| // component that hasn't finished its lifecycle update yet | ||
| if (ancestorComponent['s-p']) { | ||
| // we found this components first ancestor component | ||
| // keep a reference to this component's ancestor component | ||
| attachToAncestor(hostRef, (hostRef.$ancestorComponent$ = ancestorComponent)); | ||
| break; | ||
| } | ||
| } | ||
| } | ||
| // Lazy properties | ||
| // https://developers.google.com/web/fundamentals/web-components/best-practices#lazy-properties | ||
| if (cmpMeta.$members$) { | ||
| Object.entries(cmpMeta.$members$).map(([memberName, [memberFlags]]) => { | ||
| if (memberFlags & 31 /* Prop */ && elm.hasOwnProperty(memberName)) { | ||
| const value = elm[memberName]; | ||
| delete elm[memberName]; | ||
| elm[memberName] = value; | ||
| } | ||
| }); | ||
| } | ||
| { | ||
| initializeComponent(elm, hostRef, cmpMeta); | ||
| } | ||
| } | ||
| else { | ||
| // fire off connectedCallback() on component instance | ||
| fireConnectedCallback(hostRef.$lazyInstance$); | ||
| } | ||
| endConnected(); | ||
| } | ||
| }; | ||
| const disconnectedCallback = (elm) => { | ||
| if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0) { | ||
| const hostRef = getHostRef(elm); | ||
| const instance = hostRef.$lazyInstance$ ; | ||
| { | ||
| safeCall(instance, 'disconnectedCallback'); | ||
| } | ||
| } | ||
| }; | ||
| const bootstrapLazy = (lazyBundles, options = {}) => { | ||
| const endBootstrap = createTime(); | ||
| const cmpTags = []; | ||
| const exclude = options.exclude || []; | ||
| const customElements = win.customElements; | ||
| const head = doc.head; | ||
| const metaCharset = /*@__PURE__*/ head.querySelector('meta[charset]'); | ||
| const visibilityStyle = /*@__PURE__*/ doc.createElement('style'); | ||
| const deferredConnectedCallbacks = []; | ||
| let appLoadFallback; | ||
| let isBootstrapping = true; | ||
| Object.assign(plt, options); | ||
| plt.$resourcesUrl$ = new URL(options.resourcesUrl || './', doc.baseURI).href; | ||
| lazyBundles.map(lazyBundle => lazyBundle[1].map(compactMeta => { | ||
| const cmpMeta = { | ||
| $flags$: compactMeta[0], | ||
| $tagName$: compactMeta[1], | ||
| $members$: compactMeta[2], | ||
| $listeners$: compactMeta[3], | ||
| }; | ||
| { | ||
| cmpMeta.$members$ = compactMeta[2]; | ||
| } | ||
| { | ||
| cmpMeta.$watchers$ = {}; | ||
| } | ||
| const tagName = cmpMeta.$tagName$; | ||
| const HostElement = class extends HTMLElement { | ||
| // StencilLazyHost | ||
| constructor(self) { | ||
| // @ts-ignore | ||
| super(self); | ||
| self = this; | ||
| registerHost(self, cmpMeta); | ||
| if (cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) { | ||
| // this component is using shadow dom | ||
| // and this browser supports shadow dom | ||
| // add the read-only property "shadowRoot" to the host element | ||
| // adding the shadow root build conditionals to minimize runtime | ||
| { | ||
| { | ||
| self.attachShadow({ mode: 'open' }); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| connectedCallback() { | ||
| if (appLoadFallback) { | ||
| clearTimeout(appLoadFallback); | ||
| appLoadFallback = null; | ||
| } | ||
| if (isBootstrapping) { | ||
| // connectedCallback will be processed once all components have been registered | ||
| deferredConnectedCallbacks.push(this); | ||
| } | ||
| else { | ||
| plt.jmp(() => connectedCallback(this)); | ||
| } | ||
| } | ||
| disconnectedCallback() { | ||
| plt.jmp(() => disconnectedCallback(this)); | ||
| } | ||
| componentOnReady() { | ||
| return getHostRef(this).$onReadyPromise$; | ||
| } | ||
| }; | ||
| cmpMeta.$lazyBundleId$ = lazyBundle[0]; | ||
| if (!exclude.includes(tagName) && !customElements.get(tagName)) { | ||
| cmpTags.push(tagName); | ||
| customElements.define(tagName, proxyComponent(HostElement, cmpMeta, 1 /* isElementConstructor */)); | ||
| } | ||
| })); | ||
| { | ||
| visibilityStyle.innerHTML = cmpTags + HYDRATED_CSS; | ||
| visibilityStyle.setAttribute('data-styles', ''); | ||
| head.insertBefore(visibilityStyle, metaCharset ? metaCharset.nextSibling : head.firstChild); | ||
| } | ||
| // Process deferred connectedCallbacks now all components have been registered | ||
| isBootstrapping = false; | ||
| if (deferredConnectedCallbacks.length) { | ||
| deferredConnectedCallbacks.map(host => host.connectedCallback()); | ||
| } | ||
| else { | ||
| { | ||
| plt.jmp(() => (appLoadFallback = setTimeout(appDidLoad, 30))); | ||
| } | ||
| } | ||
| // Fallback appLoad event | ||
| endBootstrap(); | ||
| }; | ||
| const hostRefs = new WeakMap(); | ||
| const getHostRef = (ref) => hostRefs.get(ref); | ||
| const registerInstance = (lazyInstance, hostRef) => hostRefs.set((hostRef.$lazyInstance$ = lazyInstance), hostRef); | ||
| const registerHost = (elm, cmpMeta) => { | ||
| const hostRef = { | ||
| $flags$: 0, | ||
| $hostElement$: elm, | ||
| $cmpMeta$: cmpMeta, | ||
| $instanceValues$: new Map(), | ||
| }; | ||
| { | ||
| hostRef.$onInstancePromise$ = new Promise(r => (hostRef.$onInstanceResolve$ = r)); | ||
| } | ||
| { | ||
| hostRef.$onReadyPromise$ = new Promise(r => (hostRef.$onReadyResolve$ = r)); | ||
| elm['s-p'] = []; | ||
| elm['s-rc'] = []; | ||
| } | ||
| return hostRefs.set(elm, hostRef); | ||
| }; | ||
| const isMemberInElement = (elm, memberName) => memberName in elm; | ||
| const consoleError = (e, el) => (0, console.error)(e, el); | ||
| const cmpModules = /*@__PURE__*/ new Map(); | ||
| const loadModule = (cmpMeta, hostRef, hmrVersionId) => { | ||
| // loadModuleImport | ||
| const exportName = cmpMeta.$tagName$.replace(/-/g, '_'); | ||
| const bundleId = cmpMeta.$lazyBundleId$; | ||
| const module = cmpModules.get(bundleId) ; | ||
| if (module) { | ||
| return module[exportName]; | ||
| } | ||
| return import( | ||
| /* webpackInclude: /\.entry\.js$/ */ | ||
| /* webpackExclude: /\.system\.entry\.js$/ */ | ||
| /* webpackMode: "lazy" */ | ||
| `./${bundleId}.entry.js${''}`).then(importedModule => { | ||
| { | ||
| cmpModules.set(bundleId, importedModule); | ||
| } | ||
| return importedModule[exportName]; | ||
| }, consoleError); | ||
| }; | ||
| const styles = new Map(); | ||
| const queueDomReads = []; | ||
| const queueDomWrites = []; | ||
| const queueTask = (queue, write) => (cb) => { | ||
| queue.push(cb); | ||
| if (!queuePending) { | ||
| queuePending = true; | ||
| if (write && plt.$flags$ & 4 /* queueSync */) { | ||
| nextTick(flush); | ||
| } | ||
| else { | ||
| plt.raf(flush); | ||
| } | ||
| } | ||
| }; | ||
| const consume = (queue) => { | ||
| for (let i = 0; i < queue.length; i++) { | ||
| try { | ||
| queue[i](performance.now()); | ||
| } | ||
| catch (e) { | ||
| consoleError(e); | ||
| } | ||
| } | ||
| queue.length = 0; | ||
| }; | ||
| const flush = () => { | ||
| // always force a bunch of medium callbacks to run, but still have | ||
| // a throttle on how many can run in a certain time | ||
| // DOM READS!!! | ||
| consume(queueDomReads); | ||
| // DOM WRITES!!! | ||
| { | ||
| consume(queueDomWrites); | ||
| if ((queuePending = queueDomReads.length > 0)) { | ||
| // still more to do yet, but we've run out of time | ||
| // let's let this thing cool off and try again in the next tick | ||
| plt.raf(flush); | ||
| } | ||
| } | ||
| }; | ||
| const nextTick = /*@__PURE__*/ (cb) => promiseResolve().then(cb); | ||
| const writeTask = /*@__PURE__*/ queueTask(queueDomWrites, true); | ||
| export { Host as H, bootstrapLazy as b, createEvent as c, getElement as g, h, promiseResolve as p, registerInstance as r }; |
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
New alerts
Network access
Supply chain riskThis module accesses the network.
Found 1 instance in 1 package
Uses eval
Supply chain riskPackage uses dynamic code execution (e.g., eval()), which is a dangerous practice. This can prevent the code from running in certain environments and increases the risk that the code may contain exploits or malicious behavior.
Found 1 instance in 1 package
Dynamic require
Supply chain riskDynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.
Found 1 instance in 1 package
Environment variable access
Supply chain riskPackage accesses environment variables, which may be a sign of credential stuffing or data theft.
Found 1 instance in 1 package
Long strings
Supply chain riskContains long string literals, which may be a sign of obfuscated or packed code.
Found 1 instance in 1 package
Minified code
QualityThis package contains minified code. This may be harmless in some cases where minified code is included in packaged libraries, however packages on npm should not minify code.
Found 1 instance in 1 package
Fixed alerts
Network access
Supply chain riskThis module accesses the network.
Found 1 instance in 1 package
Uses eval
Supply chain riskPackage uses dynamic code execution (e.g., eval()), which is a dangerous practice. This can prevent the code from running in certain environments and increases the risk that the code may contain exploits or malicious behavior.
Found 1 instance in 1 package
Dynamic require
Supply chain riskDynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.
Found 1 instance in 1 package
Environment variable access
Supply chain riskPackage accesses environment variables, which may be a sign of credential stuffing or data theft.
Found 1 instance in 1 package
Long strings
Supply chain riskContains long string literals, which may be a sign of obfuscated or packed code.
Found 1 instance in 1 package
Minified code
QualityThis package contains minified code. This may be harmless in some cases where minified code is included in packaged libraries, however packages on npm should not minify code.
Found 1 instance in 1 package
Improved metrics
- Total package byte prevSize
871777
0.35%- Lines of code
13879
0.51%No dependency changes