@sparkle-learning/core 0.0.57 → 0.0.59

package/dist/cjs/compass-svg.cjs.entry.js

@@ -0,0 +1,132 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-51e8292e.js');
+
+const compassSvgCss = ":host{display:block}.donut-ring{stroke:#000;stroke-width:1px}text{font-size:30px;font-weight:800;letter-spacing:2px;text-transform:uppercase;font-family:'Roboto Slab', serif}";
+
+const CompassSvg = class {
+  constructor(hostRef) {
+    index.registerInstance(this, hostRef);
+    this.circles = [];
+    this.segmentTexts1 = [
+      {
+        id: "relationships",
+        text: "RelationShips",
+        angle: 180
+      },
+      {
+        id: "emotions",
+        text: "Emotions",
+        angle: 225
+      },
+      {
+        id: "spirituality",
+        text: "Spirituality",
+        angle: 270
+      },
+      {
+        id: "restAndPlay",
+        text: "Rest & Play",
+        angle: 315
+      }
+    ];
+    this.segmentTexts2 = [
+      {
+        id: "vocation",
+        text: "Vocation",
+        angle: -180
+      },
+      {
+        id: "organization",
+        text: "Organization",
+        angle: -225
+      },
+      {
+        id: "careforbody",
+        text: "Care for body",
+        angle: -270
+      },
+      {
+        id: "resilience",
+        text: "Resilience",
+        angle: -315
+      }
+    ];
+    this.colors = ["indigo", "green", "blue", "violet", "lightgray", "cyan", "magenta", "red"];
+    //colors = ["#fff", "#fff", "#fff", "#fff", "#fff", "#fff", "#fff", "#fff"];
+    this.strokeWidth = 30;
+    this.polygonRadius = 100;
+    this.polygonWidth = 60;
+    this.borderGaps = 60;
+    this.segments = [1, 2, 3, 4, 5, 6, 7, 8];
+    this.radius = 460;
+    this.cx = this.radius + this.strokeWidth * 3;
+    this.cy = this.radius + this.strokeWidth * 3;
+    this.svgHeight = this.radius + this.strokeWidth * 3;
+    this.svgWidth = this.radius + this.strokeWidth * 3;
+    this.calculateStrokeDashOffset = (radius) => {
+      let circumference = (2 * Math.PI * radius);
+      const strokeDiff = (12.5 / 100) * circumference;
+      return circumference - strokeDiff;
+    };
+  }
+  //  distanceX = (1.414 * this.radius - this.radius) * 0.5;
+  componentWillLoad() {
+    let radius = this.radius;
+    for (let i = 0; i <= 10; i++) {
+      if (i == 0) {
+        this.circles.push({
+          cx: this.cx,
+          cy: this.cy,
+          radius: radius,
+          strokeWidth: this.strokeWidth * 3
+        });
+        radius -= this.strokeWidth;
+      }
+      else if (i == 1) {
+        this.circles.push({
+          cx: this.cx,
+          cy: this.cy,
+          radius: radius,
+          strokeWidth: this.strokeWidth * 1.5
+        });
+        radius -= this.strokeWidth;
+      }
+      else {
+        this.circles.push({
+          cx: this.cx,
+          cy: this.cy,
+          radius: radius,
+          strokeWidth: this.strokeWidth
+        });
+      }
+      radius -= this.strokeWidth;
+    }
+  }
+  getXCordinate(angle) {
+    console.log(angle);
+    return this.cx + (this.radius - (this.strokeWidth * 1.8)) * Math.cos(angle * Math.PI / 180);
+  }
+  getYCordinate(angle) {
+    return this.cy + (this.radius - (this.strokeWidth * 1.8)) * Math.sin(angle * Math.PI / 180);
+  }
+  render() {
+    return (index.h(index.Host, null, index.h("div", null, index.h("svg", { height: this.svgHeight, width: this.svgWidth, viewBox: `0 0 ${this.svgWidth * 2} ${this.svgHeight * 2}`, class: "donut" }, this.circles.map((circle, circleIndex) => {
+      return this.segments.map((item, index$1) => [
+        index.h("circle", { class: "donut-ring", cx: circle.cx, cy: circle.cy, r: circle.radius + circle.strokeWidth, fill: "transparent", "stroke-width": "0.5", stroke: "#000" }),
+        index.h(index.Fragment, null, circleIndex > 1 ?
+          index.h("circle", { class: "rect", cx: circle.cx, cy: circle.cy, r: circle.radius, stroke: this.colors[index$1], "stroke-width": circle.strokeWidth, "stroke-dasharray": `${2 * Math.PI * circle.radius * 0.125}, ${(2 * Math.PI * circle.radius) - (2 * Math.PI * circle.radius * 0.125)}`, "stroke-dashoffset": this.calculateStrokeDashOffset(circle.radius), fill: "transparent", transform: `rotate(${index$1 * 45}, ${circle.cx}, ${circle.cy})` }) :
+          index.h("circle", { class: "rect", cx: circle.cx, cy: circle.cy, r: circle.radius, stroke: "none", "stroke-width": circle.strokeWidth, "stroke-dasharray": `${2 * Math.PI * circle.radius * 0.125}, ${(2 * Math.PI * circle.radius) - (2 * Math.PI * circle.radius * 0.125)}`, "stroke-dashoffset": this.calculateStrokeDashOffset(circle.radius), fill: "transparent", transform: `rotate(${index$1 * 45}, ${circle.cx}, ${circle.cy})` }))
+      ]);
+    }), index.h("defs", null, this.segmentTexts1.map((item) => {
+      return index.h("path", { id: item.id, d: `M${this.getXCordinate(item.angle)},${this.getYCordinate(item.angle)} A${this.radius},${this.radius} 0 0,1 ${this.getXCordinate(item.angle + 45)},${this.getYCordinate(item.angle + 45)}` });
+    }), this.segmentTexts2.map((item) => {
+      return index.h("path", { id: item.id, d: `M${this.getXCordinate(item.angle)},${this.getYCordinate(item.angle)} A${this.radius},${this.radius} 0 0,0 ${this.getXCordinate(item.angle - 45)},${this.getYCordinate(item.angle - 45)}` });
+    })), index.h("g", { fill: "black", stroke: "none" }, index.h("text", { x: "20", y: "0", "text-anchor": "start" }, index.h("textPath", { xlinkHref: "#spirituality" }, "spirituality")), index.h("text", { x: "20", y: "0", "text-anchor": "start" }, index.h("textPath", { xlinkHref: "#restAndPlay" }, "Rest & Play")), index.h("text", { x: "20", y: "0", "text-anchor": "start" }, index.h("textPath", { xlinkHref: "#resilience" }, "Resilience")), index.h("text", { x: "20", y: "0", "text-anchor": "start" }, index.h("textPath", { xlinkHref: "#careforbody" }, "Care for Body ")), index.h("text", { x: "20", y: "0", "text-anchor": "start" }, index.h("textPath", { xlinkHref: "#vocation" }, "vocation")), index.h("text", { x: "20", y: "0", "text-anchor": "start" }, index.h("textPath", { xlinkHref: "#organization" }, "Organization")), index.h("text", { x: "20", y: "0", "text-anchor": "start" }, index.h("textPath", { xlinkHref: "#relationships" }, "Relationships")), index.h("text", { x: "20", y: "0", "text-anchor": "start" }, index.h("textPath", { xlinkHref: "#emotions" }, "Emotions"))), index.h("line", { x1: this.cx - this.radius + (this.radius / 4), y1: this.cy - this.radius + (this.radius / 4), x2: this.cx + this.radius - (this.radius / 4), y2: this.cy + this.radius - (this.radius / 4), class: "cross-line", stroke: "#000", "stroke-width": "1" }), index.h("line", { x1: this.cx + this.radius - (this.radius / 4), y1: this.cy - this.radius + (this.radius / 4), x2: this.cx - this.radius + (this.radius / 4), y2: this.cy + this.radius - (this.radius / 4), class: "cross-line", stroke: "#000", "stroke-width": "1" }), index.h("polygon", { points: `${this.cx},${this.cy - this.radius - this.borderGaps} ${this.cx + this.polygonWidth},${this.cy - this.polygonWidth} ${this.cx + this.radius + this.borderGaps},${this.cy} ${this.cx + this.polygonWidth},${this.cy + this.polygonWidth} ${this.cx},${this.cy + this.radius + this.borderGaps} ${this.cx - this.polygonWidth},${this.cy + this.polygonWidth} ${this.cx - this.radius - this.borderGaps},${this.cy} ${this.cx - this.polygonWidth},${this.cy - this.polygonWidth}`, fill: "#000" }), index.h("circle", { cx: this.cx, cy: this.cy, r: "50", stroke: "black", "stroke-width": "3", fill: "#fff" }), index.h("circle", { cx: this.cx, cy: this.cy, r: "40", stroke: "black", "stroke-width": "2", fill: "#fff" })))));
+  }
+};
+CompassSvg.style = compassSvgCss;
+
+exports.compass_svg = CompassSvg;

