@sparkle-learning/core 0.0.55 → 0.0.57

package/dist/sparkle-core/sparkle-tabs.entry.js

@@ -0,0 +1,62 @@
+import { r as registerInstance, k as h, o as getElement, n as Host } from './index-1dec9544.js';
+
+const tabsCss = ".Tabs,.Tabs-tab{display:block}.Tabs-tab:not([selected]){display:none}.Tabs-header{border-bottom:solid 1px rgba(0, 32, 88, 0.1);white-space:nowrap}.Tabs-button{--bg-alpha:0;appearance:none;background-color:rgba(0, 0, 0, var(--bg-alpha));border:none;color:var(--text-color--light);cursor:pointer;font-family:inherit;font-size:10px;font-weight:600;letter-spacing:0.04em;padding:1rem;text-transform:uppercase;transform:translateY(1px)}.Tabs-button:first-child{border-top-left-radius:6px}.Tabs-button:last-child{border-top-right-radius:6px}.Tabs-button:focus{outline:none}.Tabs-button:focus{--bg-alpha:0.015}@media (hover: hover){.Tabs-button:hover{--bg-alpha:0.015}}.Tabs-button:active{--bg-alpha:0.03}.Tabs-button.is-selected{border-bottom:solid 1px currentColor;color:var(--accent-color)}.Tabs-tab sparkle-code pre{margin-top:0}";
+
+const SparkleTabs = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.selected = null;
+    this.tabs = [];
+    this.toTabButton = (tab) => {
+      const label = tab.getAttribute('tab');
+      const isSelected = this.selected === tab;
+      const buttonClass = {
+        'Tabs-button': true,
+        'is-selected': isSelected
+      };
+      return (h("button", { role: "tab", "aria-selected": isSelected ? 'true' : 'false', onClick: () => this.select(tab), class: buttonClass }, label));
+    };
+  }
+  // if an event with a name that matches the 'listenFor' property is heard,
+  // check the tabs to see if the event has a value that matches a tab title
+  // The original purpose for this is the Framework Selection dropdown
+  listenForFrameworkSelection(event) {
+    if (typeof this.listenFor !== 'undefined' && event.detail.key === this.listenFor) {
+      this.tabs.forEach(tab => {
+        if (tab.tab.toLowerCase() === event.detail.value.toLowerCase()) {
+          this.select(tab);
+        }
+      });
+    }
+  }
+  componentDidLoad() {
+    this.tabs = Array.from(this.el.querySelectorAll('sparkle-tab'));
+    this.select(this.tabs.find(t => t.hasAttribute('selected')) || this.tabs[0]);
+  }
+  select(tab) {
+    if (this.selected !== null) {
+      this.selected.removeAttribute('selected');
+    }
+    this.selected = tab;
+    this.selected.setAttribute('selected', '');
+  }
+  hostData() {
+    return {
+      role: 'tablist',
+      class: {
+        'Tabs': true
+      }
+    };
+  }
+  __stencil_render() {
+    return [
+      h("header", { class: "Tabs-header" }, this.tabs.map(this.toTabButton)),
+      h("slot", null)
+    ];
+  }
+  get el() { return getElement(this); }
+  render() { return h(Host, this.hostData(), this.__stencil_render()); }
+};
+SparkleTabs.style = tabsCss;
+
+export { SparkleTabs as sparkle_tabs };

package/dist/sparkle-core/sparkle-unauthorized.entry.js

@@ -0,0 +1,17 @@
+import { r as registerInstance, k as h, n as Host } from './index-1dec9544.js';
+
+const sparkleUnauthorizedCss = ":host{display:block}.unauthorized{display:block;padding-left:var(--page-margin-left);padding-top:var(--header-height)}.content{text-align:center;padding-top:40px}";
+
+const SparkleUnauthorized = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+  }
+  render() {
+    return (h(Host, { class: {
+        'unauthorized': true,
+      } }, h("div", { class: "content" }, h("h1", null, "401"), h("p", null, "Unauthorized"))));
+  }
+};
+SparkleUnauthorized.style = sparkleUnauthorizedCss;
+
+export { SparkleUnauthorized as sparkle_unauthorized };

