@coveo/atomic 3.50.0 → 3.52.0

package/dist/esm/_index.js

@@ -1,10 +1,30 @@
-import { c as closest } from './initialization-lit-stencil-common-utils-e7755434.js';
-export { M as MissingInterfaceParentError, f as initializeBindings } from './initialization-lit-stencil-common-utils-e7755434.js';
-import { b as buildCustomEvent } from './event-utils-8de63ec3.js';
-import { i as itemContext } from './stencil-result-template-decorators-9cbe1e1c.js';
-export { r as resultContext } from './stencil-result-template-decorators-9cbe1e1c.js';
+export * from '@coveo/atomic-legacy/item-decorators';
 import { buildInteractiveResult } from '@coveo/headless';
-import './index-3eb0b28e.js';
+
+function closest(element, selector) {
+    if (!element) {
+        return null;
+    }
+    if (element.matches(selector)) {
+        return element;
+    }
+    if (element.parentNode instanceof ShadowRoot) {
+        return closest(element.parentNode.host, selector);
+    }
+    return closest(element.parentElement, selector);
+}
+
+function buildCustomEvent(name, detail) {
+    return new CustomEvent(name, {
+        detail,
+        // Event will bubble up the DOM until it is caught
+        bubbles: true,
+        // Allows to verify if event is caught (cancelled). If it's not caught, it won't be initialized.
+        cancelable: true,
+        // Allows to compose Atomic components inside one another, event will go across DOM/Shadow DOM
+        composed: true,
+    });
+}
 
 class MissingParentError extends Error {
     constructor(elementName, parentName) {
@@ -39,22 +59,6 @@ function fetchProductContext(element) {
     return fetchItemContext(element, 'atomic-product');
 }
 
-/**
- * Retrieves `Product` on a rendered `atomic-product`.
- *
- * This method is useful for building custom product template elements, see [Create a Product List](https://docs.coveo.com/en/atomic/latest/cc-search/create-custom-components/native-components/#custom-product-template-component-example) for more information.
- *
- * You should use the method in the [`connectedCallback` lifecycle method](https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_custom_elements#using_the_lifecycle_callbacks).
- *
- * @param element - The element that the event is dispatched to, which must be the child of a rendered "atomic-product".
- * @returns A promise that resolves on initialization of the parent "atomic-product" element, or rejects when there is no parent "atomic-product" element.
- *
- * @deprecated should only be used for Stencil components. For Lit components, use `fetchProductContext` from \@/src/components/commerce/product-template-component-utils/context/fetch-product-context.ts
- */
-function productContext(element) {
-    return itemContext(element, 'atomic-product');
-}
-
 /**
  * Dispatches an event which retrieves the `SearchBoxSuggestionsBindings` on a configured parent search box.
  *
@@ -108,6 +112,76 @@ function elementHasQuery(el) {
     return !!el.query && el.query.trim() !== '';
 }
 
+function getWindow() {
+    return window;
+}
+function getInitQueueNamespace() {
+    if (!getWindow().initQueueNamespace) {
+        getWindow().initQueueNamespace = {
+            eventQueueMap: new Map(),
+            parentReadyMap: new Map(),
+        };
+    }
+    return getWindow().initQueueNamespace;
+}
+function getEventQueueMap() {
+    return getInitQueueNamespace().eventQueueMap;
+}
+function getParentReadyMap() {
+    return getInitQueueNamespace().parentReadyMap;
+}
+function isParentReady(parent) {
+    const parentReadyMap = getParentReadyMap();
+    return parentReadyMap.get(parent) || false;
+}
+function queueEventForParent(parent, event, element) {
+    const eventQueueMap = getEventQueueMap();
+    if (!eventQueueMap.has(parent)) {
+        eventQueueMap.set(parent, []);
+    }
+    eventQueueMap.get(parent).push({ event, element });
+}
+function enqueueOrDispatchInitializationEvent(parent, event, element) {
+    if (isParentReady(parent)) {
+        element.dispatchEvent(event);
+    }
+    else {
+        queueEventForParent(parent, event, element);
+    }
+}
+
+/**
+ * Retrieves `Bindings` or `CommerceBindings` on a configured parent interface.
+ * @param event - The element on which to dispatch the event, which must be the child of a configured Atomic container element.
+ * @returns A promise that resolves upon initialization of the parent container element, and rejects otherwise.
+ */
+function fetchBindings(element) {
+    return new Promise((resolve, reject) => {
+        const event = buildCustomEvent(initializeEventName, (bindings) => resolve(bindings));
+        const parent = closest(element, initializableElements.join(', '));
+        if (!parent) {
+            reject(new MissingInterfaceParentError(element.nodeName.toLowerCase()));
+            return;
+        }
+        enqueueOrDispatchInitializationEvent(parent, event, element);
+    });
+}
+class MissingInterfaceParentError extends Error {
+    constructor(elementName) {
+        super(`The "${elementName}" element must be the child of the following elements: ${initializableElements.join(', ')}`);
+    }
+}
+const initializableElements = [
+    'atomic-recs-interface',
+    'atomic-search-interface',
+    'atomic-commerce-interface',
+    'atomic-commerce-recommendation-interface',
+    'atomic-relevance-inspector',
+    'atomic-insight-interface',
+    'atomic-external',
+];
+const initializeEventName = 'atomic/initializeComponent';
+
 /**
  * Binds the logging of document
  * @returns An unbind function for the events
@@ -139,6 +213,6 @@ function bindLogDocumentOpenOnResult(engine, result, resultElement, selector) {
     };
 }
 
-export { bindLogDocumentOpenOnResult, dispatchSearchBoxSuggestionsEvent, elementHasNoQuery, elementHasQuery, fetchProductContext, productContext };
+export { MissingInterfaceParentError, bindLogDocumentOpenOnResult, dispatchSearchBoxSuggestionsEvent, elementHasNoQuery, elementHasQuery, fetchProductContext, fetchBindings as initializeBindings };
 
 //# sourceMappingURL=index.js.map

package/dist/esm/_loader.js

@@ -1,11 +1,10 @@
-import { b as bootstrapLazy } from './index-3eb0b28e.js';
-export { s as setNonce } from './index-3eb0b28e.js';
-import { g as globalScripts } from './app-globals-0f993ce5.js';
+import { g as globalScripts, b as bootstrapLazy } from './app-globals-c5b073da.js';
+export { s as setNonce } from './app-globals-c5b073da.js';
 
 const defineCustomElements = async (win, options) => {
   if (typeof window === 'undefined') return undefined;
   await globalScripts();
-  return bootstrapLazy([["atomic-ipx-refine-toggle",[[1,"atomic-ipx-refine-toggle",{"collapseFacetsAfter":[514,"collapse-facets-after"],"error":[32],"breadcrumbManagerState":[32],"searchStatusState":[32]}]]],["atomic-insight-generated-answer",[[1,"atomic-insight-generated-answer",{"withToggle":[4,"with-toggle"],"collapsible":[4],"maxCollapsedHeight":[2,"max-collapsed-height"],"answerConfigurationId":[1,"answer-configuration-id"],"fieldsToIncludeInCitations":[1,"fields-to-include-in-citations"],"disableCitationAnchoring":[4,"disable-citation-anchoring"],"generatedAnswerState":[32],"searchStatusState":[32],"error":[32],"copied":[32],"copyError":[32]},null,{"generatedAnswerState":["updateAnswerCollapsed"]}]]],["atomic-insight-result-action",[[0,"atomic-insight-result-action",{"icon":[1025],"tooltip":[1025],"tooltipOnClick":[1025,"tooltip-on-click"],"action":[1025],"error":[32]}]]],["atomic-insight-result-attach-to-case-action",[[0,"atomic-insight-result-attach-to-case-action",{"error":[32],"attachToCaseState":[32]}]]],["atomic-insight-result-children-template",[[1,"atomic-insight-result-children-template",{"conditions":[16],"ifDefined":[513,"if-defined"],"ifNotDefined":[513,"if-not-defined"],"mustMatch":[16],"mustNotMatch":[16],"error":[32],"getTemplate":[64]}]]],["atomic-insight-timeframe-facet",[[1,"atomic-insight-timeframe-facet",{"facetId":[1537,"facet-id"],"label":[513],"field":[513],"withDatePicker":[516,"with-date-picker"],"isCollapsed":[1540,"is-collapsed"],"headingLevel":[514,"heading-level"],"filterFacetCount":[516,"filter-facet-count"],"injectionDepth":[514,"injection-depth"],"dependsOn":[16],"sortCriteria":[513,"sort-criteria"],"facetState":[32],"facetForDatePickerState":[32],"filterState":[32],"searchStatusState":[32],"error":[32]},[[0,"atomic/dateInputApply","applyDateInput"]]]]],["atomic-ipx-recs-list",[[1,"atomic-ipx-recs-list",{"recommendation":[513],"display":[513],"density":[513],"imageSize":[513,"image-size"],"numberOfRecommendations":[514,"number-of-recommendations"],"numberOfRecommendationsPerPage":[514,"number-of-recommendations-per-page"],"label":[513],"headingLevel":[514,"heading-level"],"error":[32],"isAppLoaded":[32],"resultTemplateRegistered":[32],"templateHasError":[32],"currentPage":[32],"recommendationListState":[32],"setRenderFunction":[64],"previousPage":[64],"nextPage":[64]},null,{"numberOfRecommendationsPerPage":["watchNumberOfRecommendationsPerPage"]}]]],["atomic-stencil-facet-date-input",[[0,"atomic-stencil-facet-date-input",{"bindings":[16],"rangeGetter":[16],"rangeSetter":[16],"facetId":[1,"facet-id"],"label":[1],"min":[1],"max":[1],"start":[32],"end":[32]}]]],["atomic-ipx-refine-modal",[[1,"atomic-ipx-refine-modal",{"openButton":[1040],"isOpen":[1540,"is-open"],"collapseFacetsAfter":[514,"collapse-facets-after"],"querySummaryState":[32],"breadcrumbManagerState":[32],"error":[32],"interfaceDimensions":[32]},null,{"isOpen":["watchEnabled"]}]]]], options);
+  return bootstrapLazy([], options);
 };
 
 export { defineCustomElements };

package/dist/esm/app-globals-c5b073da.js

@@ -0,0 +1,481 @@
+const NAMESPACE = 'atomic';
+const BUILD = /* atomic */ { allRenderFn: true, appendChildSlotFix: false, asyncLoading: true, asyncQueue: false, attachStyles: true, cloneNodeFix: false, cmpDidLoad: false, cmpDidRender: false, cmpDidUnload: false, cmpDidUpdate: false, cmpShouldUpdate: false, cmpWillLoad: false, cmpWillRender: false, cmpWillUpdate: false, connectedCallback: false, constructableCSS: true, cssAnnotations: true, devTools: false, disconnectedCallback: false, element: false, event: false, experimentalScopedSlotChanges: false, experimentalSlotFixes: false, formAssociated: false, hasRenderFn: false, hostListener: false, hostListenerTarget: false, hostListenerTargetBody: false, hostListenerTargetDocument: false, hostListenerTargetParent: false, hostListenerTargetWindow: false, hotModuleReplacement: false, hydrateClientSide: false, hydrateServerSide: false, hydratedAttribute: false, hydratedClass: true, hydratedSelectorName: "hydrated", initializeNextTick: false, invisiblePrehydration: true, isDebug: false, isDev: false, isTesting: false, lazyLoad: true, lifecycle: false, lifecycleDOMEvents: false, member: false, method: false, mode: false, observeAttribute: false, profile: false, prop: false, propBoolean: false, propMutable: false, propNumber: false, propString: false, reflect: false, scoped: false, scopedSlotTextContentFix: false, scriptDataOpts: false, shadowDelegatesFocus: false, shadowDom: false, slot: false, slotChildNodesFix: false, slotRelocation: false, state: false, style: false, svg: false, taskQueue: true, transformTagName: false, updatable: false, vdomAttribute: false, vdomClass: false, vdomFunctional: false, vdomKey: false, vdomListener: false, vdomPropOrAttr: false, vdomRef: false, vdomRender: false, vdomStyle: false, vdomText: false, vdomXlink: false, watchCallback: false };
+
+/*
+ Stencil Client Platform v4.20.0 | MIT Licensed | https://stenciljs.com
+ */
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var hostRefs = /* @__PURE__ */ new WeakMap();
+var getHostRef = (ref) => hostRefs.get(ref);
+var registerHost = (hostElement, cmpMeta) => {
+  const hostRef = {
+    $flags$: 0,
+    $hostElement$: hostElement,
+    $cmpMeta$: cmpMeta,
+    $instanceValues$: /* @__PURE__ */ new Map()
+  };
+  {
+    hostRef.$onReadyPromise$ = new Promise((r) => hostRef.$onReadyResolve$ = r);
+    hostElement["s-p"] = [];
+    hostElement["s-rc"] = [];
+  }
+  return hostRefs.set(hostElement, hostRef);
+};
+var consoleError = (e, el) => (0, console.error)(e, el);
+
+// src/client/client-load-module.ts
+var cmpModules = /* @__PURE__ */ new Map();
+var loadModule = (cmpMeta, hostRef, hmrVersionId) => {
+  const exportName = cmpMeta.$tagName$.replace(/-/g, "_");
+  const bundleId = cmpMeta.$lazyBundleId$;
+  if (!bundleId) {
+    return void 0;
+  }
+  const module = cmpModules.get(bundleId) ;
+  if (module) {
+    return module[exportName];
+  }
+  /*!__STENCIL_STATIC_IMPORT_SWITCH__*/
+  return import(
+    /* @vite-ignore */
+    /* webpackInclude: /\.entry\.js$/ */
+    /* webpackExclude: /\.system\.entry\.js$/ */
+    /* webpackMode: "lazy" */
+    `./${bundleId}.entry.js${""}`
+  ).then((importedModule) => {
+    {
+      cmpModules.set(bundleId, importedModule);
+    }
+    return importedModule[exportName];
+  }, consoleError);
+};
+var HYDRATED_CSS = "{visibility:hidden}.hydrated{visibility:inherit}";
+var SLOT_FB_CSS = "slot-fb{display:contents}slot-fb[hidden]{display:none}";
+var win = typeof window !== "undefined" ? window : {};
+var doc = win.document || { head: {} };
+var plt = {
+  $flags$: 0,
+  $resourcesUrl$: "",
+  jmp: (h2) => h2(),
+  raf: (h2) => requestAnimationFrame(h2),
+  ael: (el, eventName, listener, opts) => el.addEventListener(eventName, listener, opts),
+  rel: (el, eventName, listener, opts) => el.removeEventListener(eventName, listener, opts),
+  ce: (eventName, opts) => new CustomEvent(eventName, opts)
+};
+var promiseResolve = (v) => Promise.resolve(v);
+var queuePending = false;
+var queueDomReads = [];
+var queueDomWrites = [];
+var queueTask = (queue, write) => (cb) => {
+  queue.push(cb);
+  if (!queuePending) {
+    queuePending = true;
+    if (write && plt.$flags$ & 4 /* queueSync */) {
+      nextTick(flush);
+    } else {
+      plt.raf(flush);
+    }
+  }
+};
+var consume = (queue) => {
+  for (let i2 = 0; i2 < queue.length; i2++) {
+    try {
+      queue[i2](performance.now());
+    } catch (e) {
+      consoleError(e);
+    }
+  }
+  queue.length = 0;
+};
+var flush = () => {
+  consume(queueDomReads);
+  {
+    consume(queueDomWrites);
+    if (queuePending = queueDomReads.length > 0) {
+      plt.raf(flush);
+    }
+  }
+};
+var nextTick = (cb) => promiseResolve().then(cb);
+var writeTask = /* @__PURE__ */ queueTask(queueDomWrites, true);
+
+// src/utils/query-nonce-meta-tag-content.ts
+function queryNonceMetaTagContent(doc2) {
+  var _a, _b, _c;
+  return (_c = (_b = (_a = doc2.head) == null ? void 0 : _a.querySelector('meta[name="csp-nonce"]')) == null ? void 0 : _b.getAttribute("content")) != null ? _c : void 0;
+}
+
+// src/utils/result.ts
+var result_exports = {};
+__export(result_exports, {
+  err: () => err,
+  map: () => map,
+  ok: () => ok,
+  unwrap: () => unwrap,
+  unwrapErr: () => unwrapErr
+});
+var ok = (value) => ({
+  isOk: true,
+  isErr: false,
+  value
+});
+var err = (value) => ({
+  isOk: false,
+  isErr: true,
+  value
+});
+function map(result, fn) {
+  if (result.isOk) {
+    const val = fn(result.value);
+    if (val instanceof Promise) {
+      return val.then((newVal) => ok(newVal));
+    } else {
+      return ok(val);
+    }
+  }
+  if (result.isErr) {
+    const value = result.value;
+    return err(value);
+  }
+  throw "should never get here";
+}
+var unwrap = (result) => {
+  if (result.isOk) {
+    return result.value;
+  } else {
+    throw result.value;
+  }
+};
+var unwrapErr = (result) => {
+  if (result.isErr) {
+    return result.value;
+  } else {
+    throw result.value;
+  }
+};
+var createTime = (fnName, tagName = "") => {
+  {
+    return () => {
+      return;
+    };
+  }
+};
+var uniqueTime = (key, measureText) => {
+  {
+    return () => {
+      return;
+    };
+  }
+};
+var emitEvent = (elm, name, opts) => {
+  const ev = plt.ce(name, opts);
+  elm.dispatchEvent(ev);
+  return ev;
+};
+
+// src/runtime/update-component.ts
+var attachToAncestor = (hostRef, ancestorComponent) => {
+  if (ancestorComponent && !hostRef.$onRenderResolve$ && ancestorComponent["s-p"]) {
+    ancestorComponent["s-p"].push(new Promise((r) => hostRef.$onRenderResolve$ = r));
+  }
+};
+var scheduleUpdate = (hostRef, isInitialLoad) => {
+  if (hostRef.$flags$ & 4 /* isWaitingForChildren */) {
+    hostRef.$flags$ |= 512 /* needsRerender */;
+    return;
+  }
+  attachToAncestor(hostRef, hostRef.$ancestorComponent$);
+  const dispatch = () => dispatchHooks(hostRef);
+  return writeTask(dispatch) ;
+};
+var dispatchHooks = (hostRef, isInitialLoad) => {
+  const elm = hostRef.$hostElement$;
+  const endSchedule = createTime("scheduleUpdate", hostRef.$cmpMeta$.$tagName$);
+  const instance = hostRef.$lazyInstance$ ;
+  if (!instance) {
+    throw new Error(
+      `Can't render component <${elm.tagName.toLowerCase()} /> with invalid Stencil runtime! Make sure this imported component is compiled with a \`externalRuntime: true\` flag. For more information, please refer to https://stenciljs.com/docs/custom-elements#externalruntime`
+    );
+  }
+  let maybePromise;
+  endSchedule();
+  return enqueue(maybePromise, () => updateComponent(hostRef, instance));
+};
+var enqueue = (maybePromise, fn) => isPromisey(maybePromise) ? maybePromise.then(fn).catch((err2) => {
+  console.error(err2);
+  fn();
+}) : fn();
+var isPromisey = (maybePromise) => maybePromise instanceof Promise || maybePromise && maybePromise.then && typeof maybePromise.then === "function";
+var updateComponent = async (hostRef, instance, isInitialLoad) => {
+  var _a;
+  const elm = hostRef.$hostElement$;
+  const endUpdate = createTime("update", hostRef.$cmpMeta$.$tagName$);
+  const rc = elm["s-rc"];
+  const endRender = createTime("render", hostRef.$cmpMeta$.$tagName$);
+  {
+    callRender(hostRef, instance);
+  }
+  if (rc) {
+    rc.map((cb) => cb());
+    elm["s-rc"] = void 0;
+  }
+  endRender();
+  endUpdate();
+  {
+    const childrenPromises = (_a = elm["s-p"]) != null ? _a : [];
+    const postUpdate = () => postUpdateComponent(hostRef);
+    if (childrenPromises.length === 0) {
+      postUpdate();
+    } else {
+      Promise.all(childrenPromises).then(postUpdate);
+      hostRef.$flags$ |= 4 /* isWaitingForChildren */;
+      childrenPromises.length = 0;
+    }
+  }
+};
+var callRender = (hostRef, instance, elm, isInitialLoad) => {
+  try {
+    instance = instance.render() ;
+    {
+      hostRef.$flags$ |= 2 /* hasRendered */;
+    }
+  } catch (e) {
+    consoleError(e, hostRef.$hostElement$);
+  }
+  return null;
+};
+var postUpdateComponent = (hostRef) => {
+  const tagName = hostRef.$cmpMeta$.$tagName$;
+  const elm = hostRef.$hostElement$;
+  const endPostUpdate = createTime("postUpdate", tagName);
+  const ancestorComponent = hostRef.$ancestorComponent$;
+  if (!(hostRef.$flags$ & 64 /* hasLoadedComponent */)) {
+    hostRef.$flags$ |= 64 /* hasLoadedComponent */;
+    {
+      addHydratedFlag(elm);
+    }
+    endPostUpdate();
+    {
+      hostRef.$onReadyResolve$(elm);
+      if (!ancestorComponent) {
+        appDidLoad();
+      }
+    }
+  } else {
+    endPostUpdate();
+  }
+  {
+    if (hostRef.$onRenderResolve$) {
+      hostRef.$onRenderResolve$();
+      hostRef.$onRenderResolve$ = void 0;
+    }
+    if (hostRef.$flags$ & 512 /* needsRerender */) {
+      nextTick(() => scheduleUpdate(hostRef));
+    }
+    hostRef.$flags$ &= ~(4 /* isWaitingForChildren */ | 512 /* needsRerender */);
+  }
+};
+var appDidLoad = (who) => {
+  {
+    addHydratedFlag(doc.documentElement);
+  }
+  nextTick(() => emitEvent(win, "appload", { detail: { namespace: NAMESPACE } }));
+};
+var addHydratedFlag = (elm) => {
+  var _a;
+  return elm.classList.add((_a = BUILD.hydratedSelectorName) != null ? _a : "hydrated") ;
+};
+
+// src/runtime/proxy-component.ts
+var proxyComponent = (Cstr, cmpMeta, flags) => {
+  return Cstr;
+};
+
+// src/runtime/initialize-component.ts
+var initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId) => {
+  let Cstr;
+  if ((hostRef.$flags$ & 32 /* hasInitializedComponent */) === 0) {
+    hostRef.$flags$ |= 32 /* hasInitializedComponent */;
+    const bundleId = cmpMeta.$lazyBundleId$;
+    if (bundleId) {
+      const CstrImport = loadModule(cmpMeta);
+      if (CstrImport && "then" in CstrImport) {
+        const endLoad = uniqueTime();
+        Cstr = await CstrImport;
+        endLoad();
+      } else {
+        Cstr = CstrImport;
+      }
+      if (!Cstr) {
+        throw new Error(`Constructor for "${cmpMeta.$tagName$}#${hostRef.$modeName$}" was not found`);
+      }
+      const endNewInstance = createTime("createInstance", cmpMeta.$tagName$);
+      try {
+        new Cstr(hostRef);
+      } catch (e) {
+        consoleError(e);
+      }
+      endNewInstance();
+    } else {
+      Cstr = elm.constructor;
+      const cmpTag = elm.localName;
+      customElements.whenDefined(cmpTag).then(() => hostRef.$flags$ |= 128 /* isWatchReady */);
+    }
+  }
+  const ancestorComponent = hostRef.$ancestorComponent$;
+  const schedule = () => scheduleUpdate(hostRef);
+  if (ancestorComponent && ancestorComponent["s-rc"]) {
+    ancestorComponent["s-rc"].push(schedule);
+  } else {
+    schedule();
+  }
+};
+var fireConnectedCallback = (instance) => {
+};
+
+// src/runtime/connected-callback.ts
+var connectedCallback = (elm) => {
+  if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0) {
+    const hostRef = getHostRef(elm);
+    const cmpMeta = hostRef.$cmpMeta$;
+    const endConnected = createTime("connectedCallback", cmpMeta.$tagName$);
+    if (!(hostRef.$flags$ & 1 /* hasConnected */)) {
+      hostRef.$flags$ |= 1 /* hasConnected */;
+      {
+        let ancestorComponent = elm;
+        while (ancestorComponent = ancestorComponent.parentNode || ancestorComponent.host) {
+          if (ancestorComponent["s-p"]) {
+            attachToAncestor(hostRef, hostRef.$ancestorComponent$ = ancestorComponent);
+            break;
+          }
+        }
+      }
+      {
+        initializeComponent(elm, hostRef, cmpMeta);
+      }
+    } else {
+      if (hostRef == null ? void 0 : hostRef.$lazyInstance$) ; else if (hostRef == null ? void 0 : hostRef.$onReadyPromise$) {
+        hostRef.$onReadyPromise$.then(() => fireConnectedCallback());
+      }
+    }
+    endConnected();
+  }
+};
+var disconnectInstance = (instance) => {
+};
+var disconnectedCallback = async (elm) => {
+  if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0) {
+    const hostRef = getHostRef(elm);
+    if (hostRef == null ? void 0 : hostRef.$lazyInstance$) ; else if (hostRef == null ? void 0 : hostRef.$onReadyPromise$) {
+      hostRef.$onReadyPromise$.then(() => disconnectInstance());
+    }
+  }
+};
+
+// src/runtime/bootstrap-lazy.ts
+var bootstrapLazy = (lazyBundles, options = {}) => {
+  var _a;
+  const endBootstrap = createTime();
+  const cmpTags = [];
+  const exclude = options.exclude || [];
+  const customElements2 = win.customElements;
+  const head = doc.head;
+  const metaCharset = /* @__PURE__ */ head.querySelector("meta[charset]");
+  const dataStyles = /* @__PURE__ */ doc.createElement("style");
+  const deferredConnectedCallbacks = [];
+  let appLoadFallback;
+  let isBootstrapping = true;
+  Object.assign(plt, options);
+  plt.$resourcesUrl$ = new URL(options.resourcesUrl || "./", doc.baseURI).href;
+  let hasSlotRelocation = false;
+  lazyBundles.map((lazyBundle) => {
+    lazyBundle[1].map((compactMeta) => {
+      const cmpMeta = {
+        $flags$: compactMeta[0],
+        $tagName$: compactMeta[1],
+        $members$: compactMeta[2],
+        $listeners$: compactMeta[3]
+      };
+      if (cmpMeta.$flags$ & 4 /* hasSlotRelocation */) {
+        hasSlotRelocation = true;
+      }
+      const tagName = cmpMeta.$tagName$;
+      const HostElement = class extends HTMLElement {
+        // StencilLazyHost
+        constructor(self) {
+          super(self);
+          this.hasRegisteredEventListeners = false;
+          self = this;
+          registerHost(self, cmpMeta);
+        }
+        connectedCallback() {
+          getHostRef(this);
+          if (!this.hasRegisteredEventListeners) {
+            this.hasRegisteredEventListeners = true;
+          }
+          if (appLoadFallback) {
+            clearTimeout(appLoadFallback);
+            appLoadFallback = null;
+          }
+          if (isBootstrapping) {
+            deferredConnectedCallbacks.push(this);
+          } else {
+            plt.jmp(() => connectedCallback(this));
+          }
+        }
+        disconnectedCallback() {
+          plt.jmp(() => disconnectedCallback(this));
+        }
+        componentOnReady() {
+          return getHostRef(this).$onReadyPromise$;
+        }
+      };
+      cmpMeta.$lazyBundleId$ = lazyBundle[0];
+      if (!exclude.includes(tagName) && !customElements2.get(tagName)) {
+        cmpTags.push(tagName);
+        customElements2.define(
+          tagName,
+          proxyComponent(HostElement)
+        );
+      }
+    });
+  });
+  if (cmpTags.length > 0) {
+    if (hasSlotRelocation) {
+      dataStyles.textContent += SLOT_FB_CSS;
+    }
+    {
+      dataStyles.textContent += cmpTags.sort() + HYDRATED_CSS;
+    }
+    if (dataStyles.innerHTML.length) {
+      dataStyles.setAttribute("data-styles", "");
+      const nonce = (_a = plt.$nonce$) != null ? _a : queryNonceMetaTagContent(doc);
+      if (nonce != null) {
+        dataStyles.setAttribute("nonce", nonce);
+      }
+      head.insertBefore(dataStyles, metaCharset ? metaCharset.nextSibling : head.firstChild);
+    }
+  }
+  isBootstrapping = false;
+  if (deferredConnectedCallbacks.length) {
+    deferredConnectedCallbacks.map((host) => host.connectedCallback());
+  } else {
+    {
+      plt.jmp(() => appLoadFallback = setTimeout(appDidLoad, 30));
+    }
+  }
+  endBootstrap();
+};
+
+// src/runtime/nonce.ts
+var setNonce = (nonce) => plt.$nonce$ = nonce;
+
+const globalScripts = () => {};
+
+export { bootstrapLazy as b, globalScripts as g, promiseResolve as p, setNonce as s };
+
+//# sourceMappingURL=app-globals-c5b073da.js.map