package/dist/cjs/context-consumer.cjs.entry.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-51e8292e.js');
+
+const ContextConsumer = class {
+  constructor(hostRef) {
+    index.registerInstance(this, hostRef);
+    this.context = {};
+    this.renderer = () => null;
+  }
+  connectedCallback() {
+    if (this.subscribe != null) {
+      this.unsubscribe = this.subscribe(this.el, 'context');
+    }
+  }
+  disconnectedCallback() {
+    if (this.unsubscribe != null) {
+      this.unsubscribe();
+    }
+  }
+  render() {
+    return this.renderer(Object.assign({}, this.context));
+  }
+  get el() { return index.getElement(this); }
+};
+
+exports.context_consumer = ContextConsumer;

package/dist/cjs/course-select.cjs.entry.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-51e8292e.js');
+
+const CourseSelect = class {
+  constructor(hostRef) {
+    index.registerInstance(this, hostRef);
+    this.courses = ['Mind & Body', 'Data Analytics', 'Financial Literacy'];
+    this.renderOption = (course) => {
+      return (index.h("div", { class: "CourseSelect-course" }, index.h("span", null, course)));
+    };
+  }
+  componentDidLoad() { }
+  redirectToCourse(course) {
+    if (this.courses[1] === course) {
+      window.location.href = 'https://g3da.z13.web.core.windows.net/';
+    }
+    else if (this.courses[2] === course) {
+      window.location.href = 'https://girlsinclearning.com/Financial';
+    }
+  }
+  render() {
+    return index.h("sparkle-select", { class: "CourseSelect", options: this.courses, optionRenderer: this.renderOption, onSelection: ev => this.redirectToCourse(ev.detail) });
+  }
+  get el() { return index.getElement(this); }
+};
+
+exports.course_select = CourseSelect;

