diff --git a/Software/Code Composer Studio Workspace/.gitignore b/Software/Code Composer Studio Workspace/.gitignore new file mode 100644 index 0000000..e10e727 --- /dev/null +++ b/Software/Code Composer Studio Workspace/.gitignore @@ -0,0 +1 @@ +/.metadata/ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/data_0 b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/data_0 new file mode 100644 index 0000000..57f530a Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/data_0 differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/data_1 b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/data_1 new file mode 100644 index 0000000..fa833a7 Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/data_1 differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/data_2 b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/data_2 new file mode 100644 index 0000000..9c9a995 Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/data_2 differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/data_3 b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/data_3 new file mode 100644 index 0000000..1f89bfa Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/data_3 differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/f_000001 b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/f_000001 new file mode 100644 index 0000000..3ae74fd Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/f_000001 differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/f_000002 b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/f_000002 new file mode 100644 index 0000000..e9f0838 --- /dev/null +++ b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/f_000002 @@ -0,0 +1,2821 @@ +const BUILD = {"allRenderFn":false,"cmpDidLoad":true,"cmpShouldUpdate":false,"cmpDidUnload":true,"cmpDidUpdate":true,"cmpDidRender":true,"cmpWillLoad":true,"cmpWillUpdate":true,"cmpWillRender":false,"connectedCallback":true,"disconnectedCallback":true,"element":false,"event":true,"hasRenderFn":true,"lifecycle":true,"asyncLoading":true,"hostListener":true,"hostListenerTargetWindow":true,"hostListenerTargetDocument":true,"hostListenerTargetBody":false,"hostListenerTargetParent":false,"hostListenerTarget":true,"member":true,"method":true,"mode":false,"noVdomRender":false,"observeAttribute":true,"prop":true,"propBoolean":true,"propNumber":true,"propString":true,"propMutable":true,"reflect":true,"scoped":false,"shadowDom":true,"shadowDelegatesFocus":false,"slot":true,"slotRelocation":true,"state":true,"style":true,"svg":true,"updatable":true,"vdomAttribute":true,"vdomXlink":true,"vdomClass":true,"vdomFunctional":false,"vdomKey":true,"vdomListener":true,"vdomPropOrAttr":true,"vdomRef":true,"vdomRender":true,"vdomStyle":true,"vdomText":true,"watchCallback":true,"taskQueue":true,"lazyLoad":true,"hydrateServerSide":false,"cssVarShim":true,"initializeNextTick":true,"hydrateClientSide":false,"isDebug":false,"isDev":true,"devTools":true,"profile":true,"hotModuleReplacement":true,"constructableCSS":false,"cssAnnotations":true,"appendChildSlotFix":false,"cloneNodeFix":false,"dynamicImportShim":true,"lifecycleDOMEvents":false,"safari10":true,"shadowDomShim":true,"hydratedAttribute":false,"hydratedClass":true}; +const NAMESPACE = 'gc-components'; + +let queueCongestion = 0; +let queuePending = false; +let i = 0; +let scopeId; +let contentRef; +let hostTagName; +let useNativeShadowDom = false; +let checkSlotFallbackVisibility = false; +let checkSlotRelocate = false; +let isSvgMode = false; +let renderingElement = null; +const win = typeof window !== 'undefined' ? window : {}; +const CSS = BUILD.cssVarShim ? win.CSS : null; +const doc = win.document || { head: {} }; +const H = (win.HTMLElement || class { +}); +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), +}; +const supportsShadowDom = BUILD.shadowDomShim ? (BUILD.shadowDom) ? /*@__PURE__*/ (() => (doc.head.attachShadow + '').indexOf('[native') > -1)() : false : true; +const supportsListenerOptions = /*@__PURE__*/ (() => { + let supportsListenerOptions = false; + try { + doc.addEventListener('e', null, Object.defineProperty({}, 'passive', { + get() { supportsListenerOptions = true; } + })); + } + catch (e) { } + return supportsListenerOptions; +})(); +const promiseResolve = (v) => Promise.resolve(v); +const supportsConstructibleStylesheets = BUILD.constructableCSS ? /*@__PURE__*/ (() => { + try { + new CSSStyleSheet(); + return true; + } + catch (e) { } + return false; +})() : false; +const Context = {}; +const hostRefs = new WeakMap(); +const getHostRef = (ref) => hostRefs.get(ref); +const registerInstance = (lazyInstance, hostRef) => hostRefs.set(hostRef.$lazyInstance$ = lazyInstance, hostRef); +const registerHost = (elm) => { + const hostRef = { + $flags$: 0, + $hostElement$: elm, + $instanceValues$: new Map() + }; + if (BUILD.isDev) { + hostRef.$renderCount$ = 0; + } + if (BUILD.method && BUILD.lazyLoad) { + hostRef.$onInstancePromise$ = new Promise(r => hostRef.$onInstanceResolve$ = r); + } + if (BUILD.asyncLoading) { + 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 STENCIL_DEV_MODE = ['%c[STENCIL-DEV-MODE]', 'color:#4c47ff;font-weight: bold']; +const consoleDevError = (...m) => console.error(...STENCIL_DEV_MODE, ...m); +const consoleDevWarn = (...m) => console.warn(...STENCIL_DEV_MODE, ...m); +const consoleDevInfo = (...m) => console.info(...STENCIL_DEV_MODE, ...m); +const consoleError = (e) => console.error(e); +const moduleCache = /*@__PURE__*/ new Map(); +const loadModule = (cmpMeta, hostRef, hmrVersionId) => { + // loadModuleImport + const exportName = cmpMeta.$tagName$.replace(/-/g, '_'); + const bundleId = ((BUILD.mode && typeof cmpMeta.$lazyBundleIds$ !== 'string') + ? cmpMeta.$lazyBundleIds$[hostRef.$modeName$] + : cmpMeta.$lazyBundleIds$); + const module = !BUILD.hotModuleReplacement ? moduleCache.get(bundleId) : false; + if (module) { + return module[exportName]; + } + return __sc_import_gc_components( + /* webpackInclude: /\.entry\.js$/ */ + /* webpackExclude: /\.system\.entry\.js$/ */ + /* webpackMode: "lazy" */ + `./${bundleId}.entry.js${BUILD.hotModuleReplacement && hmrVersionId ? '?s-hmr=' + hmrVersionId : ''}`).then(importedModule => { + if (!BUILD.hotModuleReplacement) { + moduleCache.set(bundleId, importedModule); + } + return importedModule[exportName]; + }, consoleError); +}; +const styles = new Map(); +const queueDomReads = []; +const queueDomWrites = []; +const queueDomWritesLow = []; +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 consumeTimeout = (queue, timeout) => { + let i = 0; + let ts = 0; + while (i < queue.length && (ts = performance.now()) < timeout) { + try { + queue[i++](ts); + } + catch (e) { + consoleError(e); + } + } + if (i === queue.length) { + queue.length = 0; + } + else if (i !== 0) { + queue.splice(0, i); + } +}; +const flush = () => { + queueCongestion++; + // 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); + const timeout = (plt.$flags$ & 6 /* queueMask */) === 2 /* appLoaded */ + ? performance.now() + (10 * Math.ceil(queueCongestion * (1.0 / 22.0))) + : Infinity; + // DOM WRITES!!! + consumeTimeout(queueDomWrites, timeout); + consumeTimeout(queueDomWritesLow, timeout); + if (queueDomWrites.length > 0) { + queueDomWritesLow.push(...queueDomWrites); + queueDomWrites.length = 0; + } + if (queuePending = ((queueDomReads.length + queueDomWrites.length + queueDomWritesLow.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); + } + else { + queueCongestion = 0; + } +}; +const nextTick = /*@__PURE__*/ (cb) => promiseResolve().then(cb); +const readTask = /*@__PURE__*/ queueTask(queueDomReads, false); +const writeTask = /*@__PURE__*/ queueTask(queueDomWrites, true); +const Build = { + isDev: BUILD.isDev ? true : false, + isBrowser: true +}; +/** + * Default style mode id + */ +/** + * Reusable empty obj/array + * Don't add values to these!! + */ +const EMPTY_OBJ = {}; +/** + * Namespaces + */ +const SVG_NS = 'http://www.w3.org/2000/svg'; +const HTML_NS = 'http://www.w3.org/1999/xhtml'; +const isDef = (v) => v != null; +const isComplexType = (o) => { + // https://jsperf.com/typeof-fn-object/5 + o = typeof o; + return o === 'object' || o === 'function'; +}; +const getDynamicImportFunction = (namespace) => `__sc_import_${namespace.replace(/\s|-/g, '_')}`; +const patchEsm = () => { + // @ts-ignore + if (BUILD.cssVarShim && !(CSS && CSS.supports && CSS.supports('color', 'var(--c)'))) { + // @ts-ignore + return __sc_import_gc_components(/* webpackChunkName: "stencil-polyfills-css-shim" */ './css-shim-8775d9ad-556f0cc2.js').then(() => { + if (plt.$cssShim$ = win.__cssshim) { + return plt.$cssShim$.i(); + } + else { + // for better minification + return 0; + } + }); + } + return promiseResolve(); +}; +const patchBrowser = () => { + // NOTE!! This fn cannot use async/await! + if (BUILD.isDev) { + consoleDevInfo('Stencil is running in the development mode.'); + } + if (BUILD.cssVarShim) { + // shim css vars + plt.$cssShim$ = win.__cssshim; + } + if (BUILD.cloneNodeFix) { + // opted-in to polyfill cloneNode() for slot polyfilled components + patchCloneNodeFix(H.prototype); + } + if (BUILD.profile && !performance.mark) { + // not all browsers support performance.mark/measure (Safari 10) + performance.mark = performance.measure = () => { }; + performance.getEntriesByName = () => []; + } + // @ts-ignore + const scriptElm = (BUILD.scriptDataOpts || BUILD.safari10 || BUILD.dynamicImportShim) ? + Array.from(doc.querySelectorAll('script')).find(s => (new RegExp(`\/${NAMESPACE}(\\.esm)?\\.js($|\\?|#)`).test(s.src) || + s.getAttribute('data-stencil-namespace') === NAMESPACE)) : null; + const importMeta = ""; + const opts = BUILD.scriptDataOpts ? scriptElm['data-opts'] || {} : {}; + if (BUILD.safari10 && 'onbeforeload' in scriptElm && !history.scrollRestoration /* IS_ESM_BUILD */) { + // Safari < v11 support: This IF is true if it's Safari below v11. + // This fn cannot use async/await since Safari didn't support it until v11, + // however, Safari 10 did support modules. Safari 10 also didn't support "nomodule", + // so both the ESM file and nomodule file would get downloaded. Only Safari + // has 'onbeforeload' in the script, and "history.scrollRestoration" was added + // to Safari in v11. Return a noop then() so the async/await ESM code doesn't continue. + // IS_ESM_BUILD is replaced at build time so this check doesn't happen in systemjs builds. + return { then() { } }; + } + if (!BUILD.safari10 && importMeta !== '') { + opts.resourcesUrl = new URL('.', importMeta).href; + } + else if (BUILD.dynamicImportShim || BUILD.safari10) { + opts.resourcesUrl = new URL('.', new URL(scriptElm.getAttribute('data-resources-url') || scriptElm.src, win.location.href)).href; + patchDynamicImport(opts.resourcesUrl, scriptElm); + if (BUILD.dynamicImportShim && !win.customElements) { + // module support, but no custom elements support (Old Edge) + // @ts-ignore + return __sc_import_gc_components(/* webpackChunkName: "stencil-polyfills-dom" */ './dom-76cc7c7d-0a082895.js').then(() => opts); + } + } + return promiseResolve(opts); +}; +const patchDynamicImport = (base, orgScriptElm) => { + const importFunctionName = getDynamicImportFunction(NAMESPACE); + try { + // test if this browser supports dynamic imports + // There is a caching issue in V8, that breaks using import() in Function + // By generating a random string, we can workaround it + // Check https://bugs.chromium.org/p/v8/issues/detail?id=9558 for more info + win[importFunctionName] = new Function('w', `return import(w);//${Math.random()}`); + } + catch (e) { + // this shim is specifically for browsers that do support "esm" imports + // however, they do NOT support "dynamic" imports + // basically this code is for old Edge, v18 and below + const moduleMap = new Map(); + win[importFunctionName] = (src) => { + const url = new URL(src, base).href; + let mod = moduleMap.get(url); + if (!mod) { + const script = doc.createElement('script'); + script.type = 'module'; + script.crossOrigin = orgScriptElm.crossOrigin; + script.src = URL.createObjectURL(new Blob([`import * as m from '${url}'; window.${importFunctionName}.m = m;`], { type: 'application/javascript' })); + mod = new Promise(resolve => { + script.onload = () => { + resolve(win[importFunctionName].m); + script.remove(); + }; + }); + moduleMap.set(url, mod); + doc.head.appendChild(script); + } + return mod; + }; + } +}; +const patchCloneNodeFix = (HTMLElementPrototype) => { + const nativeCloneNodeFn = HTMLElementPrototype.cloneNode; + HTMLElementPrototype.cloneNode = function (deep) { + if (this.nodeName === 'TEMPLATE') { + return nativeCloneNodeFn.call(this, deep); + } + const clonedNode = nativeCloneNodeFn.call(this, false); + const srcChildNodes = this.childNodes; + if (deep) { + for (let i = 0; i < srcChildNodes.length; i++) { + // Node.ATTRIBUTE_NODE === 2, and checking because IE11 + if (srcChildNodes[i].nodeType !== 2) { + clonedNode.appendChild(srcChildNodes[i].cloneNode(true)); + } + } + } + return clonedNode; + }; +}; +const CONTENT_REF_ID = 'r'; +const ORG_LOCATION_ID = 'o'; +const SLOT_NODE_ID = 's'; +const TEXT_NODE_ID = 't'; +const HYDRATE_ID = 's-id'; +const HYDRATED_STYLE_ID = 'sty-id'; +const HYDRATE_CHILD_ID = 'c-id'; +const HYDRATED_CSS = '{visibility:hidden}.hydrated{visibility:inherit}'; +const XLINK_NS = 'http://www.w3.org/1999/xlink'; +const createTime = (fnName, tagName = '') => { + if (BUILD.profile) { + const key = `st:${fnName}:${tagName}:${i++}`; + // Start + performance.mark(key); + // End + return () => performance.measure(`[Stencil] ${fnName}() <${tagName}>`, key); + } + else { + return () => { return; }; + } +}; +const uniqueTime = (key, measureText) => { + if (BUILD.profile) { + if (performance.getEntriesByName(key).length === 0) { + performance.mark(key); + } + return () => { + if (performance.getEntriesByName(measureText).length === 0) { + performance.measure(measureText, key); + } + }; + } + else { + return () => { return; }; + } +}; +const inspect = (ref) => { + const hostRef = getHostRef(ref); + if (!hostRef) { + return undefined; + } + const flags = hostRef.$flags$; + const hostElement = hostRef.$hostElement$; + return { + renderCount: hostRef.$renderCount$, + flags: { + hasRendered: !!(flags & 2 /* hasRendered */), + hasConnected: !!(flags & 1 /* hasConnected */), + isWaitingForChildren: !!(flags & 4 /* isWaitingForChildren */), + isConstructingInstance: !!(flags & 8 /* isConstructingInstance */), + isQueuedForUpdate: !!(flags & 16 /* isQueuedForUpdate */), + hasInitializedComponent: !!(flags & 32 /* hasInitializedComponent */), + hasLoadedComponent: !!(flags & 64 /* hasLoadedComponent */), + isWatchReady: !!(flags & 128 /* isWatchReady */), + isListenReady: !!(flags & 256 /* isListenReady */), + needsRerender: !!(flags & 512 /* needsRerender */), + }, + instanceValues: hostRef.$instanceValues$, + ancestorComponent: hostRef.$ancestorComponent$, + hostElement, + lazyInstance: hostRef.$lazyInstance$, + vnode: hostRef.$vnode$, + modeName: hostRef.$modeName$, + onReadyPromise: hostRef.$onReadyPromise$, + onReadyResolve: hostRef.$onReadyResolve$, + onInstancePromise: hostRef.$onInstancePromise$, + onInstanceResolve: hostRef.$onInstanceResolve$, + onRenderResolve: hostRef.$onRenderResolve$, + queuedListeners: hostRef.$queuedListeners$, + rmListeners: hostRef.$rmListeners$, + ['s-id']: hostElement['s-id'], + ['s-cr']: hostElement['s-cr'], + ['s-lr']: hostElement['s-lr'], + ['s-p']: hostElement['s-p'], + ['s-rc']: hostElement['s-rc'], + ['s-sc']: hostElement['s-sc'], + }; +}; +const installDevTools = () => { + if (BUILD.devTools) { + const stencil = win.stencil = win.stencil || {}; + const originalInspect = stencil.inspect; + stencil.inspect = (ref) => { + let result = inspect(ref); + if (!result && typeof originalInspect === 'function') { + result = originalInspect(ref); + } + return result; + }; + } +}; +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 = BUILD.mode ? getScopeId(cmpMeta.$tagName$, mode) : getScopeId(cmpMeta.$tagName$); + 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 (BUILD.mode && !style) { + scopeId = getScopeId(cmpMeta.$tagName$); + style = styles.get(scopeId); + } + 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)) { + if (BUILD.hydrateClientSide && styleContainerNode.host && (styleElm = styleContainerNode.querySelector(`[${HYDRATED_STYLE_ID}="${scopeId}"]`))) { + // This is only happening on native shadow-dom, do not needs CSS var shim + styleElm.innerHTML = style; + } + else { + if (BUILD.cssVarShim && plt.$cssShim$) { + styleElm = plt.$cssShim$.createHostStyle(hostElm, scopeId, style, !!(cmpMeta.$flags$ & 10 /* needsScopedEncapsulation */)); + const newScopeId = styleElm['s-sc']; + if (newScopeId) { + scopeId = newScopeId; + // we don't want to add this styleID to the appliedStyles Set + // since the cssVarShim might need to apply several different + // stylesheets for the same component + appliedStyles = null; + } + } + else { + styleElm = doc.createElement('style'); + styleElm.innerHTML = style; + } + if (BUILD.hydrateServerSide || BUILD.hotModuleReplacement) { + styleElm.setAttribute(HYDRATED_STYLE_ID, scopeId); + } + styleContainerNode.insertBefore(styleElm, styleContainerNode.querySelector('link')); + } + if (appliedStyles) { + appliedStyles.add(scopeId); + } + } + } + else if (BUILD.constructableCSS && !styleContainerNode.adoptedStyleSheets.includes(style)) { + styleContainerNode.adoptedStyleSheets = [...styleContainerNode.adoptedStyleSheets, style]; + } + } + return scopeId; +}; +const attachStyles = (elm, cmpMeta, mode) => { + const endAttachStyles = createTime('attachStyles', cmpMeta.$tagName$); + const scopeId = addStyle((BUILD.shadowDom && supportsShadowDom && elm.shadowRoot) + ? elm.shadowRoot + : elm.getRootNode(), cmpMeta, mode, elm); + if ((BUILD.shadowDom || BUILD.scoped) && BUILD.cssAnnotations && cmpMeta.$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'); + if (BUILD.scoped && cmpMeta.$flags$ & 2 /* scopedCssEncapsulation */) { + elm.classList.add(scopeId + '-s'); + } + } + endAttachStyles(); +}; +const getScopeId = (tagName, mode) => 'sc-' + ((BUILD.mode && mode) ? tagName + '-' + mode : tagName); +const convertScopedToShadow = (css) => css.replace(/\/\*!@([^\/]+)\*\/[^\{]+\{/g, '$1{'); +/** + * 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 key = null; + let slotName = 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); + } + else if (BUILD.isDev && child.$flags$ === undefined) { + consoleDevError(`vNode passed as children has unexpected type. +Make sure it's using the correct h() function. +Empty objects can also be the cause, look for JSX comments that became objects.`); + } + 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) { + if (BUILD.isDev && nodeName === 'input') { + validateInputProperties(vnodeData); + } + // normalize class / classname attributes + if (BUILD.vdomKey && vnodeData.key) { + key = vnodeData.key; + } + if (BUILD.slotRelocation && vnodeData.name) { + slotName = vnodeData.name; + } + if (BUILD.vdomClass) { + const classData = vnodeData.className || vnodeData.class; + if (classData) { + vnodeData.class = typeof classData !== 'object' + ? classData + : Object.keys(classData) + .filter(k => classData[k]) + .join(' '); + } + } + } + if (BUILD.isDev && vNodeChildren.some(isHost)) { + consoleDevError(`The must be the single root component. Make sure: +- You are NOT using hostData() and in the same component. +- is used once, and it's the single root component of the render() function.`); + } + if (BUILD.vdomFunctional && typeof nodeName === 'function') { + // nodeName is a functional component + return nodeName(vnodeData, vNodeChildren, vdomFnUtils); + } + const vnode = newVNode(nodeName, null); + vnode.$attrs$ = vnodeData; + if (vNodeChildren.length > 0) { + vnode.$children$ = vNodeChildren; + } + if (BUILD.vdomKey) { + vnode.$key$ = key; + } + if (BUILD.slotRelocation) { + vnode.$name$ = slotName; + } + return vnode; +}; +const newVNode = (tag, text) => { + const vnode = { + $flags$: 0, + $tag$: tag, + $text$: text, + $elm$: null, + $children$: null + }; + if (BUILD.vdomAttribute) { + vnode.$attrs$ = null; + } + if (BUILD.vdomKey) { + vnode.$key$ = null; + } + if (BUILD.slotRelocation) { + vnode.$name$ = 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) => { + return { + vattrs: node.$attrs$, + vchildren: node.$children$, + vkey: node.$key$, + vname: node.$name$, + vtag: node.$tag$, + vtext: node.$text$ + }; +}; +const convertToPrivate = (node) => { + 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; +}; +const validateInputProperties = (vnodeData) => { + const props = Object.keys(vnodeData); + const typeIndex = props.indexOf('type'); + const minIndex = props.indexOf('min'); + const maxIndex = props.indexOf('max'); + const stepIndex = props.indexOf('min'); + const value = props.indexOf('value'); + if (value < typeIndex || value < minIndex || value < maxIndex || value < stepIndex) { + consoleDevWarn(`The "value" prop of should be set after "min", "max", "type" and "step"`); + } +}; +/** + * 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 (BUILD.vdomClass && 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 (BUILD.vdomStyle && memberName === 'style') { + // update style attribute, css properties and values + if (BUILD.updatable) { + for (const prop in oldValue) { + if (!newValue || newValue[prop] == null) { + if (!BUILD.hydrateServerSide && prop.includes('-')) { + elm.style.removeProperty(prop); + } + else { + elm.style[prop] = ''; + } + } + } + } + for (const prop in newValue) { + if (!oldValue || newValue[prop] !== oldValue[prop]) { + if (!BUILD.hydrateServerSide && prop.includes('-')) { + elm.style.setProperty(prop, newValue[prop]); + } + else { + elm.style[prop] = newValue[prop]; + } + } + } + } + else if (BUILD.vdomKey && memberName === 'key') + ; + else if (BUILD.vdomRef && memberName === 'ref') { + // minifier will clean this up + if (newValue) { + newValue(elm); + } + } + else if (BUILD.vdomListener && + (BUILD.lazyLoad + ? !isProp + : !elm.__lookupSetter__(memberName)) && + 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: + // // listens for "click" + // // listens for "Click" + // // listens for "ionChange" + // // 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 if (BUILD.vdomPropOrAttr) { + // 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 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) { } + } + /** + * Need to manually update attribute if: + * - memberName is not an attribute + * - if we are rendering the host element in order to reflect attribute + * - if it's a SVG, since properties might not work in + * - if the newValue is null/undefined or 'false'. + */ + let xlink = false; + if (BUILD.vdomXlink) { + if (ln !== (ln = ln.replace(/^xlink\:?/, ''))) { + memberName = ln; + xlink = true; + } + } + if (newValue == null || newValue === false) { + if (BUILD.vdomXlink && xlink) { + elm.removeAttributeNS(XLINK_NS, memberName); + } + else { + elm.removeAttribute(memberName); + } + } + else if ((!isProp || (flags & 4 /* isHost */) || isSvg) && !isComplex) { + newValue = newValue === true ? '' : newValue; + if (BUILD.vdomXlink && xlink) { + elm.setAttributeNS(XLINK_NS, memberName, newValue); + } + else { + 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; + if (BUILD.updatable) { + // 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; + let oldVNode; + if (BUILD.slotRelocation && !useNativeShadowDom) { + // remember for later we need to check to relocate nodes + checkSlotRelocate = true; + if (newVNode.$tag$ === 'slot') { + if (scopeId) { + // scoped css needs to add its scoped id to the parent element + parentElm.classList.add(scopeId + '-s'); + } + newVNode.$flags$ |= (newVNode.$children$) + // slot element has fallback content + // still create an element that "mocks" the slot element + ? 2 /* isSlotFallback */ + // slot element does not have fallback content + // create an html comment we'll use to always reference + // where actual slot content should sit next to + : 1 /* isSlotReference */; + } + } + if (BUILD.isDev && newVNode.$elm$) { + consoleError(`The JSX ${newVNode.$text$ !== null ? `"${newVNode.$text$}" text` : `"${newVNode.$tag$}" element`} node should not be shared within the same renderer. The renderer caches element lookups in order to improve performance. However, a side effect from this is that the exact same JSX node should not be reused. For more information please see https://stenciljs.com/docs/templating-jsx#avoid-shared-jsx-nodes`); + } + if (BUILD.vdomText && newVNode.$text$ !== null) { + // create text node + elm = newVNode.$elm$ = doc.createTextNode(newVNode.$text$); + } + else if (BUILD.slotRelocation && newVNode.$flags$ & 1 /* isSlotReference */) { + // create a slot reference node + elm = newVNode.$elm$ = (BUILD.isDebug || BUILD.hydrateServerSide) ? slotReferenceDebugNode(newVNode) : doc.createTextNode(''); + } + else { + if (BUILD.svg && !isSvgMode) { + isSvgMode = newVNode.$tag$ === 'svg'; + } + // create element + elm = newVNode.$elm$ = ((BUILD.svg) + ? doc.createElementNS(isSvgMode ? SVG_NS : HTML_NS, (BUILD.slotRelocation && newVNode.$flags$ & 2 /* isSlotFallback */) ? 'slot-fb' : newVNode.$tag$) + : doc.createElement((BUILD.slotRelocation && newVNode.$flags$ & 2 /* isSlotFallback */) ? 'slot-fb' : newVNode.$tag$)); + if (BUILD.svg && isSvgMode && newVNode.$tag$ === 'foreignObject') { + isSvgMode = false; + } + // add css classes, attrs, props, listeners, etc. + if (BUILD.vdomAttribute) { + updateElement(null, newVNode, isSvgMode); + } + if ((BUILD.shadowDom || BUILD.scoped) && 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, elm); + // return node could have been null + if (childNode) { + // append our new node + elm.appendChild(childNode); + } + } + } + if (BUILD.svg) { + if (newVNode.$tag$ === 'svg') { + // Only reset the SVG context when we're exiting element + isSvgMode = false; + } + else if (elm.tagName === 'foreignObject') { + // Reenter SVG context when we're exiting element + isSvgMode = true; + } + } + } + if (BUILD.slotRelocation) { + elm['s-hn'] = hostTagName; + if (newVNode.$flags$ & (2 /* isSlotFallback */ | 1 /* isSlotReference */)) { + // remember the content reference comment + elm['s-sr'] = true; + // remember the content reference comment + elm['s-cr'] = contentRef; + // remember the slot name, or empty string for default slot + elm['s-sn'] = newVNode.$name$ || ''; + // check if we've got an old vnode for this slot + oldVNode = oldParentVNode && oldParentVNode.$children$ && oldParentVNode.$children$[childIndex]; + if (oldVNode && oldVNode.$tag$ === newVNode.$tag$ && oldParentVNode.$elm$) { + // we've got an old slot vnode and the wrapper is being replaced + // so let's move the old slot content back to it's original location + putBackInOriginalLocation(oldParentVNode.$elm$, false); + } + } + } + return elm; +}; +const putBackInOriginalLocation = (parentElm, recursive) => { + plt.$flags$ |= 1 /* isTmpDisconnected */; + const oldSlotChildNodes = parentElm.childNodes; + for (let i = oldSlotChildNodes.length - 1; i >= 0; i--) { + const childNode = oldSlotChildNodes[i]; + if (childNode['s-hn'] !== hostTagName && childNode['s-ol']) { + // // this child node in the old element is from another component + // // remove this node from the old slot's parent + // childNode.remove(); + // and relocate it back to it's original location + parentReferenceNode(childNode).insertBefore(childNode, referenceNode(childNode)); + // remove the old original location comment entirely + // later on the patch function will know what to do + // and move this to the correct spot in need be + childNode['s-ol'].remove(); + childNode['s-ol'] = undefined; + checkSlotRelocate = true; + } + if (recursive) { + putBackInOriginalLocation(childNode, recursive); + } + } + plt.$flags$ &= ~1 /* isTmpDisconnected */; +}; +const addVnodes = (parentElm, before, parentVNode, vnodes, startIdx, endIdx) => { + let containerElm = ((BUILD.slotRelocation && parentElm['s-cr'] && parentElm['s-cr'].parentNode) || parentElm); + let childNode; + if (BUILD.shadowDom && containerElm.shadowRoot && containerElm.tagName === hostTagName) { + containerElm = containerElm.shadowRoot; + } + for (; startIdx <= endIdx; ++startIdx) { + if (vnodes[startIdx]) { + childNode = createElm(null, parentVNode, startIdx, parentElm); + if (childNode) { + vnodes[startIdx].$elm$ = childNode; + containerElm.insertBefore(childNode, BUILD.slotRelocation ? referenceNode(before) : before); + } + } + } +}; +const removeVnodes = (vnodes, startIdx, endIdx, vnode, elm) => { + for (; startIdx <= endIdx; ++startIdx) { + if (vnode = vnodes[startIdx]) { + elm = vnode.$elm$; + callNodeRefs(vnode); + if (BUILD.slotRelocation) { + // we're removing this element + // so it's possible we need to show slot fallback content now + checkSlotFallbackVisibility = true; + if (elm['s-ol']) { + // remove the original location comment + elm['s-ol'].remove(); + } + else { + // it's possible that child nodes of the node + // that's being removed are slot nodes + putBackInOriginalLocation(elm, true); + } + } + // remove the vnode's element from the dom + elm.remove(); + } + } +}; +const updateChildren = (parentElm, oldCh, newVNode, newCh) => { + let oldStartIdx = 0; + let newStartIdx = 0; + let idxInOld = 0; + let i = 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; + let elmToMove; + 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)) { + // Vnode moved right + if (BUILD.slotRelocation && (oldStartVnode.$tag$ === 'slot' || newEndVnode.$tag$ === 'slot')) { + putBackInOriginalLocation(oldStartVnode.$elm$.parentNode, false); + } + patch(oldStartVnode, newEndVnode); + parentElm.insertBefore(oldStartVnode.$elm$, oldEndVnode.$elm$.nextSibling); + oldStartVnode = oldCh[++oldStartIdx]; + newEndVnode = newCh[--newEndIdx]; + } + else if (isSameVnode(oldEndVnode, newStartVnode)) { + // Vnode moved left + if (BUILD.slotRelocation && (oldStartVnode.$tag$ === 'slot' || newEndVnode.$tag$ === 'slot')) { + putBackInOriginalLocation(oldEndVnode.$elm$.parentNode, false); + } + patch(oldEndVnode, newStartVnode); + parentElm.insertBefore(oldEndVnode.$elm$, oldStartVnode.$elm$); + oldEndVnode = oldCh[--oldEndIdx]; + newStartVnode = newCh[++newStartIdx]; + } + else { + // createKeyToOldIdx + idxInOld = -1; + if (BUILD.vdomKey) { + for (i = oldStartIdx; i <= oldEndIdx; ++i) { + if (oldCh[i] && oldCh[i].$key$ !== null && oldCh[i].$key$ === newStartVnode.$key$) { + idxInOld = i; + break; + } + } + } + if (BUILD.vdomKey && idxInOld >= 0) { + elmToMove = oldCh[idxInOld]; + if (elmToMove.$tag$ !== newStartVnode.$tag$) { + node = createElm(oldCh && oldCh[newStartIdx], newVNode, idxInOld, parentElm); + } + else { + patch(elmToMove, newStartVnode); + oldCh[idxInOld] = undefined; + node = elmToMove.$elm$; + } + newStartVnode = newCh[++newStartIdx]; + } + else { + // new element + node = createElm(oldCh && oldCh[newStartIdx], newVNode, newStartIdx, parentElm); + newStartVnode = newCh[++newStartIdx]; + } + if (node) { + if (BUILD.slotRelocation) { + parentReferenceNode(oldStartVnode.$elm$).insertBefore(node, referenceNode(oldStartVnode.$elm$)); + } + else { + 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 (BUILD.updatable && 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$) { + if (BUILD.slotRelocation && vnode1.$tag$ === 'slot') { + return vnode1.$name$ === vnode2.$name$; + } + if (BUILD.vdomKey) { + return vnode1.$key$ === vnode2.$key$; + } + return true; + } + return false; +}; +const referenceNode = (node) => { + // this node was relocated to a new location in the dom + // because of some other component's slot + // but we still have an html comment in place of where + // it's original location was according to it's original vdom + return (node && node['s-ol']) || node; +}; +const parentReferenceNode = (node) => (node['s-ol'] ? node['s-ol'] : node).parentNode; +const patch = (oldVNode, newVNode) => { + const elm = newVNode.$elm$ = oldVNode.$elm$; + const oldChildren = oldVNode.$children$; + const newChildren = newVNode.$children$; + const tag = newVNode.$tag$; + const text = newVNode.$text$; + let defaultHolder; + if (!BUILD.vdomText || text === null) { + if (BUILD.svg) { + // test if we're rendering an svg element, or still rendering nodes inside of one + // only add this to the when the compiler sees we're using an svg somewhere + isSvgMode = (tag === 'svg') + ? true + : (tag === 'foreignObject') + ? false + : isSvgMode; + } + // element node + if (BUILD.vdomAttribute || BUILD.reflect) { + if (BUILD.slot && 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 (BUILD.updatable && 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 (BUILD.updatable && BUILD.vdomText && 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 (BUILD.updatable && oldChildren !== null) { + // no new child vnodes, but there are old child vnodes to remove + removeVnodes(oldChildren, 0, oldChildren.length - 1); + } + if (BUILD.svg && isSvgMode && tag === 'svg') { + isSvgMode = false; + } + } + else if (BUILD.vdomText && BUILD.slotRelocation && (defaultHolder = elm['s-cr'])) { + // this element has slotted content + defaultHolder.parentNode.textContent = text; + } + else if (BUILD.vdomText && oldVNode.$text$ !== text) { + // update the text content for the text only vnode + // and also only if the text is different than before + elm.data = text; + } +}; +const updateFallbackSlotVisibility = (elm) => { + // tslint:disable-next-line: prefer-const + let childNodes = elm.childNodes; + let childNode; + let i; + let ilen; + let j; + let slotNameAttr; + let nodeType; + for (i = 0, ilen = childNodes.length; i < ilen; i++) { + childNode = childNodes[i]; + if (childNode.nodeType === 1 /* ElementNode */) { + if (childNode['s-sr']) { + // this is a slot fallback node + // get the slot name for this slot reference node + slotNameAttr = childNode['s-sn']; + // by default always show a fallback slot node + // then hide it if there are other slots in the light dom + childNode.hidden = false; + for (j = 0; j < ilen; j++) { + if (childNodes[j]['s-hn'] !== childNode['s-hn']) { + // this sibling node is from a different component + nodeType = childNodes[j].nodeType; + if (slotNameAttr !== '') { + // this is a named fallback slot node + if (nodeType === 1 /* ElementNode */ && slotNameAttr === childNodes[j].getAttribute('slot')) { + childNode.hidden = true; + break; + } + } + else { + // this is a default fallback slot node + // any element or text node (with content) + // should hide the default fallback slot node + if (nodeType === 1 /* ElementNode */ || (nodeType === 3 /* TextNode */ && childNodes[j].textContent.trim() !== '')) { + childNode.hidden = true; + break; + } + } + } + } + } + // keep drilling down + updateFallbackSlotVisibility(childNode); + } + } +}; +const relocateNodes = []; +const relocateSlotContent = (elm) => { + // tslint:disable-next-line: prefer-const + let childNode; + let node; + let hostContentNodes; + let slotNameAttr; + let relocateNodeData; + let j; + let i = 0; + let childNodes = elm.childNodes; + let ilen = childNodes.length; + for (; i < ilen; i++) { + childNode = childNodes[i]; + if (childNode['s-sr'] && (node = childNode['s-cr'])) { + // first got the content reference comment node + // then we got it's parent, which is where all the host content is in now + hostContentNodes = node.parentNode.childNodes; + slotNameAttr = childNode['s-sn']; + for (j = hostContentNodes.length - 1; j >= 0; j--) { + node = hostContentNodes[j]; + if (!node['s-cn'] && !node['s-nr'] && node['s-hn'] !== childNode['s-hn']) { + // let's do some relocating to its new home + // but never relocate a content reference node + // that is suppose to always represent the original content location + if (isNodeLocatedInSlot(node, slotNameAttr)) { + // it's possible we've already decided to relocate this node + relocateNodeData = relocateNodes.find(r => r.$nodeToRelocate$ === node); + // made some changes to slots + // let's make sure we also double check + // fallbacks are correctly hidden or shown + checkSlotFallbackVisibility = true; + node['s-sn'] = node['s-sn'] || slotNameAttr; + if (relocateNodeData) { + // previously we never found a slot home for this node + // but turns out we did, so let's remember it now + relocateNodeData.$slotRefNode$ = childNode; + } + else { + // add to our list of nodes to relocate + relocateNodes.push({ + $slotRefNode$: childNode, + $nodeToRelocate$: node, + }); + } + if (node['s-sr']) { + relocateNodes.forEach(relocateNode => { + if (isNodeLocatedInSlot(relocateNode.$nodeToRelocate$, node['s-sn'])) { + relocateNodeData = relocateNodes.find(r => r.$nodeToRelocate$ === node); + if (relocateNodeData) { + relocateNode.$slotRefNode$ = relocateNodeData.$slotRefNode$; + } + } + }); + } + } + else if (!relocateNodes.some(r => r.$nodeToRelocate$ === node)) { + // so far this element does not have a slot home, not setting slotRefNode on purpose + // if we never find a home for this element then we'll need to hide it + relocateNodes.push({ + $nodeToRelocate$: node, + }); + } + } + } + } + if (childNode.nodeType === 1 /* ElementNode */) { + relocateSlotContent(childNode); + } + } +}; +const isNodeLocatedInSlot = (nodeToRelocate, slotNameAttr) => { + if (nodeToRelocate.nodeType === 1 /* ElementNode */) { + if (nodeToRelocate.getAttribute('slot') === null && slotNameAttr === '') { + return true; + } + if (nodeToRelocate.getAttribute('slot') === slotNameAttr) { + return true; + } + return false; + } + if (nodeToRelocate['s-sn'] === slotNameAttr) { + return true; + } + return slotNameAttr === ''; +}; +const callNodeRefs = (vNode) => { + if (BUILD.vdomRef) { + vNode.$attrs$ && vNode.$attrs$.ref && vNode.$attrs$.ref(null); + vNode.$children$ && vNode.$children$.forEach(callNodeRefs); + } +}; +const renderVdom = (hostElm, hostRef, cmpMeta, renderFnResults) => { + hostTagName = hostElm.tagName; + // runtime check + if (BUILD.isDev && Array.isArray(renderFnResults) && renderFnResults.some(isHost)) { + throw new Error(`The must be the single root component. +Looks like the render() function of "${hostTagName.toLowerCase()}" is returning an array that contains the . + +The render() function should look like this instead: + +render() { + // Do not return an array + return ( + {content} + ); +} +`); + } + const oldVNode = hostRef.$vnode$ || newVNode(null, null); + const rootVnode = isHost(renderFnResults) + ? renderFnResults + : h(null, null, renderFnResults); + if (BUILD.reflect && cmpMeta.$attrsToReflect$) { + rootVnode.$attrs$ = rootVnode.$attrs$ || {}; + cmpMeta.$attrsToReflect$.forEach(([propName, attribute]) => rootVnode.$attrs$[attribute] = hostElm[propName]); + } + rootVnode.$tag$ = null; + rootVnode.$flags$ |= 4 /* isHost */; + hostRef.$vnode$ = rootVnode; + rootVnode.$elm$ = oldVNode.$elm$ = (BUILD.shadowDom ? hostElm.shadowRoot || hostElm : hostElm); + if (BUILD.scoped || BUILD.shadowDom) { + scopeId = hostElm['s-sc']; + } + if (BUILD.slotRelocation) { + contentRef = hostElm['s-cr']; + useNativeShadowDom = supportsShadowDom && (cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) !== 0; + // always reset + checkSlotFallbackVisibility = false; + } + // synchronous patch + patch(oldVNode, rootVnode); + if (BUILD.slotRelocation) { + if (checkSlotRelocate) { + relocateSlotContent(rootVnode.$elm$); + let relocateData; + let nodeToRelocate; + let orgLocationNode; + let parentNodeRef; + let insertBeforeNode; + let refNode; + let i = 0; + for (; i < relocateNodes.length; i++) { + relocateData = relocateNodes[i]; + nodeToRelocate = relocateData.$nodeToRelocate$; + if (!nodeToRelocate['s-ol']) { + // add a reference node marking this node's original location + // keep a reference to this node for later lookups + orgLocationNode = (BUILD.isDebug || BUILD.hydrateServerSide) + ? originalLocationDebugNode(nodeToRelocate) + : doc.createTextNode(''); + orgLocationNode['s-nr'] = nodeToRelocate; + nodeToRelocate.parentNode.insertBefore((nodeToRelocate['s-ol'] = orgLocationNode), nodeToRelocate); + } + } + // while we're moving nodes around existing nodes, temporarily disable + // the disconnectCallback from working + plt.$flags$ |= 1 /* isTmpDisconnected */; + for (i = 0; i < relocateNodes.length; i++) { + relocateData = relocateNodes[i]; + nodeToRelocate = relocateData.$nodeToRelocate$; + if (relocateData.$slotRefNode$) { + // by default we're just going to insert it directly + // after the slot reference node + parentNodeRef = relocateData.$slotRefNode$.parentNode; + insertBeforeNode = relocateData.$slotRefNode$.nextSibling; + orgLocationNode = nodeToRelocate['s-ol']; + while (orgLocationNode = orgLocationNode.previousSibling) { + refNode = orgLocationNode['s-nr']; + if (refNode && + refNode['s-sn'] === nodeToRelocate['s-sn'] && + parentNodeRef === refNode.parentNode) { + refNode = refNode.nextSibling; + if (!refNode || !refNode['s-nr']) { + insertBeforeNode = refNode; + break; + } + } + } + if ((!insertBeforeNode && parentNodeRef !== nodeToRelocate.parentNode) || + (nodeToRelocate.nextSibling !== insertBeforeNode)) { + // we've checked that it's worth while to relocate + // since that the node to relocate + // has a different next sibling or parent relocated + if (nodeToRelocate !== insertBeforeNode) { + if (!nodeToRelocate['s-hn'] && nodeToRelocate['s-ol']) { + // probably a component in the index.html that doesn't have it's hostname set + nodeToRelocate['s-hn'] = nodeToRelocate['s-ol'].parentNode.nodeName; + } + // add it back to the dom but in its new home + parentNodeRef.insertBefore(nodeToRelocate, insertBeforeNode); + } + } + } + else { + // this node doesn't have a slot home to go to, so let's hide it + if (nodeToRelocate.nodeType === 1 /* ElementNode */) { + nodeToRelocate.hidden = true; + } + } + } + // done moving nodes around + // allow the disconnect callback to work again + plt.$flags$ &= ~1 /* isTmpDisconnected */; + } + if (checkSlotFallbackVisibility) { + updateFallbackSlotVisibility(rootVnode.$elm$); + } + // always reset + relocateNodes.length = 0; + } +}; +// slot comment debug nodes only created with the `--debug` flag +// otherwise these nodes are text nodes w/out content +const slotReferenceDebugNode = (slotVNode) => doc.createComment(` (host=${hostTagName.toLowerCase()})`); +const originalLocationDebugNode = (nodeToRelocate) => doc.createComment(`org-location for ` + + (nodeToRelocate.localName ? + `<${nodeToRelocate.localName}> (host=${nodeToRelocate['s-hn']})` : + `[${nodeToRelocate.textContent}]`)); +const attachToAncestor = (hostRef, ancestorComponent) => { + if (BUILD.asyncLoading && ancestorComponent && !hostRef.$onRenderResolve$) { + ancestorComponent['s-p'].push(new Promise(r => hostRef.$onRenderResolve$ = r)); + } +}; +const scheduleUpdate = (elm, hostRef, cmpMeta, isInitialLoad) => { + if (BUILD.taskQueue && BUILD.updatable) { + hostRef.$flags$ |= 16 /* isQueuedForUpdate */; + } + if (BUILD.asyncLoading && hostRef.$flags$ & 4 /* isWaitingForChildren */) { + hostRef.$flags$ |= 512 /* needsRerender */; + return; + } + const endSchedule = createTime('scheduleUpdate', cmpMeta.$tagName$); + const ancestorComponent = hostRef.$ancestorComponent$; + const instance = BUILD.lazyLoad ? hostRef.$lazyInstance$ : elm; + const update = () => updateComponent(elm, hostRef, cmpMeta, instance, isInitialLoad); + attachToAncestor(hostRef, ancestorComponent); + let promise; + if (isInitialLoad) { + if (BUILD.lazyLoad && BUILD.hostListener) { + hostRef.$flags$ |= 256 /* isListenReady */; + if (hostRef.$queuedListeners$) { + hostRef.$queuedListeners$.forEach(([methodName, event]) => safeCall(instance, methodName, event)); + hostRef.$queuedListeners$ = null; + } + } + emitLifecycleEvent(elm, 'componentWillLoad'); + if (BUILD.cmpWillLoad) { + promise = safeCall(instance, 'componentWillLoad'); + } + } + else { + emitLifecycleEvent(elm, 'componentWillUpdate'); + if (BUILD.cmpWillUpdate) { + promise = safeCall(instance, 'componentWillUpdate'); + } + } + emitLifecycleEvent(elm, 'componentWillRender'); + if (BUILD.cmpWillRender) { + promise = then(promise, () => safeCall(instance, 'componentWillRender')); + } + endSchedule(); + // there is no ancestorc omponent or the ancestor component + // has already fired off its lifecycle update then + // fire off the initial update + return then(promise, BUILD.taskQueue + ? () => writeTask(update) + : update); +}; +const updateComponent = (elm, hostRef, cmpMeta, instance, isInitialLoad) => { + // updateComponent + const endUpdate = createTime('update', cmpMeta.$tagName$); + const rc = elm['s-rc']; + if (BUILD.style && isInitialLoad) { + // DOM WRITE! + attachStyles(elm, cmpMeta, hostRef.$modeName$); + } + const endRender = createTime('render', cmpMeta.$tagName$); + if (BUILD.isDev) { + hostRef.$flags$ |= 1024 /* devOnRender */; + } + if (BUILD.hasRenderFn || BUILD.reflect) { + if (BUILD.vdomRender || BUILD.reflect) { + // 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(elm, hostRef, cmpMeta, callRender(instance, elm)); + } + else { + elm.textContent = callRender(instance, elm); + } + } + if (BUILD.cssVarShim && plt.$cssShim$) { + plt.$cssShim$.updateHost(elm); + } + if (BUILD.isDev) { + hostRef.$renderCount$++; + hostRef.$flags$ &= ~1024 /* devOnRender */; + } + if (BUILD.updatable && BUILD.taskQueue) { + hostRef.$flags$ &= ~16 /* isQueuedForUpdate */; + } + if (BUILD.hydrateServerSide) { + try { + // manually connected child components during server-side hydrate + serverSideConnected(elm); + if (isInitialLoad) { + // using only during server-side hydrate + if (cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) { + elm['s-en'] = ''; + } + else if (cmpMeta.$flags$ & 2 /* scopedCssEncapsulation */) { + elm['s-en'] = 'c'; + } + } + } + catch (e) { + consoleError(e); + } + } + if (BUILD.updatable || BUILD.lazyLoad) { + hostRef.$flags$ |= 2 /* hasRendered */; + } + if (BUILD.asyncLoading && 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.forEach(cb => cb()); + elm['s-rc'] = undefined; + } + endRender(); + endUpdate(); + if (BUILD.asyncLoading) { + const childrenPromises = elm['s-p']; + const postUpdate = () => postUpdateComponent(elm, hostRef, cmpMeta); + if (childrenPromises.length === 0) { + postUpdate(); + } + else { + Promise.all(childrenPromises).then(postUpdate); + hostRef.$flags$ |= 4 /* isWaitingForChildren */; + childrenPromises.length = 0; + } + } + else { + postUpdateComponent(elm, hostRef, cmpMeta); + } +}; +const callRender = (instance, elm) => { + try { + renderingElement = elm; + instance = (BUILD.allRenderFn) ? instance.render() : (instance.render && instance.render()); + } + catch (e) { + consoleError(e); + } + renderingElement = null; + return instance; +}; +const getRenderingElement = () => renderingElement; +const postUpdateComponent = (elm, hostRef, cmpMeta) => { + const endPostUpdate = createTime('postUpdate', cmpMeta.$tagName$); + const instance = BUILD.lazyLoad ? hostRef.$lazyInstance$ : elm; + const ancestorComponent = hostRef.$ancestorComponent$; + if (BUILD.cmpDidRender) { + if (BUILD.isDev) { + hostRef.$flags$ |= 1024 /* devOnRender */; + } + safeCall(instance, 'componentDidRender'); + if (BUILD.isDev) { + hostRef.$flags$ &= ~1024 /* devOnRender */; + } + } + emitLifecycleEvent(elm, 'componentDidRender'); + if (!(hostRef.$flags$ & 64 /* hasLoadedComponent */)) { + hostRef.$flags$ |= 64 /* hasLoadedComponent */; + if (BUILD.asyncLoading && BUILD.cssAnnotations) { + // DOM WRITE! + addHydratedFlag(elm); + } + if (BUILD.cmpDidLoad) { + if (BUILD.isDev) { + hostRef.$flags$ |= 2048 /* devOnDidLoad */; + } + safeCall(instance, 'componentDidLoad'); + if (BUILD.isDev) { + hostRef.$flags$ &= ~2048 /* devOnDidLoad */; + } + } + emitLifecycleEvent(elm, 'componentDidLoad'); + endPostUpdate(); + if (BUILD.asyncLoading) { + hostRef.$onReadyResolve$(elm); + if (!ancestorComponent) { + appDidLoad(cmpMeta.$tagName$); + } + } + } + else { + if (BUILD.cmpDidUpdate) { + // we've already loaded this component + // fire off the user's componentDidUpdate method (if one was provided) + // componentDidUpdate runs AFTER render() has been called + // and all child components have finished updating + if (BUILD.isDev) { + hostRef.$flags$ |= 1024 /* devOnRender */; + } + safeCall(instance, 'componentDidUpdate'); + if (BUILD.isDev) { + hostRef.$flags$ &= ~1024 /* devOnRender */; + } + } + emitLifecycleEvent(elm, 'componentDidUpdate'); + endPostUpdate(); + } + if (BUILD.hotModuleReplacement) { + elm['s-hmr-load'] && elm['s-hmr-load'](); + } + if (BUILD.method && BUILD.lazyLoad) { + hostRef.$onInstanceResolve$(elm); + } + // load events fire from bottom to top + // the deepest elements load first then bubbles up + if (BUILD.asyncLoading) { + if (hostRef.$onRenderResolve$) { + hostRef.$onRenderResolve$(); + hostRef.$onRenderResolve$ = undefined; + } + if (hostRef.$flags$ & 512 /* needsRerender */) { + nextTick(() => scheduleUpdate(elm, hostRef, cmpMeta, false)); + } + hostRef.$flags$ &= ~(4 /* isWaitingForChildren */ | 512 /* needsRerender */); + } + // ( •_•) + // ( •_•)>⌐■-■ + // (⌐■_■) +}; +const forceUpdate = (elm, cmpMeta) => { + if (BUILD.updatable) { + const hostRef = getHostRef(elm); + const isConnected = hostRef.$hostElement$.isConnected; + if (isConnected && (hostRef.$flags$ & (2 /* hasRendered */ | 16 /* isQueuedForUpdate */)) === 2 /* hasRendered */) { + scheduleUpdate(elm, hostRef, cmpMeta, false); + } + // Returns "true" when the forced update was successfully scheduled + return isConnected; + } + return false; +}; +const appDidLoad = (who) => { + // on appload + // we have finish the first big initial render + if (BUILD.cssAnnotations) { + addHydratedFlag(doc.documentElement); + } + if (!BUILD.hydrateServerSide) { + plt.$flags$ |= 2 /* appLoaded */; + } + emitLifecycleEvent(doc, 'appload'); + if (BUILD.profile) { + performance.measure(`[Stencil] ${NAMESPACE} initial load (by ${who})`, 'st:app:start'); + } +}; +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 emitLifecycleEvent = (elm, lifecycleName) => { + if (BUILD.lifecycleDOMEvents) { + elm.dispatchEvent(new CustomEvent('stencil_' + lifecycleName, { 'bubbles': true, 'composed': true })); + } +}; +const addHydratedFlag = (elm) => BUILD.hydratedClass ? + elm.classList.add('hydrated') : + BUILD.hydratedAttribute ? + elm.setAttribute('hydrated', '') : + undefined; +const serverSideConnected = (elm) => { + const children = elm.children; + if (children != null) { + for (let i = 0, ii = children.length; i < ii; i++) { + const childElm = children[i]; + if (typeof childElm.connectedCallback === 'function') { + childElm.connectedCallback(); + } + serverSideConnected(childElm); + } + } +}; +const cloneNodeFix = (HostElementPrototype) => { + const orgCloneNode = HostElementPrototype.cloneNode; + HostElementPrototype.cloneNode = function (deep) { + const srcNode = this; + const isShadowDom = BUILD.shadowDom ? srcNode.shadowRoot && supportsShadowDom : false; + const clonedNode = orgCloneNode.call(srcNode, isShadowDom ? deep : false); + if (BUILD.slot && !isShadowDom && deep) { + let i = 0; + let slotted; + for (; i < srcNode.childNodes.length; i++) { + slotted = srcNode.childNodes[i]['s-nr']; + if (slotted) { + if (BUILD.appendChildSlotFix && clonedNode.__appendChild) { + clonedNode.__appendChild(slotted.cloneNode(true)); + } + else { + clonedNode.appendChild(slotted.cloneNode(true)); + } + } + } + } + return clonedNode; + }; +}; +const appendChildSlotFix = (HostElementPrototype) => { + HostElementPrototype.__appendChild = HostElementPrototype.appendChild; + HostElementPrototype.appendChild = function (newChild) { + const slotName = newChild['s-sn'] = getSlotName(newChild); + const slotNode = getHostSlotNode(this, slotName); + if (slotNode) { + const slotChildNodes = getHostSlotChildNodes(slotNode, slotName); + const appendAfter = slotChildNodes[slotChildNodes.length - 1]; + return appendAfter.parentNode.insertBefore(newChild, appendAfter.nextSibling); + } + return this.__appendChild(newChild); + }; +}; +const getSlotName = (node) => (node['s-sn']) || + (node.nodeType === 1 && node.getAttribute('slot')) || ''; +const getHostSlotNode = (elm, slotName) => { + let childNodes = elm.childNodes; + let i = 0; + let childNode; + for (; i < childNodes.length; i++) { + childNode = childNodes[i]; + if (childNode['s-sr'] && childNode['s-sn'] === slotName) { + return childNode; + } + childNode = getHostSlotNode(childNode, slotName); + if (childNode) { + return childNode; + } + } + return null; +}; +const getHostSlotChildNodes = (n, slotName) => { + const childNodes = [n]; + while ((n = n.nextSibling) && n['s-sn'] === slotName) { + childNodes.push(n); + } + return childNodes; +}; +const addEventListeners = (elm, hostRef, listeners) => { + hostRef.$queuedListeners$ = hostRef.$queuedListeners$ || []; + const removeFns = listeners.map(([flags, name, method]) => { + const target = (BUILD.hostListenerTarget ? getHostListenerTarget(elm, flags) : elm); + const handler = hostListenerProxy(hostRef, method); + const opts = hostListenerOpts(flags); + plt.ael(target, name, handler, opts); + return () => plt.rel(target, name, handler, opts); + }); + return () => removeFns.forEach(fn => fn()); +}; +const hostListenerProxy = (hostRef, methodName) => { + return (ev) => { + if (BUILD.lazyLoad) { + if (hostRef.$flags$ & 256 /* isListenReady */) { + // instance is ready, let's call it's member method for this event + hostRef.$lazyInstance$[methodName](ev); + } + else { + hostRef.$queuedListeners$.push([methodName, ev]); + } + } + else { + hostRef.$hostElement$[methodName](ev); + } + }; +}; +const getHostListenerTarget = (elm, flags) => { + if (BUILD.hostListenerTargetDocument && flags & 4 /* TargetDocument */) + return doc; + if (BUILD.hostListenerTargetWindow && flags & 8 /* TargetWindow */) + return win; + if (BUILD.hostListenerTargetBody && flags & 32 /* TargetBody */) + return doc.body; + if (BUILD.hostListenerTargetParent && flags & 16 /* TargetParent */) + return elm.parentElement; + return elm; +}; +const hostListenerOpts = (flags) => supportsListenerOptions ? + { + 'passive': (flags & 1 /* Passive */) !== 0, + 'capture': (flags & 2 /* Capture */) !== 0, + } + : (flags & 2 /* Capture */) !== 0; +const initializeClientHydrate = (hostElm, tagName, hostId, hostRef) => { + const endHydrate = createTime('hydrateClient', tagName); + const shadowRoot = hostElm.shadowRoot; + const childRenderNodes = []; + const slotNodes = []; + const shadowRootNodes = (BUILD.shadowDom && shadowRoot ? [] : null); + const vnode = hostRef.$vnode$ = newVNode(tagName, null); + if (!plt.$orgLocNodes$) { + initializeDocumentHydrate(doc.body, plt.$orgLocNodes$ = new Map()); + } + hostElm[HYDRATE_ID] = hostId; + hostElm.removeAttribute(HYDRATE_ID); + clientHydrate(vnode, childRenderNodes, slotNodes, shadowRootNodes, hostElm, hostElm, hostId); + childRenderNodes.forEach(c => { + const orgLocationId = c.$hostId$ + '.' + c.$nodeId$; + const orgLocationNode = plt.$orgLocNodes$.get(orgLocationId); + const node = c.$elm$; + if (orgLocationNode && (supportsShadowDom && orgLocationNode['s-en'] === '')) { + orgLocationNode.parentNode.insertBefore(node, orgLocationNode.nextSibling); + } + if (!shadowRoot) { + node['s-hn'] = tagName; + if (orgLocationNode) { + node['s-ol'] = orgLocationNode; + node['s-ol']['s-nr'] = node; + } + } + plt.$orgLocNodes$.delete(orgLocationId); + }); + if (BUILD.shadowDom && shadowRoot) { + shadowRootNodes.forEach(shadowRootNode => { + if (shadowRootNode) { + shadowRoot.appendChild(shadowRootNode); + } + }); + } + endHydrate(); +}; +const clientHydrate = (parentVNode, childRenderNodes, slotNodes, shadowRootNodes, hostElm, node, hostId) => { + let childNodeType; + let childIdSplt; + let childVNode; + let i; + if (node.nodeType === 1 /* ElementNode */) { + childNodeType = node.getAttribute(HYDRATE_CHILD_ID); + if (childNodeType) { + // got the node data from the element's attribute + // `${hostId}.${nodeId}.${depth}.${index}` + childIdSplt = childNodeType.split('.'); + if (childIdSplt[0] === hostId || childIdSplt[0] === '0') { + childVNode = { + $flags$: 0, + $hostId$: childIdSplt[0], + $nodeId$: childIdSplt[1], + $depth$: childIdSplt[2], + $index$: childIdSplt[3], + $tag$: node.tagName.toLowerCase(), + $elm$: node, + $attrs$: null, + $children$: null, + $key$: null, + $name$: null, + $text$: null + }; + childRenderNodes.push(childVNode); + node.removeAttribute(HYDRATE_CHILD_ID); + // this is a new child vnode + // so ensure its parent vnode has the vchildren array + if (!parentVNode.$children$) { + parentVNode.$children$ = []; + } + // add our child vnode to a specific index of the vnode's children + parentVNode.$children$[childVNode.$index$] = childVNode; + // this is now the new parent vnode for all the next child checks + parentVNode = childVNode; + if (shadowRootNodes && childVNode.$depth$ === '0') { + shadowRootNodes[childVNode.$index$] = childVNode.$elm$; + } + } + } + // recursively drill down, end to start so we can remove nodes + for (i = node.childNodes.length - 1; i >= 0; i--) { + clientHydrate(parentVNode, childRenderNodes, slotNodes, shadowRootNodes, hostElm, node.childNodes[i], hostId); + } + if (node.shadowRoot) { + // keep drilling down through the shadow root nodes + for (i = node.shadowRoot.childNodes.length - 1; i >= 0; i--) { + clientHydrate(parentVNode, childRenderNodes, slotNodes, shadowRootNodes, hostElm, node.shadowRoot.childNodes[i], hostId); + } + } + } + else if (node.nodeType === 8 /* CommentNode */) { + // `${COMMENT_TYPE}.${hostId}.${nodeId}.${depth}.${index}` + childIdSplt = node.nodeValue.split('.'); + if (childIdSplt[1] === hostId || childIdSplt[1] === '0') { + // comment node for either the host id or a 0 host id + childNodeType = childIdSplt[0]; + childVNode = { + $flags$: 0, + $hostId$: childIdSplt[1], + $nodeId$: childIdSplt[2], + $depth$: childIdSplt[3], + $index$: childIdSplt[4], + $elm$: node, + $attrs$: null, + $children$: null, + $key$: null, + $name$: null, + $tag$: null, + $text$: null + }; + if (childNodeType === TEXT_NODE_ID) { + childVNode.$elm$ = node.nextSibling; + if (childVNode.$elm$ && childVNode.$elm$.nodeType === 3 /* TextNode */) { + childVNode.$text$ = childVNode.$elm$.textContent; + childRenderNodes.push(childVNode); + // remove the text comment since it's no longer needed + node.remove(); + if (!parentVNode.$children$) { + parentVNode.$children$ = []; + } + parentVNode.$children$[childVNode.$index$] = childVNode; + if (shadowRootNodes && childVNode.$depth$ === '0') { + shadowRootNodes[childVNode.$index$] = childVNode.$elm$; + } + } + } + else if (childVNode.$hostId$ === hostId) { + // this comment node is specifcally for this host id + if (childNodeType === SLOT_NODE_ID) { + // `${SLOT_NODE_ID}.${hostId}.${nodeId}.${depth}.${index}.${slotName}`; + childVNode.$tag$ = 'slot'; + if (childIdSplt[5]) { + node['s-sn'] = childVNode.$name$ = childIdSplt[5]; + } + else { + node['s-sn'] = ''; + } + node['s-sr'] = true; + if (BUILD.shadowDom && shadowRootNodes) { + // browser support shadowRoot and this is a shadow dom component + // create an actual slot element + childVNode.$elm$ = doc.createElement(childVNode.$tag$); + if (childVNode.$name$) { + // add the slot name attribute + childVNode.$elm$.setAttribute('name', childVNode.$name$); + } + // insert the new slot element before the slot comment + node.parentNode.insertBefore(childVNode.$elm$, node); + // remove the slot comment since it's not needed for shadow + node.remove(); + if (childVNode.$depth$ === '0') { + shadowRootNodes[childVNode.$index$] = childVNode.$elm$; + } + } + slotNodes.push(childVNode); + if (!parentVNode.$children$) { + parentVNode.$children$ = []; + } + parentVNode.$children$[childVNode.$index$] = childVNode; + } + else if (childNodeType === CONTENT_REF_ID) { + // `${CONTENT_REF_ID}.${hostId}`; + if (BUILD.shadowDom && shadowRootNodes) { + // remove the content ref comment since it's not needed for shadow + node.remove(); + } + else if (BUILD.slotRelocation) { + hostElm['s-cr'] = node; + node['s-cn'] = true; + } + } + } + } + } + else if (parentVNode && parentVNode.$tag$ === 'style') { + const vnode = newVNode(null, node.textContent); + vnode.$elm$ = node; + vnode.$index$ = '0'; + parentVNode.$children$ = [vnode]; + } +}; +const initializeDocumentHydrate = (node, orgLocNodes) => { + if (node.nodeType === 1 /* ElementNode */) { + let i = 0; + for (; i < node.childNodes.length; i++) { + initializeDocumentHydrate(node.childNodes[i], orgLocNodes); + } + if (node.shadowRoot) { + for (i = 0; i < node.shadowRoot.childNodes.length; i++) { + initializeDocumentHydrate(node.shadowRoot.childNodes[i], orgLocNodes); + } + } + } + else if (node.nodeType === 8 /* CommentNode */) { + const childIdSplt = node.nodeValue.split('.'); + if (childIdSplt[0] === ORG_LOCATION_ID) { + orgLocNodes.set(childIdSplt[1] + '.' + childIdSplt[2], node); + node.nodeValue = ''; + // useful to know if the original location is + // the root light-dom of a shadow dom component + node['s-en'] = childIdSplt[3]; + } + } +}; +const parsePropertyValue = (propValue, propType) => { + // ensure this value is of the correct prop type + if (propValue != null && !isComplexType(propValue)) { + if (BUILD.propBoolean && 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 (BUILD.propNumber && propType & 2 /* Number */) { + // force it to be a number + return parseFloat(propValue); + } + if (BUILD.propString && 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 = BUILD.lazyLoad ? hostRef.$hostElement$ : ref; + const oldVal = hostRef.$instanceValues$.get(propName); + const flags = hostRef.$flags$; + const instance = BUILD.lazyLoad ? hostRef.$lazyInstance$ : elm; + newVal = parsePropertyValue(newVal, cmpMeta.$members$[propName][0]); + if (newVal !== oldVal && (!BUILD.lazyLoad || !(flags & 8 /* isConstructingInstance */) || oldVal === undefined)) { + // gadzooks! the property's value has changed!! + // set our new value! + hostRef.$instanceValues$.set(propName, newVal); + if (BUILD.isDev) { + if (hostRef.$flags$ & 1024 /* devOnRender */) { + consoleDevWarn(`The state/prop "${propName}" changed during rendering. This can potentially lead to infinite-loops and other bugs.`, '\nElement', elm, '\nNew value', newVal, '\nOld value', oldVal); + } + else if (hostRef.$flags$ & 2048 /* devOnDidLoad */) { + consoleDevWarn(`The state/prop "${propName}" changed during "componentDidLoad()", this triggers extra re-renders, try to setup on "componentWillLoad()"`, '\nElement', elm, '\nNew value', newVal, '\nOld value', oldVal); + } + } + if (!BUILD.lazyLoad || instance) { + // get an array of method names of watch functions to call + if (BUILD.watchCallback && cmpMeta.$watchers$ && flags & 128 /* isWatchReady */) { + const watchMethods = cmpMeta.$watchers$[propName]; + if (watchMethods) { + // this instance is watching for when this property changed + watchMethods.forEach(watchMethodName => { + try { + // fire off each of the watch methods that are watching this property + instance[watchMethodName](newVal, oldVal, propName); + } + catch (e) { + consoleError(e); + } + }); + } + } + if (BUILD.updatable && (flags & (2 /* hasRendered */ | 16 /* isQueuedForUpdate */)) === 2 /* hasRendered */) { + if (BUILD.cmpShouldUpdate && instance.componentShouldUpdate) { + if (instance.componentShouldUpdate(newVal, oldVal, propName) === false) { + return; + } + } + // 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(elm, hostRef, cmpMeta, false); + } + } + } +}; +const proxyComponent = (Cstr, cmpMeta, flags) => { + if (BUILD.member && cmpMeta.$members$) { + if (BUILD.watchCallback && 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.forEach(([memberName, [memberFlags]]) => { + if ((BUILD.prop || BUILD.state) && ((memberFlags & 31 /* Prop */) || + ((!BUILD.lazyLoad || flags & 2 /* proxyState */) && + (memberFlags & 32 /* State */)))) { + // proxyComponent - prop + Object.defineProperty(prototype, memberName, { + get() { + // proxyComponent, get value + return getValue(this, memberName); + }, + set(newValue) { + if ( + // only during dev time + (BUILD.isDev) && + // we are proxing the instance (not element) + (flags & 1 /* isElementConstructor */) === 0 && + // the member is a non-mutable prop + (memberFlags & (31 /* Prop */ | 1024 /* Mutable */)) === 31 /* Prop */) { + consoleDevWarn(`@Prop() "${memberName}" on "${cmpMeta.$tagName$}" cannot be modified.\nFurther information: https://stenciljs.com/docs/properties#prop-mutability`); + } + // proxyComponent, set value + setValue(this, memberName, newValue, cmpMeta); + }, + configurable: true, + enumerable: true + }); + } + else if (BUILD.lazyLoad && BUILD.method && (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 (BUILD.observeAttribute && (!BUILD.lazyLoad || 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); + if (BUILD.reflect && m[0] & 512 /* ReflectAttr */) { + cmpMeta.$attrsToReflect$.push([propName, attrName]); + } + return attrName; + }); + } + } + return Cstr; +}; +const modeResolutionChain = []; +const computeMode = (elm) => modeResolutionChain.map(h => h(elm)).find(m => !!m); +// Public +const setMode = (handler) => modeResolutionChain.push(handler); +const getMode = (ref) => getHostRef(ref).$modeName$; +const initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId, Cstr) => { + // initializeComponent + if ((BUILD.lazyLoad || BUILD.style) && (hostRef.$flags$ & 32 /* hasInitializedComponent */) === 0) { + // we haven't initialized this element yet + hostRef.$flags$ |= 32 /* hasInitializedComponent */; + if (BUILD.mode && hostRef.$modeName$ == null) { + // initializeComponent + // looks like mode wasn't set as a property directly yet + // first check if there's an attribute + // next check the app's global + hostRef.$modeName$ = typeof cmpMeta.$lazyBundleIds$ !== 'string' ? computeMode(elm) : ''; + } + if (BUILD.hydrateServerSide && hostRef.$modeName$) { + elm.setAttribute('s-mode', hostRef.$modeName$); + } + if (BUILD.lazyLoad) { + // lazy loaded components + // request the component's implementation to be + // wired up with the host element + Cstr = loadModule(cmpMeta, hostRef, hmrVersionId); + if (Cstr.then) { + // Await creates a micro-task avoid if possible + const endLoad = uniqueTime(`st:load:${cmpMeta.$tagName$}:${hostRef.$modeName$}`, `[Stencil] Load module for <${cmpMeta.$tagName$}>`); + Cstr = await Cstr; + endLoad(); + } + if ((BUILD.isDev || BUILD.isDebug) && !Cstr) { + throw new Error(`Constructor for "${cmpMeta.$tagName$}#${hostRef.$modeName$}" was not found`); + } + if (BUILD.member && !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 + if (BUILD.watchCallback) { + 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 + if (BUILD.member) { + 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); + } + if (BUILD.member) { + hostRef.$flags$ &= ~8 /* isConstructingInstance */; + } + if (BUILD.watchCallback) { + hostRef.$flags$ |= 128 /* isWatchReady */; + } + endNewInstance(); + fireConnectedCallback(hostRef.$lazyInstance$); + } + else { + Cstr = elm.constructor; + } + const scopeId = BUILD.mode ? getScopeId(cmpMeta.$tagName$, hostRef.$modeName$) : getScopeId(cmpMeta.$tagName$); + if (BUILD.style && !styles.has(scopeId) && Cstr.style) { + const endRegisterStyles = createTime('registerStyles', cmpMeta.$tagName$); + // this component has styles but we haven't registered them yet + let style = Cstr.style; + if (BUILD.mode && typeof style !== 'string') { + style = style[hostRef.$modeName$]; + } + if (!BUILD.hydrateServerSide && BUILD.shadowDom && BUILD.shadowDomShim && cmpMeta.$flags$ & 8 /* needsShadowDomShim */) { + style = await __sc_import_gc_components('./shadow-css-d7d058ec-d59cb009.js').then(m => m.scopeCss(style, scopeId, false)); + } + registerStyle(scopeId, style, !!(cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */)); + endRegisterStyles(); + } + } + // we've successfully created a lazy instance + const ancestorComponent = hostRef.$ancestorComponent$; + const schedule = () => scheduleUpdate(elm, hostRef, cmpMeta, true); + if (BUILD.asyncLoading && 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) => { + if (BUILD.lazyLoad && BUILD.connectedCallback) { + safeCall(instance, 'connectedCallback'); + } +}; +const connectedCallback = (elm, cmpMeta) => { + if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0) { + const endConnected = createTime('connectedCallback', cmpMeta.$tagName$); + // connectedCallback + const hostRef = getHostRef(elm); + if (BUILD.hostListener && cmpMeta.$listeners$) { + // initialize our event listeners on the host element + // we do this now so that we can listening to events that may + // have fired even before the instance is ready + hostRef.$rmListeners$ = addEventListeners(elm, hostRef, cmpMeta.$listeners$); + } + if (!(hostRef.$flags$ & 1 /* hasConnected */)) { + // first time this component has connected + hostRef.$flags$ |= 1 /* hasConnected */; + let hostId; + if (BUILD.hydrateClientSide) { + hostId = elm.getAttribute(HYDRATE_ID); + if (hostId) { + if (BUILD.shadowDom && supportsShadowDom && cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) { + const scopeId = BUILD.mode ? addStyle(elm.shadowRoot, cmpMeta, elm.getAttribute('s-mode')) : addStyle(elm.shadowRoot, cmpMeta); + elm.classList.remove(scopeId + '-h', scopeId + '-s'); + } + initializeClientHydrate(elm, cmpMeta.$tagName$, hostId, hostRef); + } + } + if (BUILD.slotRelocation && !hostId) { + // initUpdate + // if the slot polyfill is required we'll need to put some nodes + // in here to act as original content anchors as we move nodes around + // host element has been connected to the DOM + if ((BUILD.hydrateServerSide) || + (BUILD.slot && cmpMeta.$flags$ & 4 /* hasSlotRelocation */) || + (BUILD.shadowDom && cmpMeta.$flags$ & 8 /* needsShadowDomShim */)) { + setContentReference(elm); + } + } + if (BUILD.asyncLoading) { + // 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 ((BUILD.hydrateClientSide && ancestorComponent.nodeType === 1 /* ElementNode */ && ancestorComponent.hasAttribute('s-id')) || + (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 (BUILD.prop && BUILD.lazyLoad && !BUILD.hydrateServerSide && cmpMeta.$members$) { + Object.entries(cmpMeta.$members$).forEach(([memberName, [memberFlags]]) => { + if (memberFlags & 31 /* Prop */ && elm.hasOwnProperty(memberName)) { + const value = elm[memberName]; + delete elm[memberName]; + elm[memberName] = value; + } + }); + } + if (BUILD.initializeNextTick) { + // connectedCallback, taskQueue, initialLoad + // angular sets attribute AFTER connectCallback + // https://github.com/angular/angular/issues/18909 + // https://github.com/angular/angular/issues/19940 + nextTick(() => initializeComponent(elm, hostRef, cmpMeta)); + } + else { + initializeComponent(elm, hostRef, cmpMeta); + } + } + fireConnectedCallback(hostRef.$lazyInstance$); + endConnected(); + } +}; +const setContentReference = (elm) => { + // only required when we're NOT using native shadow dom (slot) + // or this browser doesn't support native shadow dom + // and this host element was NOT created with SSR + // let's pick out the inner content for slot projection + // create a node to represent where the original + // content was first placed, which is useful later on + const contentRefElm = elm['s-cr'] = doc.createComment(BUILD.isDebug + ? `content-ref (host=${elm.localName})` + : ''); + contentRefElm['s-cn'] = true; + elm.insertBefore(contentRefElm, elm.firstChild); +}; +const disconnectedCallback = (elm) => { + if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0) { + const hostRef = getHostRef(elm); + const instance = BUILD.lazyLoad ? hostRef.$lazyInstance$ : elm; + if (BUILD.hostListener) { + if (hostRef.$rmListeners$) { + hostRef.$rmListeners$(); + hostRef.$rmListeners$ = undefined; + } + } + // clear CSS var-shim tracking + if (BUILD.cssVarShim && plt.$cssShim$) { + plt.$cssShim$.removeHost(elm); + } + if (BUILD.lazyLoad && BUILD.disconnectedCallback) { + safeCall(instance, 'disconnectedCallback'); + } + if (BUILD.cmpDidUnload) { + safeCall(instance, 'componentDidUnload'); + } + } +}; +function hmrStart(elm, cmpMeta, hmrVersionId) { + // ¯\_(ツ)_/¯ + const hostRef = getHostRef(elm); + // reset state flags to only have been connected + hostRef.$flags$ = 1 /* hasConnected */; + // TODO + // detatch any event listeners that may have been added + // because we're not passing an exact event name it'll + // remove all of this element's event, which is good + // create a callback for when this component finishes hmr + elm['s-hmr-load'] = () => { + // finished hmr for this element + delete elm['s-hmr-load']; + }; + // re-initialize the component + initializeComponent(elm, hostRef, cmpMeta, hmrVersionId); +} +const bootstrapLazy = (lazyBundles, options = {}) => { + if (BUILD.profile) { + performance.mark('st:app:start'); + } + installDevTools(); + const endBootstrap = createTime('bootstrapLazy'); + 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 = []; + const styles = /*@__PURE__*/ doc.querySelectorAll(`[${HYDRATED_STYLE_ID}]`); + let appLoadFallback; + let isBootstrapping = true; + let i = 0; + Object.assign(plt, options); + plt.$resourcesUrl$ = new URL(options.resourcesUrl || './', doc.baseURI).href; + if (options.syncQueue) { + plt.$flags$ |= 4 /* queueSync */; + } + if (BUILD.hydrateClientSide) { + // If the app is already hydrated there is not point to disable the + // async queue. This will improve the first input delay + plt.$flags$ |= 2 /* appLoaded */; + } + if (BUILD.hydrateClientSide && BUILD.shadowDom) { + for (; i < styles.length; i++) { + registerStyle(styles[i].getAttribute(HYDRATED_STYLE_ID), convertScopedToShadow(styles[i].innerHTML), true); + } + } + lazyBundles.forEach(lazyBundle => lazyBundle[1].forEach(compactMeta => { + const cmpMeta = { + $flags$: compactMeta[0], + $tagName$: compactMeta[1], + $members$: compactMeta[2], + $listeners$: compactMeta[3], + }; + if (BUILD.member) { + cmpMeta.$members$ = compactMeta[2]; + } + if (BUILD.hostListener) { + cmpMeta.$listeners$ = compactMeta[3]; + } + if (BUILD.reflect) { + cmpMeta.$attrsToReflect$ = []; + } + if (BUILD.watchCallback) { + cmpMeta.$watchers$ = {}; + } + if (BUILD.shadowDom && !supportsShadowDom && cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) { + cmpMeta.$flags$ |= 8 /* needsShadowDomShim */; + } + const tagName = cmpMeta.$tagName$; + const HostElement = class extends HTMLElement { + // StencilLazyHost + constructor(self) { + // @ts-ignore + super(self); + self = this; + registerHost(self); + if (BUILD.shadowDom && 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 + if (supportsShadowDom) { + if (BUILD.shadowDelegatesFocus) { + self.attachShadow({ + mode: 'open', + delegatesFocus: !!(cmpMeta.$flags$ & 16 /* shadowDelegatesFocus */), + }); + } + else { + self.attachShadow({ mode: 'open' }); + } + } + else if (!BUILD.hydrateServerSide && !('shadowRoot' in self)) { + self.shadowRoot = self; + } + } + } + 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, cmpMeta)); + } + } + disconnectedCallback() { + plt.jmp(() => disconnectedCallback(this)); + } + forceUpdate() { + forceUpdate(this, cmpMeta); + } + componentOnReady() { + return getHostRef(this).$onReadyPromise$; + } + }; + if (BUILD.cloneNodeFix) { + cloneNodeFix(HostElement.prototype); + } + if (BUILD.appendChildSlotFix) { + appendChildSlotFix(HostElement.prototype); + } + if (BUILD.hotModuleReplacement) { + HostElement.prototype['s-hmr'] = function (hmrVersionId) { + hmrStart(this, cmpMeta, hmrVersionId); + }; + } + cmpMeta.$lazyBundleIds$ = lazyBundle[0]; + if (!exclude.includes(tagName) && !customElements.get(tagName)) { + cmpTags.push(tagName); + customElements.define(tagName, proxyComponent(HostElement, cmpMeta, 1 /* isElementConstructor */)); + } + })); + if (BUILD.hydratedClass || BUILD.hydratedAttribute) { + 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 > 0) { + deferredConnectedCallbacks.forEach(host => host.connectedCallback()); + } + else { + if (BUILD.profile) { + plt.jmp(() => appLoadFallback = setTimeout(appDidLoad, 30, 'timeout')); + } + else { + plt.jmp(() => appLoadFallback = setTimeout(appDidLoad, 30)); + } + } + // Fallback appLoad event + endBootstrap(); +}; +const defineCustomElement = (Cstr, compactMeta) => { + customElements.define(compactMeta[1], proxyCustomElement(Cstr, compactMeta)); +}; +const proxyCustomElement = (Cstr, compactMeta) => { + const cmpMeta = { + $flags$: compactMeta[0], + $tagName$: compactMeta[1], + }; + if (BUILD.member) { + cmpMeta.$members$ = compactMeta[2]; + } + if (BUILD.hostListener) { + cmpMeta.$listeners$ = compactMeta[3]; + } + if (BUILD.watchCallback) { + cmpMeta.$watchers$ = Cstr.$watchers$; + } + if (BUILD.reflect) { + cmpMeta.$attrsToReflect$ = []; + } + if (BUILD.shadowDom && !supportsShadowDom && cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) { + cmpMeta.$flags$ |= 8 /* needsShadowDomShim */; + } + Object.assign(Cstr.prototype, { + forceUpdate() { + forceUpdate(this, cmpMeta); + }, + connectedCallback() { + connectedCallback(this, cmpMeta); + }, + disconnectedCallback() { + disconnectedCallback(this); + } + }); + return proxyComponent(Cstr, cmpMeta, 1 /* isElementConstructor */ | 2 /* proxyState */); +}; +const attachShadow = (el) => { + if (supportsShadowDom) { + el.attachShadow({ mode: 'open' }); + } + else { + el.shadowRoot = el; + } +}; +const proxyNative = (Cstr, compactMeta) => { + const cmpMeta = { + $flags$: compactMeta[0], + $tagName$: compactMeta[1], + $members$: compactMeta[2], + $listeners$: compactMeta[3], + $watchers$: Cstr.$watchers$ + }; + if (BUILD.reflect) { + cmpMeta.$attrsToReflect$ = []; + } + if (BUILD.shadowDom && !supportsShadowDom && cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) { + cmpMeta.$flags$ |= 8 /* needsShadowDomShim */; + } + Object.assign(Cstr.prototype, { + forceUpdate() { + forceUpdate(this, cmpMeta); + }, + connectedCallback() { + connectedCallback(this, cmpMeta); + }, + disconnectedCallback() { + disconnectedCallback(this); + } + }); + return proxyComponent(Cstr, cmpMeta, 1 /* isElementConstructor */ | 2 /* proxyState */); +}; +const createEvent = (ref, name, flags) => { + const elm = getElement(ref); + return { + emit: (detail) => { + if (BUILD.isDev && !elm.isConnected) { + consoleDevWarn(`The "${name}" event was emitted, but the dispatcher node is no longer connected to the dom.`); + } + const ev = new (BUILD.hydrateServerSide ? win.CustomEvent : CustomEvent)(name, { + bubbles: !!(flags & 4 /* Bubbles */), + composed: !!(flags & 2 /* Composed */), + cancelable: !!(flags & 1 /* Cancellable */), + detail + }); + elm.dispatchEvent(ev); + return ev; + } + }; +}; +const getAssetPath = (path) => { + const assetUrl = new URL(path, plt.$resourcesUrl$); + return (assetUrl.origin !== win.location.origin) + ? assetUrl.href + : assetUrl.pathname; +}; +const getConnect = (_ref, tagName) => { + const componentOnReady = () => { + let elm = doc.querySelector(tagName); + if (!elm) { + elm = doc.createElement(tagName); + doc.body.appendChild(elm); + } + return typeof elm.componentOnReady === 'function' ? elm.componentOnReady() : Promise.resolve(elm); + }; + const create = (...args) => { + return componentOnReady() + .then(el => el.create(...args)); + }; + return { + create, + componentOnReady, + }; +}; +const getContext = (_elm, context) => { + if (context in Context) { + return Context[context]; + } + else if (context === 'window') { + return win; + } + else if (context === 'document') { + return doc; + } + else if (context === 'isServer' || context === 'isPrerender') { + return BUILD.hydrateServerSide ? true : false; + } + else if (context === 'isClient') { + return BUILD.hydrateServerSide ? false : true; + } + else if (context === 'resourcesUrl' || context === 'publicPath') { + return getAssetPath('.'); + } + else if (context === 'queue') { + return { + write: writeTask, + read: readTask, + tick: { + then(cb) { + return nextTick(cb); + } + } + }; + } + return undefined; +}; +const getElement = (ref) => BUILD.lazyLoad ? getHostRef(ref).$hostElement$ : ref; +const insertVdomAnnotations = (doc) => { + if (doc != null) { + const docData = { + hostIds: 0, + rootLevelIds: 0 + }; + const orgLocationNodes = []; + parseVNodeAnnotations(doc, doc.body, docData, orgLocationNodes); + orgLocationNodes.forEach(orgLocationNode => { + if (orgLocationNode != null) { + const nodeRef = orgLocationNode['s-nr']; + let hostId = nodeRef['s-host-id']; + let nodeId = nodeRef['s-node-id']; + let childId = `${hostId}.${nodeId}`; + if (hostId == null) { + hostId = 0; + docData.rootLevelIds++; + nodeId = docData.rootLevelIds; + childId = `${hostId}.${nodeId}`; + if (nodeRef.nodeType === 1 /* ElementNode */) { + nodeRef.setAttribute(HYDRATE_CHILD_ID, childId); + } + else if (nodeRef.nodeType === 3 /* TextNode */) { + if (hostId === 0) { + const textContent = nodeRef.nodeValue.trim(); + if (textContent === '') { + // useless whitespace node at the document root + orgLocationNode.remove(); + return; + } + } + const commentBeforeTextNode = doc.createComment(childId); + commentBeforeTextNode.nodeValue = `${TEXT_NODE_ID}.${childId}`; + nodeRef.parentNode.insertBefore(commentBeforeTextNode, nodeRef); + } + } + let orgLocationNodeId = `${ORG_LOCATION_ID}.${childId}`; + const orgLocationParentNode = orgLocationNode.parentElement; + if (orgLocationParentNode) { + if (orgLocationParentNode['s-en'] === '') { + // ending with a "." means that the parent element + // of this node's original location is a SHADOW dom element + // and this node is apart of the root level light dom + orgLocationNodeId += `.`; + } + else if (orgLocationParentNode['s-en'] === 'c') { + // ending with a ".c" means that the parent element + // of this node's original location is a SCOPED element + // and this node is apart of the root level light dom + orgLocationNodeId += `.c`; + } + } + orgLocationNode.nodeValue = orgLocationNodeId; + } + }); + } +}; +const parseVNodeAnnotations = (doc, node, docData, orgLocationNodes) => { + if (node == null) { + return; + } + if (node['s-nr'] != null) { + orgLocationNodes.push(node); + } + if (node.nodeType === 1 /* ElementNode */) { + node.childNodes.forEach(childNode => { + const hostRef = getHostRef(childNode); + if (hostRef != null) { + const cmpData = { + nodeIds: 0 + }; + insertVNodeAnnotations(doc, childNode, hostRef.$vnode$, docData, cmpData); + } + parseVNodeAnnotations(doc, childNode, docData, orgLocationNodes); + }); + } +}; +const insertVNodeAnnotations = (doc, hostElm, vnode, docData, cmpData) => { + if (vnode != null) { + const hostId = ++docData.hostIds; + hostElm.setAttribute(HYDRATE_ID, hostId); + if (hostElm['s-cr'] != null) { + hostElm['s-cr'].nodeValue = `${CONTENT_REF_ID}.${hostId}`; + } + if (vnode.$children$ != null) { + const depth = 0; + vnode.$children$.forEach((vnodeChild, index) => { + insertChildVNodeAnnotations(doc, vnodeChild, cmpData, hostId, depth, index); + }); + } + } +}; +const insertChildVNodeAnnotations = (doc, vnodeChild, cmpData, hostId, depth, index) => { + const childElm = vnodeChild.$elm$; + if (childElm == null) { + return; + } + const nodeId = cmpData.nodeIds++; + const childId = `${hostId}.${nodeId}.${depth}.${index}`; + childElm['s-host-id'] = hostId; + childElm['s-node-id'] = nodeId; + if (childElm.nodeType === 1 /* ElementNode */) { + childElm.setAttribute(HYDRATE_CHILD_ID, childId); + } + else if (childElm.nodeType === 3 /* TextNode */) { + const parentNode = childElm.parentNode; + if (parentNode.nodeName !== 'STYLE') { + const textNodeId = `${TEXT_NODE_ID}.${childId}`; + const commentBeforeTextNode = doc.createComment(textNodeId); + parentNode.insertBefore(commentBeforeTextNode, childElm); + } + } + else if (childElm.nodeType === 8 /* CommentNode */) { + if (childElm['s-sr']) { + const slotName = (childElm['s-sn'] || ''); + const slotNodeId = `${SLOT_NODE_ID}.${childId}.${slotName}`; + childElm.nodeValue = slotNodeId; + } + } + if (vnodeChild.$children$ != null) { + const childDepth = depth + 1; + vnodeChild.$children$.forEach((vnode, index) => { + insertChildVNodeAnnotations(doc, vnode, cmpData, hostId, childDepth, index); + }); + } +}; + +const globals = () => { +}; + +export { Host as H, patchEsm as a, bootstrapLazy as b, getElement as c, createEvent as d, getAssetPath as e, globals as g, h, patchBrowser as p, registerInstance as r }; diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/f_000003 b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/f_000003 new file mode 100644 index 0000000..6580d3a Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/f_000003 differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/f_000004 b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/f_000004 new file mode 100644 index 0000000..3e3e555 --- /dev/null +++ b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/f_000004 @@ -0,0 +1,430 @@ +import { h } from './core-800e68f4.js'; +import { TiUtils } from '../ti-core-assets/lib/TiUtils'; +import '../ti-core-assets/lib/TiFiles'; +import { TiConsole } from '../ti-core-assets/lib/TiConsole'; +import { TiLocalStorage } from '../ti-core-assets/lib/TiLocalStorage'; + +const style = document.createElement('style'); +style.innerHTML = ` + @font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 300; + src: local('Roboto Light'), local('Roboto-Light'), url(components/assets/fonts/font-roboto/Roboto_300_normal.woff) format('woff'); + } + @font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 400; + src: local('Roboto'), local('Roboto-Regular'), url(components/assets/fonts/font-roboto/Roboto_400_normal.woff) format('woff'); + } + @font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 500; + src: local('Roboto Medium'), local('Roboto-Medium'), url(components/assets/fonts/font-roboto/Roboto_500_normal.woff) format('woff'); + } + @font-face { + font-family: 'Roboto'; + font-style: normal; + font-weight: 700; + src: local('Roboto Bold'), local('Roboto-Bold'), url(components/assets/fonts/font-roboto/Roboto_700_normal.woff) format('woff'); + } + @font-face { + font-family: 'Roboto'; + font-style: italic; + font-weight: 300; + src: local('Roboto Light Italic'), local('Roboto-LightItalic'), url(components/assets/fonts/font-roboto/Roboto_300_italic.woff) format('woff'); + } + @font-face { + font-family: 'Roboto'; + font-style: italic; + font-weight: 400; + src: local('Roboto Italic'), local('Roboto-Italic'), url(components/assets/fonts/font-roboto/Roboto_400_italic.woff) format('woff'); + } + @font-face { + font-family: 'Roboto'; + font-style: italic; + font-weight: 500; + src: local('Roboto Medium Italic'), local('Roboto-MediumItalic'), url(components/assets/fonts/font-roboto/Roboto_500_italic.woff) format('woff'); + } + @font-face { + font-family: 'Roboto'; + font-style: italic; + font-weight: 700; + src: local('Roboto Bold Italic'), local('Roboto-BoldItalic'), url(components/assets/fonts/font-roboto/Roboto_700_italic.woff) format('woff'); + } +`; +document.head.appendChild(style); + +/** + * Copyright (c) 2019, Texas Instruments Incorporated + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Texas Instruments Incorporated nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/** +* Theme css switching using MutationObserver to the body attribute change. +* Only loaded once when added to the dom. +*/ +//create ti-widget-theme-stylesheet on load, append to document +const style$1 = document.createElement('style'); +style$1.setAttribute('title', 'ti-widget-theme-stylesheet'); +const element = document.head || document.body; +element.appendChild(style$1); +style$1.sheet.insertRule('html {}', 0); +const styleSheet = style$1.sheet.cssRules[0].style; +// modify stylesheet/css variables on theme attribute change in body +const observer = new MutationObserver((mutations) => { + mutations.forEach(function (mutation) { + switch (document.body.getAttribute('theme')) { + case 'ti-theme': + styleSheet.setProperty('--theme-primary-color', '#cc0000'); + styleSheet.setProperty('--theme-secondary-color', '#115566'); + styleSheet.setProperty('--theme-alternative-color', '#990000'); + styleSheet.setProperty('--theme-background-color', '#fff'); + styleSheet.setProperty('--theme-font-color', '#231F20'); + styleSheet.setProperty('--theme-header-font-color', '#231F20'); + break; + case 'ti-dark': + styleSheet.setProperty('--theme-primary-color', '#990000'); + styleSheet.setProperty('--theme-secondary-color', '#115566'); + styleSheet.setProperty('--theme-alternative-color', '#990000'); + styleSheet.setProperty('--theme-background-color', '#2f2f2f'); + styleSheet.setProperty('--theme-font-color', '#f2f2f2'); + styleSheet.setProperty('--theme-header-font-color', '#f2f2f2'); + break; + } + }); +}); +observer.observe(document.body, { + attributes: true, + attributeFilter: ['theme'] +}); + +/** + * Copyright (c) 2019-2020, Texas Instruments Incorporated + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Texas Instruments Incorporated nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/** + * `TiElementBase` provides the base implementation for TI elements. + * + * @customElement + * @isHidden + */ +class TiElementBase { + constructor(parent) { + this.parent = parent; + } + /** + * Returns true if the element is hosted in the designer, otherwise false. + * + * @return {boolean} + */ + isDesignerHosted() { + return !!TiUtils.rootWin.TIDesigner; + } + /** + * Parse the delimited string into an array. + * + * @param {undefined|string|Array} text the input text + * @param delimiter the delimiter character + * @return {Array} the array + */ + parseArray(text, delimiter) { + text = text || ''; + // support arrays as well + if (text instanceof Array) { + return text; + } + // support using terminating character as a delimiter if one of [,;|]. + // this means that if you want a blank element at the end of the list, you have to use a double terminator; for example, A|B|C|| + if (!delimiter && text.length > 1) { + const lastCharacter = text.charAt(text.length - 1); + if (lastCharacter === '|' || lastCharacter === ',' || lastCharacter === ';') { + delimiter = lastCharacter; + text = text.substring(0, text.length - 1); + } + } + // support comma-separated values, semi-colon separated, or | separated fields. + let fields = text.split(delimiter || '|'); + if (!delimiter) { + let altFields = text.split(';'); + if (altFields.length > fields.length) { + fields = altFields; + } + altFields = text.split(','); + if (altFields.length > fields.length && (altFields.length !== fields.length + 1 || fields.length === 1)) { + fields = altFields; + } + } + for (let i = fields.length; i-- > 0;) { + fields[i] = fields[i].trim(); + } + if (fields.length === 1 && fields[0].length === 0) { + return []; + } + return fields; + } + /** + * Returns the cookie value. + * + * @param {string} name the name of the cookie + * @return {string} the cookie value + */ + static getCookie(name) { + const value = '; ' + document.cookie; + const parts = value.split('; ' + name + '='); + if (parts.length === 2) { + const item = parts.pop(); + if (item !== null) { + return item.split(';').shift() || ''; + } + } + return ''; + } + /** + * Helper method to log trace message to the console. + * + * @param {string} logtype trace type, can be log|info|warn|debug + * @param {function|string} message the message to log + */ + trace(logType, message) { + const output = typeof message === 'object' ? JSON.stringify(message) : message; + const id = this.element.id ? this.element.id : 'no-id'; + switch (logType) { + case 'error': + TiConsole.error('[' + this.element.localName + ': ' + id + ']', output); + break; + case 'warning': + TiConsole.warning('[' + this.element.localName + ': ' + id + ']', output); + break; + case 'info': + TiConsole.info('[' + this.element.localName + ': ' + id + ']', output); + break; + case 'log': + TiConsole.log('[' + this.element.localName + ': ' + id + ']', output); + break; + case 'debug': + TiConsole.debug('[' + this.element.localName + ': ' + id + ']', output); + break; + } + } + /** + * Saves the setting to local storage. + * + * @param {string} name the setting name + * @param {string} value the value + */ + saveSetting(name, value) { + const id = this.element.tagName.toLowerCase(); + const root = JSON.parse(TiLocalStorage.getItem(TiElementBase.STORAGE_ROOT) || '{}'); + if (!root[id]) { + root[id] = {}; + } + root[id][name] = value; + TiLocalStorage.setItem(TiElementBase.STORAGE_ROOT, JSON.stringify(root)); + } + /** + * Loads the setting from local storage. + * + * @param {string} name the setting name + * @return {object} the setting JSON object + */ + loadSetting(name) { + const id = this.element.tagName.toLowerCase(); + const root = JSON.parse(TiLocalStorage.getItem(TiElementBase.STORAGE_ROOT) || '{}'); + const element = root[id] || {}; + return element[name]; + } +} +TiElementBase.STORAGE_ROOT = 'GC-SETTINGS'; + +/** + * Copyright (c) 2019-2020, Texas Instruments Incorporated + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Texas Instruments Incorporated nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, + * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/** + * `TiWidgetBase` provides the base implementation for TI widgets. + */ +class TiWidgetBase extends TiElementBase { + constructor(parent) { + super(parent); + this.parent = parent; + } + /* Widget that response to CSS property change should override this method to re-render */ + onCSSPropertyChanged(name, value) { } + ; + renderInfoText(infoText) { + if (infoText) { + // JSXON + return (h("div", { class: "help-text icon" }, + h("ti-widget-tooltip", { text: infoText }, + h("ti-widget-icon", { appearance: "secondary", icon: "help", size: "s" })))); + // JSXOFF + } + else { + return null; + } + } + render(element, options) { + if (options && (options.caption || options.infoText)) { + // JSXON + return (h("div", { class: "root-container", onClick: (e) => this.onClickHandler(e, e.target) }, + (options === null || options === void 0 ? void 0 : options.caption) ? h("div", { class: "header-container top" }, + (options === null || options === void 0 ? void 0 : options.caption) ? h("div", { class: "caption" }, options.caption) : null, + this.renderInfoText(options === null || options === void 0 ? void 0 : options.infoText)) : null, + this.parent.tooltip ? (h("div", { id: "elementWrapper" }, + element, + h("ti-widget-tooltip", { class: "tooltip", text: this.parent.tooltip, anchorId: "elementWrapper" }))) : h("div", { id: "elementWrapper" }, element), + (options === null || options === void 0 ? void 0 : options.infoText) && !(options === null || options === void 0 ? void 0 : options.caption) ? h("div", { class: "header-container side" }, this.renderInfoText(options === null || options === void 0 ? void 0 : options.infoText)) : null)); + // JSXOFF + } + else { + // JSXON + return (h("div", { id: "elementWrapper" }, + element, + this.parent.tooltip ? h("ti-widget-tooltip", { class: "tooltip", text: this.parent.tooltip, anchorId: "elementWrapper" }) : null)); + // JSXOFF + } + } + onClickHandler(event, element) { + if (element) { + const parent = element.parentElement; + if (parent && parent.id === 'elementWrapper') { + return; + } + else if (!element.classList.contains('root-container')) { + this.onClickHandler(event, element.parentElement); + } + else { + event.stopPropagation(); + } + } + } + fire(eventName, detail) { + const obj = this.parent; + for (const x in obj) { + if (TiUtils.camelToDashCase(x) === eventName) { + return obj[x].emit(detail); + } + } + } + setCSSProperty(name, value) { + value = value.replace(/^[ ]+|[ ]+$/g, ''); + this.element.style.setProperty(name, value); + this.parent.cssPropertyChanged.emit({ name: name, value: value }); + } + getCSSProperty(name) { + return getComputedStyle(this.element).getPropertyValue(name); + } + refresh() { + return this.element['forceUpdate'](); + } + /** + * Add the class name to the element. + * + * @param {string} name the class name + * @param {HTMLElement} element the element + * @protected + */ + addClassName(name, element) { + this.modifyClassName(true, name, element); + } + /** + * Remove the class name from the element. + * + * @param {string} name the class name + * @param {HTMLElement} element the element + * @protected + */ + removeClassName(name, element) { + this.modifyClassName(false, name, element); + } + modifyClassName(isAdd, name, element = this.element) { + if (element.className.indexOf(name) < 0) { + if (isAdd) { + // add because it doesn't exist yet and should + element.className = (element.className + ' ' + name).trim(); + } + } + else if (!isAdd) { + // remove because it does exist and shouldn't + element.className = element.className.replace(name, '').trim(); + } + } +} + +export { TiWidgetBase as T }; + +//# sourceMappingURL=ti-widget-base-fe722328.js.map \ No newline at end of file diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/f_000005 b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/f_000005 new file mode 100644 index 0000000..5930560 --- /dev/null +++ b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/f_000005 @@ -0,0 +1,126 @@ +import { r as registerInstance, h, H as Host, c as getElement } from './core-800e68f4.js'; + +var SvgIconColor; +(function (SvgIconColor) { + SvgIconColor["error"] = "error"; + SvgIconColor["primary"] = "primary"; + SvgIconColor["secondary"] = "secondary"; + SvgIconColor["success"] = "success"; + SvgIconColor["tertiary"] = "tertiary"; + SvgIconColor["warn"] = "warn"; + SvgIconColor["reversed"] = "reversed"; +})(SvgIconColor || (SvgIconColor = {})); +; +const SvgIconColorValues = [ + SvgIconColor.error, + SvgIconColor.primary, + SvgIconColor.secondary, + SvgIconColor.success, + SvgIconColor.tertiary, + SvgIconColor.warn, + SvgIconColor.reversed +]; + +const SvgIcon = class { + constructor(hostRef) { + registerInstance(this, hostRef); + /** + * Property for icon color and style. + * Can be one of: `primary`, `secondary`, `tertiary`, `success`, `warn`, `error`. It is `tertiary` by default. + * Also, `reversed` can be added as in `primary reversed`. This inverts the foreground and background colors. + * + * @type {string} + * @memberof SvgIcon + */ + this.appearance = 'tertiary'; + /** + * Set the icon to look disabled. + * + * @type {boolean} + * @memberof SvgIcon + */ + this.disabled = false; + /** + * Place the icon in a circle wrapper. + * + * @type {boolean} + * @memberof SvgIcon + */ + this.circle = false; + /** + * Path to the assets folder, including any common svg prefix for the icon sets. + * NOTE: do not append a trailing slash. Use forward slashes (URI format) + * + * @type {string} + * @memberof SvgIcon + */ + this.pathPrefix = 'assets/icons/ti_icons-'; + /** + * Set true if the .svg file contains multiple icons, and should use #iconName suffix to access an icon from the set + * + * @type {boolean} + * @memberOf SvgIcon + */ + this.multiIconFile = false; + /** + * The icon set. There are two sets of icons - `actions` and `objects`. The default is `objects`. + * + * @type {('actions' | 'objects')} + * @memberof SvgIcon + */ + this.iconSet = 'objects'; + /** + * Icon size - one of `xxs` (12x12), `xs` (14x14), `s` (18x18), `m` (24x24), `l` (36x36), or `xl` (48x48). Default is `m`. + * + * @type {('xxs' | 'xs' | 's' | 'm' | 'l' | 'xl')} + * @memberof SvgIcon + */ + this.size = 'm'; + } + componentWillLoad() { + // get the icon name from the text inside the element if icon name is not defined + if (!this.iconName) { + this.iconName = this.hostElement.textContent ? this.hostElement.textContent.trim() : 'info-circle'; + } + this.updateIconUrl(); + this.handleAppearanceChange(); + } + handleAppearanceChange() { + // transform appearance string into an array of options + const appearances = this.appearance.toLowerCase().split(/\s+/); + if (!appearances.some(color => { + if ((SvgIconColorValues).indexOf(color) >= 0) { + this._color = color; + return true; + } + return false; + })) { + this._color = SvgIconColor.tertiary; // default color + } + } + updateIconUrl() { + this._iconUrl = `${this.pathPrefix}${this.iconSet}${this.multiIconFile ? '.svg#' + this.iconName : '/' + this.iconName + '.svg'}`; + } + render() { + return (h(Host, { class: ` + ti-svg-icon-${this._color} + ti-svg-icon-size-${this.size} + ${this.circle && 'ti-svg-icon-circle'} + ${this.disabled && 'ti-svg-icon-disabled'} + ` }, this.multiIconFile ? [ + h("svg", { role: "img" }, h("use", { xlinkHref: this._iconUrl })), + h("span", { style: { 'display': 'none' } }, h("slot", null)) + ] : (h("div", { class: "ti-svg-icon-bg", style: { backgroundImage: `url('${this._iconUrl}')` } }, h("span", { style: { 'display': 'none' } }, h("slot", null)))))); + } + get hostElement() { return getElement(this); } + static get watchers() { return { + "appearance": ["handleAppearanceChange"], + "iconName": ["updateIconUrl"], + "pathPrefix": ["updateIconUrl"], + "iconSet": ["updateIconUrl"], + "multiIconFile": ["updateIconUrl"] + }; } + static get style() { return "/*\n* ==========================================================================\n* _polaris.colors.scss\n* This file imports the Polaris color palette.\n* ==========================================================================\n*/\n/*\n* --------------------------------------------------------------------------\n* color palette\n* --------------------------------------------------------------------------\n*/\n/*\n* ==========================================================================\n* _polaris.mixins.scss\n* This file contains Polaris mixins\n* prefix with mix-\n* ==========================================================================\n*/\n/*\n* ==========================================================================\n* _polaris-variables.scss\n* This file contains global-css variables and is using component based naming.\n*\n* Naming structure: [application(namespacing)]-[type]-[function]-[property]\n* ==========================================================================\n*/\n/*\n* --------------------------------------------------------------------------\n* Color variables\n* --------------------------------------------------------------------------\n*/\n/*\n* Polaris Component color definitions\n*/\n/*\n* Polaris Card Background color definitions\n* Ref: (http://polaris/01-ui-style-foundations.html#02-style-principles.03-background-color)\n*/\n/*\n* --------------------------------------------------------------------------\n* shape variables\n* --------------------------------------------------------------------------\n*/\n/*\n* Polaris border radius definitions\n* Ref: (http://polaris/01-ui-style-foundations.html#02-style-principles.05-border-radius)\n*/\n/*\n* Polaris box shadow definitions\n* Ref: (http://polaris/01-ui-style-foundations.html#02-style-principles.06-box-shadow)\n*/\n/*\n* --------------------------------------------------------------------------\n* font variables\n* Ref: (http://polaris/01-ui-style-foundations.html#07-typography-fundamentals)\n* --------------------------------------------------------------------------\n*/\n/*\n* Font stack definitions\n*/\n/*\n* Font families\n*/\n/*\n* Root HTML and BODY tag values\n*/\n/*\n* Font size cadence values\n*/\n/*\n* Standard Paragraph font sizes\n*/\n/*\n* Header tag font sizes\n*/\n/*\n* Line height cadence values\n*/\n/*\n* Font weight values\n*/\n/*\n* --------------------------------------------------------------------------\n* spacing values variables\n* --------------------------------------------------------------------------\n*/\n/*\n* Base spacing cadence values\n* (base grid size x multiplier) / root font size = rem value\n*/\n/*\n* Component/element specific spacing\n*/\n/*\n* --------------------------------------------------------------------------\n* page layout variables\n* --------------------------------------------------------------------------\n*/\n/*\n* --------------------------------------------------------------------------\n* animation variables\n* ref: (http://polaris/01-ui-style-foundations.html#04-motion)\n* --------------------------------------------------------------------------\n*/\n/*\n* Animation easing types\n*/\n/*\n* Animation timings\n*/\n/*\n* --------------------------------------------------------------------------\n* icon size variables\n* --------------------------------------------------------------------------\n*/\n/*\n* --------------------------------------------------------------------------\n* legacy variable names\n* - May still be used in other component repos\n* --------------------------------------------------------------------------\n*/\n/* Font variables */\n/* Space size variables */\n/*\n* ==========================================================================\n* _ti-core.scss\n*\n* This files contains mixins uses within TI Webcomponents\n* ==========================================================================\n*/\n/*\n * Base style for trigger element\n */\n/*\n* Tooltip trigger main mixin.\n* Use to add style to trigger tooltip display.\n* For example:\n*\n* .tooltip-trigger:hover {\n* \@include ti-tooltip-trigger();\n* }\n*\n* Typically not used directly, but via the other mixins below.\n*/\n/*\n* Mixin for adding style to trigger tooltip display to\n* an element selector on hover, focus and checked.\n* For example:\n*\n* .tooltip-trigger {\n \@include ti-tooltip-trigger-element();\n* }\n*/\n/*\n* Mixin for adding style to trigger tooltip display to\n* a web component shadow host on hover, focus and checked.\n* Use in the web component style sheet outside of :host{}.\n* For example:\n*\n* \@include ti-tooltip-trigger-host();\n* :host {\n* ...\n* }\n*\n* The optional $selector parameter allows a CSS selector\n* which will be added to the :host selector to allow control\n* over the host trigger via a style class or another selector.\n* For example:\n*\n* \@include ti-tooltip-trigger-host(\'.ti-tooltip-trigger\');\n*\n* creates code like\n*\n* :host(.ti-tooltip-trigger:hover) {\n* ...\n* }\n*\n* instead of\n*\n* :host(:hover) {\n* ...\n* }\n*/\n:host {\n display: -ms-inline-flexbox;\n display: inline-flex;\n vertical-align: text-bottom;\n fill: #555555;\n width: 24px;\n height: 24px;\n}\n:host svg {\n display: block;\n width: 24px;\n height: 24px;\n stroke-width: 0;\n}\n:host .ti-svg-icon-bg {\n background-repeat: no-repeat;\n background-position: 0 0;\n width: 24px;\n height: 24px;\n}\n\n:host(.ti-svg-icon-circle) {\n border-radius: 100%;\n}\n:host(.ti-svg-icon-circle) svg,\n:host(.ti-svg-icon-circle) .ti-svg-icon-bg {\n -webkit-transform: scale(0.75);\n transform: scale(0.75);\n}\n\n/* svg icon size modifiers */\n:host(.ti-svg-icon-size-xxs) {\n width: 12px;\n height: 12px;\n}\n:host(.ti-svg-icon-size-xxs) svg {\n width: 12px;\n height: 12px;\n}\n:host(.ti-svg-icon-size-xxs) .ti-svg-icon-bg {\n background-size: 12px;\n width: 12px;\n height: 12px;\n line-height: 12px;\n}\n\n:host(.ti-svg-icon-size-xs) {\n width: 14px;\n height: 14px;\n}\n:host(.ti-svg-icon-size-xs) svg {\n width: 14px;\n height: 14px;\n}\n:host(.ti-svg-icon-size-xs) .ti-svg-icon-bg {\n background-size: 14px;\n width: 14px;\n height: 14px;\n line-height: 14px;\n}\n\n:host(.ti-svg-icon-size-s) {\n width: 18px;\n height: 18px;\n}\n:host(.ti-svg-icon-size-s) svg {\n width: 18px;\n height: 18px;\n}\n:host(.ti-svg-icon-size-s) .ti-svg-icon-bg {\n background-size: 18px;\n width: 18px;\n height: 18px;\n line-height: 18px;\n}\n\n:host(.ti-svg-icon-size-m) {\n width: 24px;\n height: 24px;\n}\n:host(.ti-svg-icon-size-m) svg {\n width: 24px;\n height: 24px;\n}\n:host(.ti-svg-icon-size-m) .ti-svg-icon-bg {\n background-size: 24px;\n width: 24px;\n height: 24px;\n line-height: 24px;\n}\n\n:host(.ti-svg-icon-size-l) {\n width: 36px;\n height: 36px;\n}\n:host(.ti-svg-icon-size-l) svg {\n width: 36px;\n height: 36px;\n}\n:host(.ti-svg-icon-size-l) .ti-svg-icon-bg {\n background-size: 36px;\n width: 36px;\n height: 36px;\n line-height: 36px;\n}\n\n:host(.ti-svg-icon-size-xl) {\n width: 48px;\n height: 48px;\n}\n:host(.ti-svg-icon-size-xl) svg {\n width: 48px;\n height: 48px;\n}\n:host(.ti-svg-icon-size-xl) .ti-svg-icon-bg {\n background-size: 48px;\n width: 48px;\n height: 48px;\n line-height: 48px;\n}\n\n/* svg icon color modifiers */\n:host(.ti-svg-icon-tertiary) {\n fill: #555555;\n}\n\n:host(.ti-svg-icon-tertiary.ti-svg-icon-circle) {\n fill: #ffffff;\n background-color: #555555;\n}\n\n:host(.ti-svg-icon-secondary) {\n fill: #115566;\n}\n\n:host(.ti-svg-icon-secondary.ti-svg-icon-circle) {\n fill: #ffffff;\n background-color: #115566;\n}\n\n:host(.ti-svg-icon-primary) {\n fill: #cc0000;\n}\n\n:host(.ti-svg-icon-primary.ti-svg-icon-circle) {\n fill: #ffffff;\n background-color: #cc0000;\n}\n\n:host(.ti-svg-icon-disabled) {\n fill: #cccccc;\n}\n\n:host(.ti-svg-icon-disabled.ti-svg-icon-circle) {\n fill: #ffffff;\n background-color: #cccccc;\n}\n\n:host(.ti-svg-icon-reversed) {\n fill: #ffffff;\n}\n\n:host(.ti-svg-icon-reversed.ti-svg-icon-circle) {\n fill: #ffffff;\n background-color: #ffffff;\n}\n\n:host(.ti-svg-icon-error) {\n fill: #990000;\n}\n\n:host(.ti-svg-icon-error.ti-svg-icon-circle) {\n fill: #ffffff;\n background-color: #990000;\n}\n\n:host(.ti-svg-icon-success) {\n fill: #44bb55;\n}\n\n:host(.ti-svg-icon-success.ti-svg-icon-circle) {\n fill: #ffffff;\n background-color: #44bb55;\n}\n\n:host(.ti-svg-icon-warn) {\n fill: #ff9933;\n}\n\n:host(.ti-svg-icon-warn.ti-svg-icon-circle) {\n fill: #ffffff;\n background-color: #ff9933;\n}\n\n/* bg icon color modifiers - position adjust */\n:host(.ti-svg-icon-tertiary.ti-svg-icon-size-xxs.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -48px;\n}\n\n:host(.ti-svg-icon-secondary.ti-svg-icon-size-xxs) .ti-svg-icon-bg {\n background-position: 0 -12px;\n}\n\n:host(.ti-svg-icon-secondary.ti-svg-icon-size-xxs.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -48px;\n}\n\n:host(.ti-svg-icon-primary.ti-svg-icon-size-xxs) .ti-svg-icon-bg {\n background-position: 0 -24px;\n}\n\n:host(.ti-svg-icon-primary.ti-svg-icon-size-xxs.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -48px;\n}\n\n:host(.ti-svg-icon-disabled.ti-svg-icon-size-xxs) .ti-svg-icon-bg {\n background-position: 0 -36px;\n}\n\n:host(.ti-svg-icon-disabled.ti-svg-icon-size-xxs.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -48px;\n}\n\n:host(.ti-svg-icon-reversed.ti-svg-icon-size-xxs) .ti-svg-icon-bg {\n background-position: 0 -48px;\n}\n\n:host(.ti-svg-icon-reversed.ti-svg-icon-size-xxs.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -48px;\n}\n\n:host(.ti-svg-icon-error.ti-svg-icon-size-xxs) .ti-svg-icon-bg {\n background-position: 0 -60px;\n}\n\n:host(.ti-svg-icon-error.ti-svg-icon-size-xxs.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -48px;\n}\n\n:host(.ti-svg-icon-success.ti-svg-icon-size-xxs) .ti-svg-icon-bg {\n background-position: 0 -72px;\n}\n\n:host(.ti-svg-icon-success.ti-svg-icon-size-xxs.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -48px;\n}\n\n:host(.ti-svg-icon-warn.ti-svg-icon-size-xxs) .ti-svg-icon-bg {\n background-position: 0 -84px;\n}\n\n:host(.ti-svg-icon-warn.ti-svg-icon-size-xxs.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -48px;\n}\n\n:host(.ti-svg-icon-tertiary.ti-svg-icon-size-xs.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -56px;\n}\n\n:host(.ti-svg-icon-secondary.ti-svg-icon-size-xs) .ti-svg-icon-bg {\n background-position: 0 -14px;\n}\n\n:host(.ti-svg-icon-secondary.ti-svg-icon-size-xs.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -56px;\n}\n\n:host(.ti-svg-icon-primary.ti-svg-icon-size-xs) .ti-svg-icon-bg {\n background-position: 0 -28px;\n}\n\n:host(.ti-svg-icon-primary.ti-svg-icon-size-xs.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -56px;\n}\n\n:host(.ti-svg-icon-disabled.ti-svg-icon-size-xs) .ti-svg-icon-bg {\n background-position: 0 -42px;\n}\n\n:host(.ti-svg-icon-disabled.ti-svg-icon-size-xs.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -56px;\n}\n\n:host(.ti-svg-icon-reversed.ti-svg-icon-size-xs) .ti-svg-icon-bg {\n background-position: 0 -56px;\n}\n\n:host(.ti-svg-icon-reversed.ti-svg-icon-size-xs.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -56px;\n}\n\n:host(.ti-svg-icon-error.ti-svg-icon-size-xs) .ti-svg-icon-bg {\n background-position: 0 -70px;\n}\n\n:host(.ti-svg-icon-error.ti-svg-icon-size-xs.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -56px;\n}\n\n:host(.ti-svg-icon-success.ti-svg-icon-size-xs) .ti-svg-icon-bg {\n background-position: 0 -84px;\n}\n\n:host(.ti-svg-icon-success.ti-svg-icon-size-xs.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -56px;\n}\n\n:host(.ti-svg-icon-warn.ti-svg-icon-size-xs) .ti-svg-icon-bg {\n background-position: 0 -98px;\n}\n\n:host(.ti-svg-icon-warn.ti-svg-icon-size-xs.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -56px;\n}\n\n:host(.ti-svg-icon-tertiary.ti-svg-icon-size-s.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -72px;\n}\n\n:host(.ti-svg-icon-secondary.ti-svg-icon-size-s) .ti-svg-icon-bg {\n background-position: 0 -18px;\n}\n\n:host(.ti-svg-icon-secondary.ti-svg-icon-size-s.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -72px;\n}\n\n:host(.ti-svg-icon-primary.ti-svg-icon-size-s) .ti-svg-icon-bg {\n background-position: 0 -36px;\n}\n\n:host(.ti-svg-icon-primary.ti-svg-icon-size-s.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -72px;\n}\n\n:host(.ti-svg-icon-disabled.ti-svg-icon-size-s) .ti-svg-icon-bg {\n background-position: 0 -54px;\n}\n\n:host(.ti-svg-icon-disabled.ti-svg-icon-size-s.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -72px;\n}\n\n:host(.ti-svg-icon-reversed.ti-svg-icon-size-s) .ti-svg-icon-bg {\n background-position: 0 -72px;\n}\n\n:host(.ti-svg-icon-reversed.ti-svg-icon-size-s.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -72px;\n}\n\n:host(.ti-svg-icon-error.ti-svg-icon-size-s) .ti-svg-icon-bg {\n background-position: 0 -90px;\n}\n\n:host(.ti-svg-icon-error.ti-svg-icon-size-s.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -72px;\n}\n\n:host(.ti-svg-icon-success.ti-svg-icon-size-s) .ti-svg-icon-bg {\n background-position: 0 -108px;\n}\n\n:host(.ti-svg-icon-success.ti-svg-icon-size-s.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -72px;\n}\n\n:host(.ti-svg-icon-warn.ti-svg-icon-size-s) .ti-svg-icon-bg {\n background-position: 0 -126px;\n}\n\n:host(.ti-svg-icon-warn.ti-svg-icon-size-s.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -72px;\n}\n\n:host(.ti-svg-icon-tertiary.ti-svg-icon-size-m.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -96px;\n}\n\n:host(.ti-svg-icon-secondary.ti-svg-icon-size-m) .ti-svg-icon-bg {\n background-position: 0 -24px;\n}\n\n:host(.ti-svg-icon-secondary.ti-svg-icon-size-m.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -96px;\n}\n\n:host(.ti-svg-icon-primary.ti-svg-icon-size-m) .ti-svg-icon-bg {\n background-position: 0 -48px;\n}\n\n:host(.ti-svg-icon-primary.ti-svg-icon-size-m.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -96px;\n}\n\n:host(.ti-svg-icon-disabled.ti-svg-icon-size-m) .ti-svg-icon-bg {\n background-position: 0 -72px;\n}\n\n:host(.ti-svg-icon-disabled.ti-svg-icon-size-m.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -96px;\n}\n\n:host(.ti-svg-icon-reversed.ti-svg-icon-size-m) .ti-svg-icon-bg {\n background-position: 0 -96px;\n}\n\n:host(.ti-svg-icon-reversed.ti-svg-icon-size-m.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -96px;\n}\n\n:host(.ti-svg-icon-error.ti-svg-icon-size-m) .ti-svg-icon-bg {\n background-position: 0 -120px;\n}\n\n:host(.ti-svg-icon-error.ti-svg-icon-size-m.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -96px;\n}\n\n:host(.ti-svg-icon-success.ti-svg-icon-size-m) .ti-svg-icon-bg {\n background-position: 0 -144px;\n}\n\n:host(.ti-svg-icon-success.ti-svg-icon-size-m.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -96px;\n}\n\n:host(.ti-svg-icon-warn.ti-svg-icon-size-m) .ti-svg-icon-bg {\n background-position: 0 -168px;\n}\n\n:host(.ti-svg-icon-warn.ti-svg-icon-size-m.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -96px;\n}\n\n:host(.ti-svg-icon-tertiary.ti-svg-icon-size-l.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -144px;\n}\n\n:host(.ti-svg-icon-secondary.ti-svg-icon-size-l) .ti-svg-icon-bg {\n background-position: 0 -36px;\n}\n\n:host(.ti-svg-icon-secondary.ti-svg-icon-size-l.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -144px;\n}\n\n:host(.ti-svg-icon-primary.ti-svg-icon-size-l) .ti-svg-icon-bg {\n background-position: 0 -72px;\n}\n\n:host(.ti-svg-icon-primary.ti-svg-icon-size-l.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -144px;\n}\n\n:host(.ti-svg-icon-disabled.ti-svg-icon-size-l) .ti-svg-icon-bg {\n background-position: 0 -108px;\n}\n\n:host(.ti-svg-icon-disabled.ti-svg-icon-size-l.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -144px;\n}\n\n:host(.ti-svg-icon-reversed.ti-svg-icon-size-l) .ti-svg-icon-bg {\n background-position: 0 -144px;\n}\n\n:host(.ti-svg-icon-reversed.ti-svg-icon-size-l.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -144px;\n}\n\n:host(.ti-svg-icon-error.ti-svg-icon-size-l) .ti-svg-icon-bg {\n background-position: 0 -180px;\n}\n\n:host(.ti-svg-icon-error.ti-svg-icon-size-l.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -144px;\n}\n\n:host(.ti-svg-icon-success.ti-svg-icon-size-l) .ti-svg-icon-bg {\n background-position: 0 -216px;\n}\n\n:host(.ti-svg-icon-success.ti-svg-icon-size-l.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -144px;\n}\n\n:host(.ti-svg-icon-warn.ti-svg-icon-size-l) .ti-svg-icon-bg {\n background-position: 0 -252px;\n}\n\n:host(.ti-svg-icon-warn.ti-svg-icon-size-l.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -144px;\n}\n\n:host(.ti-svg-icon-tertiary.ti-svg-icon-size-xl.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -192px;\n}\n\n:host(.ti-svg-icon-secondary.ti-svg-icon-size-xl) .ti-svg-icon-bg {\n background-position: 0 -48px;\n}\n\n:host(.ti-svg-icon-secondary.ti-svg-icon-size-xl.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -192px;\n}\n\n:host(.ti-svg-icon-primary.ti-svg-icon-size-xl) .ti-svg-icon-bg {\n background-position: 0 -96px;\n}\n\n:host(.ti-svg-icon-primary.ti-svg-icon-size-xl.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -192px;\n}\n\n:host(.ti-svg-icon-disabled.ti-svg-icon-size-xl) .ti-svg-icon-bg {\n background-position: 0 -144px;\n}\n\n:host(.ti-svg-icon-disabled.ti-svg-icon-size-xl.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -192px;\n}\n\n:host(.ti-svg-icon-reversed.ti-svg-icon-size-xl) .ti-svg-icon-bg {\n background-position: 0 -192px;\n}\n\n:host(.ti-svg-icon-reversed.ti-svg-icon-size-xl.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -192px;\n}\n\n:host(.ti-svg-icon-error.ti-svg-icon-size-xl) .ti-svg-icon-bg {\n background-position: 0 -240px;\n}\n\n:host(.ti-svg-icon-error.ti-svg-icon-size-xl.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -192px;\n}\n\n:host(.ti-svg-icon-success.ti-svg-icon-size-xl) .ti-svg-icon-bg {\n background-position: 0 -288px;\n}\n\n:host(.ti-svg-icon-success.ti-svg-icon-size-xl.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -192px;\n}\n\n:host(.ti-svg-icon-warn.ti-svg-icon-size-xl) .ti-svg-icon-bg {\n background-position: 0 -336px;\n}\n\n:host(.ti-svg-icon-warn.ti-svg-icon-size-xl.ti-svg-icon-circle) .ti-svg-icon-bg {\n background-position: 0 -192px;\n}\n\n/* modifier for disabled icon */\n:host(.ti-svg-icon-disabled) {\n fill: #cccccc;\n}\n\n:host(.ti-svg-icon-disabled.ti-svg-icon-circle) {\n fill: #ffffff;\n background-color: #cccccc;\n}"; } +}; + +export { SvgIcon as ti_svg_icon }; diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/index b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/index new file mode 100644 index 0000000..9ae9d9a Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cache/index differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Cookies b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cookies new file mode 100644 index 0000000..f76dacd Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cookies differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Cookies-journal b/Software/Code Composer Studio Workspace/.jxbrowser-data/Cookies-journal new file mode 100644 index 0000000..e69de29 diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Favicons b/Software/Code Composer Studio Workspace/.jxbrowser-data/Favicons new file mode 100644 index 0000000..fd1f399 Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/Favicons differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Favicons-journal b/Software/Code Composer Studio Workspace/.jxbrowser-data/Favicons-journal new file mode 100644 index 0000000..e69de29 diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/GPUCache/data_0 b/Software/Code Composer Studio Workspace/.jxbrowser-data/GPUCache/data_0 new file mode 100644 index 0000000..f319abe Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/GPUCache/data_0 differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/GPUCache/data_1 b/Software/Code Composer Studio Workspace/.jxbrowser-data/GPUCache/data_1 new file mode 100644 index 0000000..a162423 Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/GPUCache/data_1 differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/GPUCache/data_2 b/Software/Code Composer Studio Workspace/.jxbrowser-data/GPUCache/data_2 new file mode 100644 index 0000000..c7e2eb9 Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/GPUCache/data_2 differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/GPUCache/data_3 b/Software/Code Composer Studio Workspace/.jxbrowser-data/GPUCache/data_3 new file mode 100644 index 0000000..52ebfc2 Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/GPUCache/data_3 differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/GPUCache/index b/Software/Code Composer Studio Workspace/.jxbrowser-data/GPUCache/index new file mode 100644 index 0000000..e85e8f3 Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/GPUCache/index differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/History b/Software/Code Composer Studio Workspace/.jxbrowser-data/History new file mode 100644 index 0000000..3a19e21 Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/History differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/History-journal b/Software/Code Composer Studio Workspace/.jxbrowser-data/History-journal new file mode 100644 index 0000000..e69de29 diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Local Storage - EXT/http_127.0.0.1.localstorage b/Software/Code Composer Studio Workspace/.jxbrowser-data/Local Storage - EXT/http_127.0.0.1.localstorage new file mode 100644 index 0000000..91618de --- /dev/null +++ b/Software/Code Composer Studio Workspace/.jxbrowser-data/Local Storage - EXT/http_127.0.0.1.localstorage @@ -0,0 +1 @@ +#Mon Jan 25 22:11:22 EST 2021 diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Local Storage/leveldb/000003.log b/Software/Code Composer Studio Workspace/.jxbrowser-data/Local Storage/leveldb/000003.log new file mode 100644 index 0000000..e69de29 diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Local Storage/leveldb/CURRENT b/Software/Code Composer Studio Workspace/.jxbrowser-data/Local Storage/leveldb/CURRENT new file mode 100644 index 0000000..7ed683d --- /dev/null +++ b/Software/Code Composer Studio Workspace/.jxbrowser-data/Local Storage/leveldb/CURRENT @@ -0,0 +1 @@ +MANIFEST-000001 diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Local Storage/leveldb/LOCK b/Software/Code Composer Studio Workspace/.jxbrowser-data/Local Storage/leveldb/LOCK new file mode 100644 index 0000000..e69de29 diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Local Storage/leveldb/LOG b/Software/Code Composer Studio Workspace/.jxbrowser-data/Local Storage/leveldb/LOG new file mode 100644 index 0000000..7da5e1f --- /dev/null +++ b/Software/Code Composer Studio Workspace/.jxbrowser-data/Local Storage/leveldb/LOG @@ -0,0 +1 @@ +2021/01/25-21:57:59.301 24324 Reusing MANIFEST leveldb/MANIFEST-000001 diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Local Storage/leveldb/MANIFEST-000001 b/Software/Code Composer Studio Workspace/.jxbrowser-data/Local Storage/leveldb/MANIFEST-000001 new file mode 100644 index 0000000..18e5cab Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/Local Storage/leveldb/MANIFEST-000001 differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Login Data b/Software/Code Composer Studio Workspace/.jxbrowser-data/Login Data new file mode 100644 index 0000000..8007eae Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/Login Data differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Login Data-journal b/Software/Code Composer Studio Workspace/.jxbrowser-data/Login Data-journal new file mode 100644 index 0000000..e69de29 diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Sync Data/LevelDB/000003.log b/Software/Code Composer Studio Workspace/.jxbrowser-data/Sync Data/LevelDB/000003.log new file mode 100644 index 0000000..2b778f4 Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/Sync Data/LevelDB/000003.log differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Sync Data/LevelDB/CURRENT b/Software/Code Composer Studio Workspace/.jxbrowser-data/Sync Data/LevelDB/CURRENT new file mode 100644 index 0000000..7ed683d --- /dev/null +++ b/Software/Code Composer Studio Workspace/.jxbrowser-data/Sync Data/LevelDB/CURRENT @@ -0,0 +1 @@ +MANIFEST-000001 diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Sync Data/LevelDB/LOCK b/Software/Code Composer Studio Workspace/.jxbrowser-data/Sync Data/LevelDB/LOCK new file mode 100644 index 0000000..e69de29 diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Sync Data/LevelDB/LOG b/Software/Code Composer Studio Workspace/.jxbrowser-data/Sync Data/LevelDB/LOG new file mode 100644 index 0000000..df5f9d3 --- /dev/null +++ b/Software/Code Composer Studio Workspace/.jxbrowser-data/Sync Data/LevelDB/LOG @@ -0,0 +1 @@ +2021/01/25-21:57:56.762 21724 Reusing MANIFEST D:\OneDrive\Repositories\Educational\Western Michigan University\ECE4810-Fall2020-SunseekerTelemetry\Software\Code Composer Studio Workspace\.jxbrowser-data\Sync Data\LevelDB/MANIFEST-000001 diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Sync Data/LevelDB/MANIFEST-000001 b/Software/Code Composer Studio Workspace/.jxbrowser-data/Sync Data/LevelDB/MANIFEST-000001 new file mode 100644 index 0000000..18e5cab Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/Sync Data/LevelDB/MANIFEST-000001 differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Visited Links b/Software/Code Composer Studio Workspace/.jxbrowser-data/Visited Links new file mode 100644 index 0000000..deaaff4 Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/Visited Links differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Web Data b/Software/Code Composer Studio Workspace/.jxbrowser-data/Web Data new file mode 100644 index 0000000..91d614a Binary files /dev/null and b/Software/Code Composer Studio Workspace/.jxbrowser-data/Web Data differ diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/Web Data-journal b/Software/Code Composer Studio Workspace/.jxbrowser-data/Web Data-journal new file mode 100644 index 0000000..e69de29 diff --git a/Software/Code Composer Studio Workspace/.jxbrowser-data/user_prefs.json b/Software/Code Composer Studio Workspace/.jxbrowser-data/user_prefs.json new file mode 100644 index 0000000..6a861be --- /dev/null +++ b/Software/Code Composer Studio Workspace/.jxbrowser-data/user_prefs.json @@ -0,0 +1 @@ +{"account_id_migration_state":2,"autofill":{"profile_use_dates_fixed":true},"countryid_at_install":21843,"download":{"directory_upgrade":true},"gcm":{"product_category_for_subtypes":"org.chromium.windows"},"profile":{"was_obsolete_http_data_cleaned":true},"proxy":{"mode":"system"},"spellcheck":{"dictionary":""}} \ No newline at end of file diff --git a/Software/Code Composer Studio Workspace/RemoteSystemsTempFiles/.project b/Software/Code Composer Studio Workspace/RemoteSystemsTempFiles/.project new file mode 100644 index 0000000..5447a64 --- /dev/null +++ b/Software/Code Composer Studio Workspace/RemoteSystemsTempFiles/.project @@ -0,0 +1,12 @@ + + + RemoteSystemsTempFiles + + + + + + + org.eclipse.rse.ui.remoteSystemsTempNature + + diff --git a/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/.ccsproject b/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/.ccsproject new file mode 100644 index 0000000..d15f5b5 --- /dev/null +++ b/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/.ccsproject @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + + diff --git a/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/.cproject b/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/.cproject new file mode 100644 index 0000000..99d3c58 --- /dev/null +++ b/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/.cproject @@ -0,0 +1,193 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/.project b/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/.project new file mode 100644 index 0000000..dc20ff6 --- /dev/null +++ b/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/.project @@ -0,0 +1,27 @@ + + + SunseekerTelemetryAndLightingSystem + + + + + + org.eclipse.cdt.managedbuilder.core.genmakebuilder + + + + + org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder + full,incremental, + + + + + + com.ti.ccstudio.core.ccsNature + org.eclipse.cdt.core.cnature + org.eclipse.cdt.managedbuilder.core.managedBuildNature + org.eclipse.cdt.core.ccnature + org.eclipse.cdt.managedbuilder.core.ScannerConfigNature + + diff --git a/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/.settings/org.eclipse.cdt.codan.core.prefs b/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/.settings/org.eclipse.cdt.codan.core.prefs new file mode 100644 index 0000000..f653028 --- /dev/null +++ b/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/.settings/org.eclipse.cdt.codan.core.prefs @@ -0,0 +1,3 @@ +eclipse.preferences.version=1 +inEditor=false +onBuild=false diff --git a/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/lnk_msp430f5438a.cmd b/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/lnk_msp430f5438a.cmd new file mode 100644 index 0000000..a2cc97c --- /dev/null +++ b/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/lnk_msp430f5438a.cmd @@ -0,0 +1,250 @@ +/* ============================================================================ */ +/* Copyright (c) 2020, Texas Instruments Incorporated */ +/* All rights reserved. */ +/* */ +/* Redistribution and use in source and binary forms, with or without */ +/* modification, are permitted provided that the following conditions */ +/* are met: */ +/* */ +/* * Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* */ +/* * Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in the */ +/* documentation and/or other materials provided with the distribution. */ +/* */ +/* * Neither the name of Texas Instruments Incorporated nor the names of */ +/* its contributors may be used to endorse or promote products derived */ +/* from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" */ +/* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, */ +/* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */ +/* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR */ +/* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, */ +/* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, */ +/* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; */ +/* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, */ +/* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR */ +/* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, */ +/* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* ============================================================================ */ + +/******************************************************************************/ +/* lnk_msp430f5438a.cmd - LINKER COMMAND FILE FOR LINKING MSP430F5438A PROGRAMS */ +/* */ +/* Usage: lnk430 -o -m lnk.cmd */ +/* cl430 -z -o -m lnk.cmd */ +/* */ +/*----------------------------------------------------------------------------*/ +/* These linker options are for command line linking only. For IDE linking, */ +/* you should set your linker options in Project Properties */ +/* -c LINK USING C CONVENTIONS */ +/* -stack 0x0100 SOFTWARE STACK SIZE */ +/* -heap 0x0100 HEAP AREA SIZE */ +/* */ +/*----------------------------------------------------------------------------*/ +/* Version: 1.210 */ +/*----------------------------------------------------------------------------*/ + +/****************************************************************************/ +/* Specify the system memory map */ +/****************************************************************************/ + +MEMORY +{ + SFR : origin = 0x0000, length = 0x0010 + PERIPHERALS_8BIT : origin = 0x0010, length = 0x00F0 + PERIPHERALS_16BIT : origin = 0x0100, length = 0x0100 + RAM : origin = 0x1C00, length = 0x4000 + INFOA : origin = 0x1980, length = 0x0080 + INFOB : origin = 0x1900, length = 0x0080 + INFOC : origin = 0x1880, length = 0x0080 + INFOD : origin = 0x1800, length = 0x0080 + FLASH : origin = 0x5C00, length = 0xA380 + FLASH2 : origin = 0x10000,length = 0x35BF8 /* Boundaries changed to fix CPU47 */ + INT00 : origin = 0xFF80, length = 0x0002 + INT01 : origin = 0xFF82, length = 0x0002 + INT02 : origin = 0xFF84, length = 0x0002 + INT03 : origin = 0xFF86, length = 0x0002 + INT04 : origin = 0xFF88, length = 0x0002 + INT05 : origin = 0xFF8A, length = 0x0002 + INT06 : origin = 0xFF8C, length = 0x0002 + INT07 : origin = 0xFF8E, length = 0x0002 + INT08 : origin = 0xFF90, length = 0x0002 + INT09 : origin = 0xFF92, length = 0x0002 + INT10 : origin = 0xFF94, length = 0x0002 + INT11 : origin = 0xFF96, length = 0x0002 + INT12 : origin = 0xFF98, length = 0x0002 + INT13 : origin = 0xFF9A, length = 0x0002 + INT14 : origin = 0xFF9C, length = 0x0002 + INT15 : origin = 0xFF9E, length = 0x0002 + INT16 : origin = 0xFFA0, length = 0x0002 + INT17 : origin = 0xFFA2, length = 0x0002 + INT18 : origin = 0xFFA4, length = 0x0002 + INT19 : origin = 0xFFA6, length = 0x0002 + INT20 : origin = 0xFFA8, length = 0x0002 + INT21 : origin = 0xFFAA, length = 0x0002 + INT22 : origin = 0xFFAC, length = 0x0002 + INT23 : origin = 0xFFAE, length = 0x0002 + INT24 : origin = 0xFFB0, length = 0x0002 + INT25 : origin = 0xFFB2, length = 0x0002 + INT26 : origin = 0xFFB4, length = 0x0002 + INT27 : origin = 0xFFB6, length = 0x0002 + INT28 : origin = 0xFFB8, length = 0x0002 + INT29 : origin = 0xFFBA, length = 0x0002 + INT30 : origin = 0xFFBC, length = 0x0002 + INT31 : origin = 0xFFBE, length = 0x0002 + INT32 : origin = 0xFFC0, length = 0x0002 + INT33 : origin = 0xFFC2, length = 0x0002 + INT34 : origin = 0xFFC4, length = 0x0002 + INT35 : origin = 0xFFC6, length = 0x0002 + INT36 : origin = 0xFFC8, length = 0x0002 + INT37 : origin = 0xFFCA, length = 0x0002 + INT38 : origin = 0xFFCC, length = 0x0002 + INT39 : origin = 0xFFCE, length = 0x0002 + INT40 : origin = 0xFFD0, length = 0x0002 + INT41 : origin = 0xFFD2, length = 0x0002 + INT42 : origin = 0xFFD4, length = 0x0002 + INT43 : origin = 0xFFD6, length = 0x0002 + INT44 : origin = 0xFFD8, length = 0x0002 + INT45 : origin = 0xFFDA, length = 0x0002 + INT46 : origin = 0xFFDC, length = 0x0002 + INT47 : origin = 0xFFDE, length = 0x0002 + INT48 : origin = 0xFFE0, length = 0x0002 + INT49 : origin = 0xFFE2, length = 0x0002 + INT50 : origin = 0xFFE4, length = 0x0002 + INT51 : origin = 0xFFE6, length = 0x0002 + INT52 : origin = 0xFFE8, length = 0x0002 + INT53 : origin = 0xFFEA, length = 0x0002 + INT54 : origin = 0xFFEC, length = 0x0002 + INT55 : origin = 0xFFEE, length = 0x0002 + INT56 : origin = 0xFFF0, length = 0x0002 + INT57 : origin = 0xFFF2, length = 0x0002 + INT58 : origin = 0xFFF4, length = 0x0002 + INT59 : origin = 0xFFF6, length = 0x0002 + INT60 : origin = 0xFFF8, length = 0x0002 + INT61 : origin = 0xFFFA, length = 0x0002 + INT62 : origin = 0xFFFC, length = 0x0002 + RESET : origin = 0xFFFE, length = 0x0002 +} + +/****************************************************************************/ +/* Specify the sections allocation into memory */ +/****************************************************************************/ + +SECTIONS +{ + .bss : {} > RAM /* Global & static vars */ + .data : {} > RAM /* Global & static vars */ + .TI.noinit : {} > RAM /* For #pragma noinit */ + .sysmem : {} > RAM /* Dynamic memory allocation area */ + .stack : {} > RAM (HIGH) /* Software system stack */ + +#ifndef __LARGE_CODE_MODEL__ + .text : {} > FLASH /* Code */ +#else + .text : {} >> FLASH2 | FLASH /* Code */ +#endif + .text:_isr : {} > FLASH /* ISR Code space */ + .cinit : {} > FLASH /* Initialization tables */ +#ifndef __LARGE_DATA_MODEL__ + .const : {} > FLASH /* Constant data */ +#else + .const : {} >> FLASH | FLASH2 /* Constant data */ +#endif + .cio : {} > RAM /* C I/O Buffer */ + + .pinit : {} > FLASH /* C++ Constructor tables */ + .binit : {} > FLASH /* Boot-time Initialization tables */ + .init_array : {} > FLASH /* C++ Constructor tables */ + .mspabi.exidx : {} > FLASH /* C++ Constructor tables */ + .mspabi.extab : {} > FLASH /* C++ Constructor tables */ +#ifdef __TI_COMPILER_VERSION__ + #if __TI_COMPILER_VERSION__ >= 15009000 + #ifndef __LARGE_CODE_MODEL__ + .TI.ramfunc : {} load=FLASH, run=RAM, table(BINIT) + #else + .TI.ramfunc : {} load=FLASH | FLASH2, run=RAM, table(BINIT) + #endif + #endif +#endif + + .infoA : {} > INFOA /* MSP430 INFO FLASH Memory segments */ + .infoB : {} > INFOB + .infoC : {} > INFOC + .infoD : {} > INFOD + + /* MSP430 Interrupt vectors */ + .int00 : {} > INT00 + .int01 : {} > INT01 + .int02 : {} > INT02 + .int03 : {} > INT03 + .int04 : {} > INT04 + .int05 : {} > INT05 + .int06 : {} > INT06 + .int07 : {} > INT07 + .int08 : {} > INT08 + .int09 : {} > INT09 + .int10 : {} > INT10 + .int11 : {} > INT11 + .int12 : {} > INT12 + .int13 : {} > INT13 + .int14 : {} > INT14 + .int15 : {} > INT15 + .int16 : {} > INT16 + .int17 : {} > INT17 + .int18 : {} > INT18 + .int19 : {} > INT19 + .int20 : {} > INT20 + .int21 : {} > INT21 + .int22 : {} > INT22 + .int23 : {} > INT23 + .int24 : {} > INT24 + .int25 : {} > INT25 + .int26 : {} > INT26 + .int27 : {} > INT27 + .int28 : {} > INT28 + .int29 : {} > INT29 + .int30 : {} > INT30 + .int31 : {} > INT31 + .int32 : {} > INT32 + .int33 : {} > INT33 + .int34 : {} > INT34 + .int35 : {} > INT35 + .int36 : {} > INT36 + .int37 : {} > INT37 + .int38 : {} > INT38 + .int39 : {} > INT39 + .int40 : {} > INT40 + RTC : { * ( .int41 ) } > INT41 type = VECT_INIT + PORT2 : { * ( .int42 ) } > INT42 type = VECT_INIT + USCI_B3 : { * ( .int43 ) } > INT43 type = VECT_INIT + USCI_A3 : { * ( .int44 ) } > INT44 type = VECT_INIT + USCI_B1 : { * ( .int45 ) } > INT45 type = VECT_INIT + USCI_A1 : { * ( .int46 ) } > INT46 type = VECT_INIT + PORT1 : { * ( .int47 ) } > INT47 type = VECT_INIT + TIMER1_A1 : { * ( .int48 ) } > INT48 type = VECT_INIT + TIMER1_A0 : { * ( .int49 ) } > INT49 type = VECT_INIT + DMA : { * ( .int50 ) } > INT50 type = VECT_INIT + USCI_B2 : { * ( .int51 ) } > INT51 type = VECT_INIT + USCI_A2 : { * ( .int52 ) } > INT52 type = VECT_INIT + TIMER0_A1 : { * ( .int53 ) } > INT53 type = VECT_INIT + TIMER0_A0 : { * ( .int54 ) } > INT54 type = VECT_INIT + ADC12 : { * ( .int55 ) } > INT55 type = VECT_INIT + USCI_B0 : { * ( .int56 ) } > INT56 type = VECT_INIT + USCI_A0 : { * ( .int57 ) } > INT57 type = VECT_INIT + WDT : { * ( .int58 ) } > INT58 type = VECT_INIT + TIMER0_B1 : { * ( .int59 ) } > INT59 type = VECT_INIT + TIMER0_B0 : { * ( .int60 ) } > INT60 type = VECT_INIT + UNMI : { * ( .int61 ) } > INT61 type = VECT_INIT + SYSNMI : { * ( .int62 ) } > INT62 type = VECT_INIT + .reset : {} > RESET /* MSP430 Reset vector */ +} + +/****************************************************************************/ +/* Include peripherals memory map */ +/****************************************************************************/ + +-l msp430f5438a.cmd + diff --git a/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/main.c b/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/main.c new file mode 100644 index 0000000..4de5073 --- /dev/null +++ b/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/main.c @@ -0,0 +1,12 @@ +#include + + +/** + * main.c + */ +int main(void) +{ + WDTCTL = WDTPW | WDTHOLD; // stop watchdog timer + + return 0; +} diff --git a/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/targetConfigs/MSP430F5438A.ccxml b/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/targetConfigs/MSP430F5438A.ccxml new file mode 100644 index 0000000..4b3573b --- /dev/null +++ b/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/targetConfigs/MSP430F5438A.ccxml @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/targetConfigs/readme.txt b/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/targetConfigs/readme.txt new file mode 100644 index 0000000..d783fef --- /dev/null +++ b/Software/Code Composer Studio Workspace/SunseekerTelemetryAndLightingSystem/targetConfigs/readme.txt @@ -0,0 +1,9 @@ +The 'targetConfigs' folder contains target-configuration (.ccxml) files, automatically generated based +on the device and connection settings specified in your project on the Properties > General page. + +Please note that in automatic target-configuration management, changes to the project's device and/or +connection settings will either modify an existing or generate a new target-configuration file. Thus, +if you manually edit these auto-generated files, you may need to re-apply your changes. Alternatively, +you may create your own target-configuration file for this project and manage it manually. You can +always switch back to automatic target-configuration management by checking the "Manage the project's +target-configuration automatically" checkbox on the project's Properties > General page. \ No newline at end of file