package/dist/sparkle-core/sparkle-user-enrollment.entry.js

@@ -0,0 +1,85 @@
+import { r as registerInstance, k as h, n as Host } from './index-1dec9544.js';
+import { S as StudentService } from './student.service-f0375229.js';
+import { u as userStore } from './user.store-3d052406.js';
+import './index-0df264ee.js';
+import './assets.service-6508aae6.js';
+import './localstorage.service-4bf408c8.js';
+import './index-1d7a6fa0.js';
+import './utils-cae23bce.js';
+import './animation-676a644d.js';
+import './helpers-f11f0674.js';
+import './ios.transition-02531dda.js';
+import './index-183cda39.js';
+import './md.transition-f8765467.js';
+import './cubic-bezier-4c0db14f.js';
+import './index-dd414b33.js';
+import './ionic-global-127576f6.js';
+import './index-be6112f8.js';
+import './index-0af0deac.js';
+import './hardware-back-button-fa04d6e9.js';
+import './overlays-fd3cfa13.js';
+
+const sparkleUserEnrollmentCss = ":host{display:block}";
+
+const SparkleUserEnrollment = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.enrollmentFormControls = {
+      ShortCode: {
+        isValid: false,
+        value: '',
+        validate: (value) => {
+          if (value) {
+            return true;
+          }
+          else {
+            return false;
+          }
+        },
+      },
+    };
+    this.enrollmentFormSubmitted = false;
+  }
+  changeEnrollmentFormValue(controlName, value) {
+    this.enrollmentFormControls = Object.assign(Object.assign({}, this.enrollmentFormControls), { [controlName]: Object.assign(Object.assign({}, this.enrollmentFormControls[controlName]), { value: value, isValid: this.enrollmentFormControls[controlName].validate(value) }) });
+  }
+  async handleEnrollmentFormSubmit(e) {
+    e.preventDefault();
+    this.enrollmentFormSubmitted = true;
+    let isFormValid = true;
+    //Run all validation functions
+    for (let controlName in this.enrollmentFormControls) {
+      let control = this.enrollmentFormControls[controlName];
+      control.validate(control.value);
+      if (!control.isValid) {
+        isFormValid = false;
+      }
+    }
+    if (isFormValid) {
+      let result = await StudentService.getInstance().enrollClass({
+        ShortCode: this.enrollmentFormControls.ShortCode.value,
+      });
+      console.log(result);
+    }
+  }
+  async leaveClass(enrollmentId) {
+    let result = await StudentService.getInstance().leaveClass({
+      Id: enrollmentId,
+    });
+    console.log(result);
+  }
+  renderEnrollmentList() {
+    if (userStore.state.enrollmentList.length > 0) {
+      return (userStore.state.enrollmentList.map((item) => h("ion-item", null, h("ion-label", null, item.Name), h("ion-button", { onClick: () => this.leaveClass(item.Id) }, h("ion-icon", { name: "trash" })))));
+    }
+    else {
+      return (h("ion-item", { lines: "none" }, h("ion-text", { class: "ion-text-center" }, "No data found")));
+    }
+  }
+  render() {
+    return (h(Host, null, h("form", { onSubmit: e => this.handleEnrollmentFormSubmit(e), novalidate: true }, h("ion-list", { "no-lines": true }, h("ion-list-header", null, "Enrollment"), h("ion-grid", null, h("ion-row", { class: "ion-align-items-center" }, h("ion-col", { size: "9" }, h("ion-item", null, h("ion-label", { position: "stacked", color: "primary" }, "Short Code"), h("ion-input", { name: "ShortCode", type: "text", value: this.enrollmentFormControls.ShortCode.value, onInput: (ev) => this.changeEnrollmentFormValue("ShortCode", ev.target.value) })), h("ion-text", { color: "danger" }, h("p", { hidden: this.enrollmentFormControls.ShortCode.isValid || this.enrollmentFormSubmitted === false, class: "ion-padding-start" }, "Short Code is required"))), h("ion-col", { size: "3" }, h("div", null, h("ion-button", { slot: "end", type: "submit", expand: "block" }, "Enroll"))))))), h("ion-list", null, h("ion-list-header", null, "Enroll List"), this.renderEnrollmentList())));
+  }
+};
+SparkleUserEnrollment.style = sparkleUserEnrollmentCss;
+
+export { SparkleUserEnrollment as sparkle_user_enrollment };