package/dist/cjs/cubic-bezier-53d26d05.js

@@ -0,0 +1,93 @@
+'use strict';
+
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+/**
+ * Based on:
+ * https://stackoverflow.com/questions/7348009/y-coordinate-for-a-given-x-cubic-bezier
+ * https://math.stackexchange.com/questions/26846/is-there-an-explicit-form-for-cubic-b%C3%A9zier-curves
+ * TODO: Reduce rounding error
+ */
+/**
+ * EXPERIMENTAL
+ * Given a cubic-bezier curve, get the x value (time) given
+ * the y value (progression).
+ * Ex: cubic-bezier(0.32, 0.72, 0, 1);
+ * P0: (0, 0)
+ * P1: (0.32, 0.72)
+ * P2: (0, 1)
+ * P3: (1, 1)
+ *
+ * If you give a cubic bezier curve that never reaches the
+ * provided progression, this function will return an empty array.
+ */
+const getTimeGivenProgression = (p0, p1, p2, p3, progression) => {
+  return solveCubicBezier(p0[1], p1[1], p2[1], p3[1], progression).map((tValue) => {
+    return solveCubicParametricEquation(p0[0], p1[0], p2[0], p3[0], tValue);
+  });
+};
+/**
+ * Solve a cubic equation in one dimension (time)
+ */
+const solveCubicParametricEquation = (p0, p1, p2, p3, t) => {
+  const partA = 3 * p1 * Math.pow(t - 1, 2);
+  const partB = -3 * p2 * t + 3 * p2 + p3 * t;
+  const partC = p0 * Math.pow(t - 1, 3);
+  return t * (partA + t * partB) - partC;
+};
+/**
+ * Find the `t` value for a cubic bezier using Cardano's formula
+ */
+const solveCubicBezier = (p0, p1, p2, p3, refPoint) => {
+  p0 -= refPoint;
+  p1 -= refPoint;
+  p2 -= refPoint;
+  p3 -= refPoint;
+  const roots = solveCubicEquation(p3 - 3 * p2 + 3 * p1 - p0, 3 * p2 - 6 * p1 + 3 * p0, 3 * p1 - 3 * p0, p0);
+  return roots.filter((root) => root >= 0 && root <= 1);
+};
+const solveQuadraticEquation = (a, b, c) => {
+  const discriminant = b * b - 4 * a * c;
+  if (discriminant < 0) {
+    return [];
+  }
+  else {
+    return [(-b + Math.sqrt(discriminant)) / (2 * a), (-b - Math.sqrt(discriminant)) / (2 * a)];
+  }
+};
+const solveCubicEquation = (a, b, c, d) => {
+  if (a === 0) {
+    return solveQuadraticEquation(b, c, d);
+  }
+  b /= a;
+  c /= a;
+  d /= a;
+  const p = (3 * c - b * b) / 3;
+  const q = (2 * b * b * b - 9 * b * c + 27 * d) / 27;
+  if (p === 0) {
+    return [Math.pow(-q, 1 / 3)];
+  }
+  else if (q === 0) {
+    return [Math.sqrt(-p), -Math.sqrt(-p)];
+  }
+  const discriminant = Math.pow(q / 2, 2) + Math.pow(p / 3, 3);
+  if (discriminant === 0) {
+    return [Math.pow(q / 2, 1 / 2) - b / 3];
+  }
+  else if (discriminant > 0) {
+    return [
+      Math.pow(-(q / 2) + Math.sqrt(discriminant), 1 / 3) - Math.pow(q / 2 + Math.sqrt(discriminant), 1 / 3) - b / 3,
+    ];
+  }
+  const r = Math.sqrt(Math.pow(-(p / 3), 3));
+  const phi = Math.acos(-(q / (2 * Math.sqrt(Math.pow(-(p / 3), 3)))));
+  const s = 2 * Math.pow(r, 1 / 3);
+  return [
+    s * Math.cos(phi / 3) - b / 3,
+    s * Math.cos((phi + 2 * Math.PI) / 3) - b / 3,
+    s * Math.cos((phi + 4 * Math.PI) / 3) - b / 3,
+  ];
+};
+
+exports.getTimeGivenProgression = getTimeGivenProgression;

package/dist/cjs/dir-5af5259a.js

@@ -0,0 +1,20 @@
+'use strict';
+
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+/**
+ * Returns `true` if the document or host element
+ * has a `dir` set to `rtl`. The host value will always
+ * take priority over the root document value.
+ */
+const isRTL = (hostEl) => {
+  if (hostEl) {
+    if (hostEl.dir !== '') {
+      return hostEl.dir.toLowerCase() === 'rtl';
+    }
+  }
+  return (document === null || document === void 0 ? void 0 : document.dir.toLowerCase()) === 'rtl';
+};
+
+exports.isRTL = isRTL;

package/dist/cjs/environment-config.service-c8ff1f3d.js

@@ -0,0 +1,28 @@
+'use strict';
+
+class EnvironmentConfigService {
+  constructor() {
+    // Private constructor, singleton
+    this.init();
+  }
+  static getInstance() {
+    if (!EnvironmentConfigService.instance) {
+      EnvironmentConfigService.instance = new EnvironmentConfigService();
+    }
+    return EnvironmentConfigService.instance;
+  }
+  init() {
+    if (!window) {
+      return;
+    }
+    const win = window;
+    const Sparkle = win.Sparkle;
+    this.m = new Map(Object.entries(Sparkle.config));
+  }
+  get(key, fallback) {
+    const value = this.m.get(key);
+    return value !== undefined ? value : fallback;
+  }
+}
+
+exports.EnvironmentConfigService = EnvironmentConfigService;