package/dist/sparkle-core/sparkle-user-profile.entry.js

@@ -0,0 +1,129 @@
+import { r as registerInstance, k as h, n as Host, h as getAssetPath, o as getElement } from './index-1dec9544.js';
+import { S as StudentService } from './student.service-f0375229.js';
+import { u as userStore } from './user.store-3d052406.js';
+import { M as MediaService, m as mediaStore } from './media.service-2609406e.js';
+import './index-0df264ee.js';
+import './assets.service-6508aae6.js';
+import './localstorage.service-4bf408c8.js';
+import './index-1d7a6fa0.js';
+import './utils-cae23bce.js';
+import './animation-676a644d.js';
+import './helpers-f11f0674.js';
+import './ios.transition-02531dda.js';
+import './index-183cda39.js';
+import './md.transition-f8765467.js';
+import './cubic-bezier-4c0db14f.js';
+import './index-dd414b33.js';
+import './ionic-global-127576f6.js';
+import './index-be6112f8.js';
+import './index-0af0deac.js';
+import './hardware-back-button-fa04d6e9.js';
+import './overlays-fd3cfa13.js';
+
+const sparkleUserProfileCss = ":host{display:block}ion-card{box-shadow:0px 2px 2px rgba(0, 0, 0, 0.2);overflow:visible;margin:16px 0 24px;position:relative;padding-top:60px}ion-card .img-wrapper{background-color:#f5f5f5;border-radius:10px;position:absolute;left:50%;top:-30px;transform:translateX(-50%)}ion-card .img-wrapper img{border-radius:10px;width:80px;height:80px}ion-card .img-wrapper ion-button{--border-width:1px;--border-color:var(--ion-color-sparkle);--border-style:solid;--padding-start:0;--padding-end:0;--padding-bottom:0;--padding-top:0;--border-radius:50%;height:26px;width:26px;position:absolute;right:-10px;bottom:-10px}ion-card .img-wrapper ion-button ion-icon{width:14px;height:14px}ion-card .img-wrapper img.loading{opacity:0.1}.image-upload-loading{position:absolute;top:40%;left:35%}";
+
+const SparkleUserProfile = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.profileFormControls = {
+      ProfileImage: {
+        isValid: true,
+        value: '',
+        validate: (_) => {
+          return true;
+        },
+      },
+      FirstName: {
+        isValid: false,
+        value: '',
+        validate: (value) => {
+          if (value) {
+            return true;
+          }
+          else {
+            return false;
+          }
+        },
+      },
+      LastName: {
+        isValid: false,
+        value: '',
+        validate: (value) => {
+          if (value) {
+            return true;
+          }
+          else {
+            return false;
+          }
+        },
+      },
+      ProfileText: {
+        isValid: true,
+        value: '',
+        validate: (value) => {
+          if (value) {
+            return true;
+          }
+          else {
+            return false;
+          }
+        }
+      }
+    };
+    this.profileFormSubmitted = false;
+  }
+  componentWillLoad() {
+    if (userStore.state.user) {
+      const user = userStore.state.user;
+      this.changeFormValue("FirstName", user.FirstName);
+      this.changeFormValue("LastName", user.LastName);
+      this.changeFormValue("ProfileText", user.ProfileText);
+      this.changeFormValue("ProfileImage", user.ProfileImage);
+    }
+  }
+  changeFormValue(controlName, value) {
+    this.profileFormControls = Object.assign(Object.assign({}, this.profileFormControls), { [controlName]: Object.assign(Object.assign({}, this.profileFormControls[controlName]), { value: value, isValid: this.profileFormControls[controlName].validate(value) }) });
+  }
+  async handleProfileFormSubmit(e) {
+    e.preventDefault();
+    await this.updateUser();
+  }
+  async updateUser() {
+    this.profileFormSubmitted = true;
+    let isFormValid = true;
+    for (let controlName in this.profileFormControls) {
+      let control = this.profileFormControls[controlName];
+      control.validate(control.value);
+      if (!control.isValid) {
+        isFormValid = false;
+      }
+    }
+    if (isFormValid) {
+      let result = await StudentService.getInstance().updateProfile({
+        FirstName: this.profileFormControls.FirstName.value,
+        LastName: this.profileFormControls.LastName.value,
+        ProfileImage: this.profileFormControls.ProfileImage.value,
+        ProfileText: this.profileFormControls.ProfileText.value
+      });
+    }
+  }
+  async uploadProfileImage(event) {
+    if (event.target.files && event.target.files[0]) {
+      const result = await MediaService.getInstance().uploadImage(event.target.files);
+      if (result.Succeeded && result.Data && result.Data.length > 0) {
+        this.changeFormValue("ProfileImage", result.Data[0].FullImageUrl);
+        await this.updateUser();
+      }
+    }
+  }
+  selectFile() {
+    this.el.querySelector("#fileInput").click();
+  }
+  render() {
+    return (h(Host, null, h("ion-card", { color: "sparkle" }, h("div", { class: "img-wrapper" }, h("img", { class: mediaStore.state.mediaUploading ? "loading" : '', src: this.profileFormControls.ProfileImage.value || getAssetPath(`../assets/svg/profile.svg`) }), h("input", { type: "file", id: "fileInput", onChange: (ev) => this.uploadProfileImage(ev), style: { display: "none" }, accept: "image/*" }), h("ion-button", { color: "sparkle", onClick: () => this.selectFile(), disabled: mediaStore.state.mediaUploading }, h("ion-icon", { slot: "icon-only", name: "camera-outline" })), mediaStore.state.mediaUploading && h("ion-spinner", { class: "image-upload-loading", name: "dots" })), h("ion-card-content", { class: "ion-text-center" }, h("h2", null, this.profileFormControls.FirstName.value, " ", this.profileFormControls.LastName.value), h("h3", null, this.profileFormControls.ProfileText.value))), h("form", { onSubmit: e => this.handleProfileFormSubmit(e), novalidate: true }, h("ion-list", { "no-lines": true }, h("ion-item", null, h("ion-label", { position: "stacked", color: "primary" }, "First Name"), h("ion-input", { name: "firstName", type: "text", value: this.profileFormControls.FirstName.value, onInput: (ev) => this.changeFormValue("FirstName", ev.target.value) })), h("ion-text", { color: "danger" }, h("p", { hidden: this.profileFormControls.FirstName.isValid || this.profileFormSubmitted === false, class: "ion-padding-start" }, "First Name is required")), h("ion-item", null, h("ion-label", { position: "stacked", color: "primary" }, "Last Name"), h("ion-input", { name: "lastName", type: "text", value: this.profileFormControls.LastName.value, onInput: (ev) => this.changeFormValue("LastName", ev.target.value) })), h("ion-text", { color: "danger" }, h("p", { hidden: this.profileFormControls.LastName.isValid || this.profileFormSubmitted === false, class: "ion-padding-start" }, "Last Name is required")), h("ion-item", null, h("ion-label", { position: "stacked", color: "primary" }, "Profile Bio"), h("ion-input", { name: "lastName", type: "text", value: this.profileFormControls.ProfileText.value, onInput: (ev) => this.changeFormValue("ProfileText", ev.target.value) })), h("ion-text", { color: "danger" }, h("p", { hidden: this.profileFormControls.ProfileText.isValid || this.profileFormSubmitted === false, class: "ion-padding-start" }, "Profile Bio is required"))), h("div", { class: "ion-padding" }, h("ion-button", { type: "submit", expand: "block", disabled: userStore.state.updateLoading }, userStore.state.updateLoading && h("ion-spinner", { name: "dots" }), " Update")))));
+  }
+  get el() { return getElement(this); }
+};
+SparkleUserProfile.style = sparkleUserProfileCss;
+
+export { SparkleUserProfile as sparkle_user_profile };

package/dist/sparkle-core/sparkle-validation-error.entry.js

@@ -0,0 +1,17 @@
+import { r as registerInstance, k as h, n as Host } from './index-1dec9544.js';
+
+const sparkleValidationErrorCss = ":host{display:block}sparkle-validation-error ul{padding:10px 0px}sparkle-validation-error .alert-danger{margin-top:10px;font-size:12px}";
+
+const SparkleValidationError = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.errors = [];
+  }
+  render() {
+    return (h(Host, null, this.errors.length > 0 &&
+      h("div", { class: "alert alert-danger", role: "alert" }, h("ul", null, this.errors.map(error => h("li", null, h("b", null, error.Field, ": "), error.Message))))));
+  }
+};
+SparkleValidationError.style = sparkleValidationErrorCss;
+
+export { SparkleValidationError as sparkle_validation_error };

package/dist/sparkle-core/sparkle-video-player.entry.js

@@ -0,0 +1,18 @@
+import { r as registerInstance, k as h } from './index-1dec9544.js';
+
+const sparkleVideoPlayerCss = "";
+
+const SparkleVideoPlayer = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.type = 'video/mp4';
+    this.width = 400;
+    this.controls = true;
+  }
+  render() {
+    return (h("video", { width: this.width, controls: this.controls, preload: "metadata" }, h("source", { src: this.src, type: this.type })));
+  }
+};
+SparkleVideoPlayer.style = sparkleVideoPlayerCss;
+
+export { SparkleVideoPlayer as sparkle_video_player };