package/dist/cjs/facilitator.service-ff0e1659.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const httpService = require('./httpService-d2e7bf8f.js');
+const auth_store = require('./auth.store-1e630a7d.js');
+
+const { state, onChange } = auth_store.createStore({
+  pageNotes: [],
+  allPageNotes: [],
+  onlineStudents: [],
+  dashboardData: null,
+  isConnected: false,
+  loading: false,
+  dashboardDataLoading: false,
+  notesLoading: false,
+  classes: [],
+  classesLoading: false,
+});
+const facilitatorStore = { state, onChange };
+
+class FacilitatorService {
+  constructor() { }
+  static getInstance() {
+    if (!FacilitatorService.instance) {
+      FacilitatorService.instance = new FacilitatorService();
+    }
+    return FacilitatorService.instance;
+  }
+  async fetchClasses() {
+    facilitatorStore.state.classesLoading = true;
+    let result = await httpService.HttpService.http.get(`api/v1/Teacher/Classes`);
+    if (result) {
+      facilitatorStore.state.classes = result.Data;
+      facilitatorStore.state.classesLoading = false;
+    }
+    return result;
+  }
+  async fetchDashboardData(payload) {
+    facilitatorStore.state.dashboardDataLoading = true;
+    let result = await httpService.HttpService.http.get(`api/v1/Teacher/Dashboard/${payload.ClassId}`);
+    if (result) {
+      facilitatorStore.state.dashboardData = result.Data;
+      facilitatorStore.state.dashboardDataLoading = false;
+    }
+    return result;
+  }
+  async fetchNotes(payload) {
+    facilitatorStore.state.notesLoading = true;
+    let result = await httpService.HttpService.http.get(`api/v1/Teacher/Notes/${payload.showAllNotes}`);
+    if (result) {
+      if (payload.showAllNotes) {
+        facilitatorStore.state.allPageNotes = result.Data;
+      }
+      else {
+        facilitatorStore.state.pageNotes = result.Data;
+      }
+      facilitatorStore.state.notesLoading = false;
+    }
+    return result;
+  }
+  async addFacilitatorNote(payload) {
+    facilitatorStore.state.notesLoading = true;
+    let result = await httpService.HttpService.http.post(`api/v1/Teacher/Notes`, payload);
+    if (result) {
+      facilitatorStore.state.pageNotes = [...facilitatorStore.state.pageNotes, result.Data];
+    }
+    facilitatorStore.state.notesLoading = false;
+    return result;
+  }
+  async updateFacilitatorNote(payload) {
+    facilitatorStore.state.notesLoading = true;
+    let result = await httpService.HttpService.http.put(`api/v1/Teacher/Notes/${payload.Id}`, payload);
+    if (result) {
+      facilitatorStore.state.pageNotes = facilitatorStore.state.pageNotes.map((item) => {
+        if (item.Id == result.Data.Id) {
+          return result.Data;
+        }
+        return item;
+      });
+    }
+    facilitatorStore.state.notesLoading = false;
+    return result;
+  }
+  async deleteFacilitatorNote(id) {
+    facilitatorStore.state.notesLoading = true;
+    let result = await httpService.HttpService.http.delete(`api/v1/Teacher/Notes/${id}`);
+    if (result) {
+      facilitatorStore.state.pageNotes = facilitatorStore.state.pageNotes.filter(x => x.Id != id);
+    }
+    facilitatorStore.state.notesLoading = false;
+    return result;
+  }
+}
+
+exports.FacilitatorService = FacilitatorService;
+exports.facilitatorStore = facilitatorStore;