package/dist/sparkle-core/sparkle-youtube.entry.js

@@ -0,0 +1,35 @@
+import { r as registerInstance, k as h, o as getElement } from './index-1dec9544.js';
+
+const sparkleYoutubeCss = ":host(.loaded) div.youtube-container{opacity:var(--sparkle-youtube-opacity-loaded, 1)}div.youtube-container{opacity:var(--sparkle-youtube-opacity-not-loaded, 0);transition:var(--sparkle-youtube-transition, opacity 0.15s linear)}.embed-container{position:relative;padding-bottom:56.25%;height:0;overflow:hidden;max-width:100%}.embed-container iframe,.embed-container object,.embed-container embed{position:absolute;top:0;left:0;width:100%;height:100%}";
+
+const SparkleYoutube = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.video_thumbnail = '';
+  }
+  componentDidLoad() {
+    this.classMode = this.initialClassMode;
+    this.classModeChanged();
+  }
+  classModeChanged() {
+    if (this.classMode) {
+      var youtube_video_id = this.src.match(/youtube\.com.*(\?v=|\/embed\/)(.{11})/).pop();
+      if (youtube_video_id.length == 11) {
+        this.video_thumbnail = '//img.youtube.com/vi/' + youtube_video_id + '/0.jpg';
+      }
+    }
+  }
+  async classRoomModeChanged(val) {
+    this.classMode = val;
+  }
+  render() {
+    return (h("div", null, !this.classMode ? (h("div", { class: "embed-container" }, h("iframe", { src: this.src.replace("watch?v=", "embed/"), frameborder: "0", allowFullScreen: true }))) : (h("div", null, h("img", { src: this.video_thumbnail })))));
+  }
+  get el() { return getElement(this); }
+  static get watchers() { return {
+    "classMode": ["classModeChanged"]
+  }; }
+};
+SparkleYoutube.style = sparkleYoutubeCss;
+
+export { SparkleYoutube as sparkle_youtube };

package/dist/sparkle-core/status-tap-52feb1b1.js

@@ -0,0 +1,40 @@
+import { t as readTask, l as writeTask } from './index-1dec9544.js';
+import { a as findClosestIonContent, s as scrollToTop } from './index-bb469fe3.js';
+import { c as componentOnReady } from './helpers-f11f0674.js';
+import './index-05b398c2.js';
+
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+const startStatusTap = () => {
+  const win = window;
+  win.addEventListener('statusTap', () => {
+    readTask(() => {
+      const width = win.innerWidth;
+      const height = win.innerHeight;
+      const el = document.elementFromPoint(width / 2, height / 2);
+      if (!el) {
+        return;
+      }
+      const contentEl = findClosestIonContent(el);
+      if (contentEl) {
+        new Promise((resolve) => componentOnReady(contentEl, resolve)).then(() => {
+          writeTask(async () => {
+            /**
+             * If scrolling and user taps status bar,
+             * only calling scrollToTop is not enough
+             * as engines like WebKit will jump the
+             * scroll position back down and complete
+             * any in-progress momentum scrolling.
+             */
+            contentEl.style.setProperty('--overflow', 'hidden');
+            await scrollToTop(contentEl, 300);
+            contentEl.style.removeProperty('--overflow');
+          });
+        });
+      }
+    });
+  });
+};
+
+export { startStatusTap };

package/dist/sparkle-core/stencil-async-content.entry.js

@@ -0,0 +1,28 @@
+import { r as registerInstance, k as h } from './index-1dec9544.js';
+
+const AsyncContent = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.content = '';
+  }
+  componentWillLoad() {
+    if (this.documentLocation != null) {
+      return this.fetchNewContent(this.documentLocation);
+    }
+  }
+  fetchNewContent(newDocumentLocation) {
+    return fetch(newDocumentLocation)
+      .then(response => response.text())
+      .then(data => {
+      this.content = data;
+    });
+  }
+  render() {
+    return (h("div", { innerHTML: this.content }));
+  }
+  static get watchers() { return {
+    "documentLocation": ["fetchNewContent"]
+  }; }
+};
+
+export { AsyncContent as stencil_async_content };

package/dist/sparkle-core/stencil-route-link.entry.js

@@ -0,0 +1,74 @@
+import { r as registerInstance, k as h, o as getElement } from './index-1dec9544.js';
+import { m as matchPath } from './match-path-760e1797.js';
+import { d as isModifiedEvent } from './dom-utils-8e73e88b.js';
+import { A as ActiveRouter } from './active-router-af86c9b4.js';
+import './location-utils-fea12957.js';
+
+const getUrl = (url, root) => {
+  // Don't allow double slashes
+  if (url.charAt(0) == '/' && root.charAt(root.length - 1) == '/') {
+    return root.slice(0, root.length - 1) + url;
+  }
+  return root + url;
+};
+const RouteLink = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.unsubscribe = () => { return; };
+    this.activeClass = 'link-active';
+    this.exact = false;
+    this.strict = true;
+    /**
+      *  Custom tag to use instead of an anchor
+      */
+    this.custom = 'a';
+    this.match = null;
+  }
+  componentWillLoad() {
+    this.computeMatch();
+  }
+  // Identify if the current route is a match.
+  computeMatch() {
+    if (this.location) {
+      this.match = matchPath(this.location.pathname, {
+        path: this.urlMatch || this.url,
+        exact: this.exact,
+        strict: this.strict
+      });
+    }
+  }
+  handleClick(e) {
+    if (isModifiedEvent(e) || !this.history || !this.url || !this.root) {
+      return;
+    }
+    e.preventDefault();
+    return this.history.push(getUrl(this.url, this.root));
+  }
+  // Get the URL for this route link without the root from the router
+  render() {
+    let anchorAttributes = {
+      class: {
+        [this.activeClass]: this.match !== null,
+      },
+      onClick: this.handleClick.bind(this)
+    };
+    if (this.anchorClass) {
+      anchorAttributes.class[this.anchorClass] = true;
+    }
+    if (this.custom === 'a') {
+      anchorAttributes = Object.assign({}, anchorAttributes, { href: this.url, title: this.anchorTitle, role: this.anchorRole, tabindex: this.anchorTabIndex, 'aria-haspopup': this.ariaHaspopup, id: this.anchorId, 'aria-posinset': this.ariaPosinset, 'aria-setsize': this.ariaSetsize, 'aria-label': this.ariaLabel });
+    }
+    return (h(this.custom, Object.assign({}, anchorAttributes), h("slot", null)));
+  }
+  get el() { return getElement(this); }
+  static get watchers() { return {
+    "location": ["computeMatch"]
+  }; }
+};
+ActiveRouter.injectProps(RouteLink, [
+  'history',
+  'location',
+  'root'
+]);
+
+export { RouteLink as stencil_route_link };

package/dist/sparkle-core/stencil-route-switch.entry.js