package/dist/cjs/feed.service-8eca4de6.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const httpService = require('./httpService-d2e7bf8f.js');
+const auth_store = require('./auth.store-1e630a7d.js');
+
+const { state, reset } = auth_store.createStore({
+  posts: [],
+  postsLoading: false,
+  createPostLoading: false,
+  postIdLoading: null
+});
+const feedStore = { state, reset };
+
+class FeedService {
+  constructor() { }
+  static getInstance() {
+    if (!FeedService.instance) {
+      FeedService.instance = new FeedService();
+    }
+    return FeedService.instance;
+  }
+  async getAllPosts() {
+    feedStore.state.postsLoading = true;
+    let result = await httpService.HttpService.http.get(`api/v1/Feed/GetAll`);
+    if (result) {
+      feedStore.state.posts = result.Data;
+      feedStore.state.postsLoading = false;
+    }
+    return result;
+  }
+  async createPost(payload) {
+    feedStore.state.createPostLoading = true;
+    let result = await httpService.HttpService.http.post(`api/v1/Feed/PostFeed`, payload);
+    if (result) {
+      feedStore.state.posts = [result.Data, ...feedStore.state.posts];
+      feedStore.state.createPostLoading = false;
+    }
+    return result;
+  }
+  async createPostComment(payload) {
+    feedStore.state.postIdLoading = payload.PostId;
+    let result = await httpService.HttpService.http.post(`api/v1/Feed/Comment`, payload);
+    if (result) {
+      feedStore.state.posts = feedStore.state.posts.map((item) => {
+        if (item.Id == result.Data.ClassFeedPostId) {
+          return Object.assign(Object.assign({}, item), { Comments: [...item.Comments, result.Data] });
+        }
+        return item;
+      });
+      feedStore.state.postIdLoading = null;
+    }
+    return result;
+  }
+}
+
+exports.FeedService = FeedService;
+exports.feedStore = feedStore;

package/dist/cjs/focus-visible-b0b07ba6.js

@@ -0,0 +1,76 @@
+'use strict';
+
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+const ION_FOCUSED = 'ion-focused';
+const ION_FOCUSABLE = 'ion-focusable';
+const FOCUS_KEYS = [
+  'Tab',
+  'ArrowDown',
+  'Space',
+  'Escape',
+  ' ',
+  'Shift',
+  'Enter',
+  'ArrowLeft',
+  'ArrowRight',
+  'ArrowUp',
+  'Home',
+  'End',
+];
+const startFocusVisible = (rootEl) => {
+  let currentFocus = [];
+  let keyboardMode = true;
+  const ref = rootEl ? rootEl.shadowRoot : document;
+  const root = rootEl ? rootEl : document.body;
+  const setFocus = (elements) => {
+    currentFocus.forEach((el) => el.classList.remove(ION_FOCUSED));
+    elements.forEach((el) => el.classList.add(ION_FOCUSED));
+    currentFocus = elements;
+  };
+  const pointerDown = () => {
+    keyboardMode = false;
+    setFocus([]);
+  };
+  const onKeydown = (ev) => {
+    keyboardMode = FOCUS_KEYS.includes(ev.key);
+    if (!keyboardMode) {
+      setFocus([]);
+    }
+  };
+  const onFocusin = (ev) => {
+    if (keyboardMode && ev.composedPath) {
+      const toFocus = ev.composedPath().filter((el) => {
+        if (el.classList) {
+          return el.classList.contains(ION_FOCUSABLE);
+        }
+        return false;
+      });
+      setFocus(toFocus);
+    }
+  };
+  const onFocusout = () => {
+    if (ref.activeElement === root) {
+      setFocus([]);
+    }
+  };
+  ref.addEventListener('keydown', onKeydown);
+  ref.addEventListener('focusin', onFocusin);
+  ref.addEventListener('focusout', onFocusout);
+  ref.addEventListener('touchstart', pointerDown);
+  ref.addEventListener('mousedown', pointerDown);
+  const destroy = () => {
+    ref.removeEventListener('keydown', onKeydown);
+    ref.removeEventListener('focusin', onFocusin);
+    ref.removeEventListener('focusout', onFocusout);
+    ref.removeEventListener('touchstart', pointerDown);
+    ref.removeEventListener('mousedown', pointerDown);
+  };
+  return {
+    destroy,
+    setFocus,
+  };
+};
+
+exports.startFocusVisible = startFocusVisible;