@@ -0,0 +1,100 @@
+import { r as registerInstance, u as getContext, k as h, o as getElement } from './index-1dec9544.js';
+import { A as ActiveRouter } from './active-router-af86c9b4.js';
+import { m as matchPath } from './match-path-760e1797.js';
+import './location-utils-fea12957.js';
+
+const getUniqueId = () => {
+  return ((Math.random() * 10e16).toString().match(/.{4}/g) || []).join('-');
+};
+const getMatch = (pathname, url, exact) => {
+  return matchPath(pathname, {
+    path: url,
+    exact: exact,
+    strict: true
+  });
+};
+const isHTMLStencilRouteElement = (elm) => {
+  return elm.tagName === 'STENCIL-ROUTE';
+};
+const RouteSwitch = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.group = getUniqueId();
+    this.subscribers = [];
+    this.queue = getContext(this, "queue");
+  }
+  componentWillLoad() {
+    if (this.location != null) {
+      this.regenerateSubscribers(this.location);
+    }
+  }
+  async regenerateSubscribers(newLocation) {
+    if (newLocation == null) {
+      return;
+    }
+    let newActiveIndex = -1;
+    this.subscribers = Array.prototype.slice.call(this.el.children)
+      .filter(isHTMLStencilRouteElement)
+      .map((childElement, index) => {
+      const match = getMatch(newLocation.pathname, childElement.url, childElement.exact);
+      if (match && newActiveIndex === -1) {
+        newActiveIndex = index;
+      }
+      return {
+        el: childElement,
+        match: match
+      };
+    });
+    if (newActiveIndex === -1) {
+      return;
+    }
+    // Check if this actually changes which child is active
+    // then just pass the new match down if the active route isn't changing.
+    if (this.activeIndex === newActiveIndex) {
+      this.subscribers[newActiveIndex].el.match = this.subscribers[newActiveIndex].match;
+      return;
+    }
+    this.activeIndex = newActiveIndex;
+    // Set all props on the new active route then wait until it says that it
+    // is completed
+    const activeChild = this.subscribers[this.activeIndex];
+    if (this.scrollTopOffset) {
+      activeChild.el.scrollTopOffset = this.scrollTopOffset;
+    }
+    activeChild.el.group = this.group;
+    activeChild.el.match = activeChild.match;
+    activeChild.el.componentUpdated = (routeViewUpdatedOptions) => {
+      // After the new active route has completed then update visibility of routes
+      this.queue.write(() => {
+        this.subscribers.forEach((child, index) => {
+          child.el.componentUpdated = undefined;
+          if (index === this.activeIndex) {
+            return child.el.style.display = '';
+          }
+          if (this.scrollTopOffset) {
+            child.el.scrollTopOffset = this.scrollTopOffset;
+          }
+          child.el.group = this.group;
+          child.el.match = null;
+          child.el.style.display = 'none';
+        });
+      });
+      if (this.routeViewsUpdated) {
+        this.routeViewsUpdated(Object.assign({ scrollTopOffset: this.scrollTopOffset }, routeViewUpdatedOptions));
+      }
+    };
+  }
+  render() {
+    return (h("slot", null));
+  }
+  get el() { return getElement(this); }
+  static get watchers() { return {
+    "location": ["regenerateSubscribers"]
+  }; }
+};
+ActiveRouter.injectProps(RouteSwitch, [
+  'location',
+  'routeViewsUpdated'
+]);
+
+export { RouteSwitch as stencil_route_switch };

package/dist/sparkle-core/stencil-route-title.entry.js

@@ -0,0 +1,28 @@
+import { r as registerInstance, o as getElement } from './index-1dec9544.js';
+import { A as ActiveRouter } from './active-router-af86c9b4.js';
+
+const RouteTitle = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.titleSuffix = '';
+    this.pageTitle = '';
+  }
+  updateDocumentTitle() {
+    const el = this.el;
+    if (el.ownerDocument) {
+      el.ownerDocument.title = `${this.pageTitle}${this.titleSuffix || ''}`;
+    }
+  }
+  componentWillLoad() {
+    this.updateDocumentTitle();
+  }
+  get el() { return getElement(this); }
+  static get watchers() { return {
+    "pageTitle": ["updateDocumentTitle"]
+  }; }
+};
+ActiveRouter.injectProps(RouteTitle, [
+  'titleSuffix',
+]);
+
+export { RouteTitle as stencil_route_title };