package/dist/cjs/framework-delegate-59a98abd.js

@@ -0,0 +1,111 @@
+'use strict';
+
+const helpers = require('./helpers-c2496722.js');
+
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+const attachComponent = async (delegate, container, component, cssClasses, componentProps, inline) => {
+  var _a;
+  if (delegate) {
+    return delegate.attachViewToDom(container, component, componentProps, cssClasses);
+  }
+  if (!inline && typeof component !== 'string' && !(component instanceof HTMLElement)) {
+    throw new Error('framework delegate is missing');
+  }
+  const el = typeof component === 'string' ? (_a = container.ownerDocument) === null || _a === void 0 ? void 0 : _a.createElement(component) : component;
+  if (cssClasses) {
+    cssClasses.forEach((c) => el.classList.add(c));
+  }
+  if (componentProps) {
+    Object.assign(el, componentProps);
+  }
+  container.appendChild(el);
+  await new Promise((resolve) => helpers.componentOnReady(el, resolve));
+  return el;
+};
+const detachComponent = (delegate, element) => {
+  if (element) {
+    if (delegate) {
+      const container = element.parentElement;
+      return delegate.removeViewFromDom(container, element);
+    }
+    element.remove();
+  }
+  return Promise.resolve();
+};
+const CoreDelegate = () => {
+  let BaseComponent;
+  let Reference;
+  const attachViewToDom = async (parentElement, userComponent, userComponentProps = {}, cssClasses = []) => {
+    var _a, _b;
+    BaseComponent = parentElement;
+    /**
+     * If passing in a component via the `component` props
+     * we need to append it inside of our overlay component.
+     */
+    if (userComponent) {
+      /**
+       * If passing in the tag name, create
+       * the element otherwise just get a reference
+       * to the component.
+       */
+      const el = typeof userComponent === 'string' ? (_a = BaseComponent.ownerDocument) === null || _a === void 0 ? void 0 : _a.createElement(userComponent) : userComponent;
+      /**
+       * Add any css classes passed in
+       * via the cssClasses prop on the overlay.
+       */
+      cssClasses.forEach((c) => el.classList.add(c));
+      /**
+       * Add any props passed in
+       * via the componentProps prop on the overlay.
+       */
+      Object.assign(el, userComponentProps);
+      /**
+       * Finally, append the component
+       * inside of the overlay component.
+       */
+      BaseComponent.appendChild(el);
+      await new Promise((resolve) => helpers.componentOnReady(el, resolve));
+    }
+    else if (BaseComponent.children.length > 0) {
+      // If there is no component, then we need to create a new parent
+      // element to apply the css classes to.
+      const el = (_b = BaseComponent.ownerDocument) === null || _b === void 0 ? void 0 : _b.createElement('div');
+      cssClasses.forEach((c) => el.classList.add(c));
+      // Move each child from the original template to the new parent element.
+      el.append(...BaseComponent.children);
+      // Append the new parent element to the original parent element.
+      BaseComponent.appendChild(el);
+    }
+    /**
+     * Get the root of the app and
+     * add the overlay there.
+     */
+    const app = document.querySelector('ion-app') || document.body;
+    /**
+     * Create a placeholder comment so that
+     * we can return this component to where
+     * it was previously.
+     */
+    Reference = document.createComment('ionic teleport');
+    BaseComponent.parentNode.insertBefore(Reference, BaseComponent);
+    app.appendChild(BaseComponent);
+    return BaseComponent;
+  };
+  const removeViewFromDom = () => {
+    /**
+     * Return component to where it was previously in the DOM.
+     */
+    if (BaseComponent && Reference) {
+      Reference.parentNode.insertBefore(BaseComponent, Reference);
+      Reference.remove();
+    }
+    return Promise.resolve();
+  };
+  return { attachViewToDom, removeViewFromDom };
+};
+
+exports.CoreDelegate = CoreDelegate;
+exports.attachComponent = attachComponent;
+exports.detachComponent = detachComponent;