@appcues/web-sdk 7.22.2 → 7.24.0

package/build/utils/dom.d.ts

@@ -0,0 +1,160 @@
+export function getRootNode($el: any): any;
+export function findUniqueElement(query: any, context?: Document): any;
+export function hasSize(el: any, computedStyle?: {}): boolean;
+export function getParentPadding(element: any): {
+    top: any;
+    left: any;
+};
+/**
+ * Calculates a set of position-related details about the element identified by
+ * the passed selector. It calculates the following proeprties:
+ *   - fixed - whether the element or a parent is fixed.
+ *   - zIndex - 1 higher than the zIndex of the targeted element's highest level
+ *              stacking context.
+ *   - element - the targeted element.
+ *   - boundingRect - with values for the `top`, `left`, `bottom`, `right` of
+ *                    the element (from getBoundingClientRect()), adjusted for
+ *                    page offsets and scrolling. This value is the equivalent
+ *                    of the position as if the element had a position of
+ *                    of 'absolute', unless it is fixed or has a fixed parent.
+ *   - relativeBoundingRect - with values for the `top`, `left`, `bottom`,
+ *                            `right` of the element relative to the viewport.
+ *   - viewport - with values for the `height` and `width` of the viewport.
+ *
+ * If no element is found or multiple are found an error object is generated.
+ *
+ * @param  {Element} el The element to calculate details for, or null if unknown.
+ *
+ * @param  {string|object[]} selector Selector of element to calculate position
+ *  details for, or an array of objects that have a "selector" key that is a
+ *  string
+ *
+ * @return {object} Position details object of the form:
+ *   {
+ *       fixed: true,
+ *       zIndex: 1,
+ *       element: $domNode,
+ *       boundingRect: {
+ *           top: 0,
+ *           left: 0,
+ *           bottom: 100,
+ *           right: 30
+ *       }
+ *       relativeBoundingRect: {
+ *           top: 10,
+ *           left: 0,
+ *           bottom: 110,
+ *           right: 30
+ *       },
+ *       viewport: {
+ *           height: 1000,
+ *           width: 1200
+ *       }
+ *   }
+ * Or in the case of an error:
+ *   {
+ *      error: true,
+ *      errorMessage: 'This is the error message.'
+ *   }
+ */
+export function calculatePositionDetails($el: any, selector: string | object[], context?: Document): object;
+/**
+ * Calculates the region of the rectangle (specified by the `height` and `width`
+ * params) that these coordinates fall within. The passed coordinates should be
+ * relative to the rectangle. The return value has two properties `xRegion` and
+ * `yRegion` that range from 0 to 3, depending on which quadrants of the
+ * rectangle the coordinates fall within:
+ *
+ *  +---+---+---+---+
+ *  |0,0|1,0|2,0|3,0|
+ *  +---+---+---+---+
+ *  |0,1|1,1|2,1|3,1|
+ *  +---+---+---+---+
+ *  |0,2|1,2|2,2|3,2|
+ *  +---+---+---+---+
+ *  |0,3|1,3|2,3|3,3|
+ *  +---+---+---+---+
+ *
+ * @param  {number} x X-coordinate relative to the rectangle.
+ * @param  {number} y Y-coordinate relative to the rectangle.
+ * @param  {number} width Width of the rectagle.
+ * @param  {number} height Height of the rectagle.
+ *
+ * @return {Object} Has two properties indicating x-region and y-region of the
+ *                  passed coordinates.
+ */
+export function calculateRegion(x: number, y: number, width: number, height: number): Object;
+export function getScrollDuration(target: any, current: any): number;
+export function getScrollablePageElement(doc: any): any;
+export function findScrollableParentElements(el: any, context: any): any[];
+export function calculateParentScrollTops(target: any, offsetFromBottomPercentage: any, parentElements: any, context: any): any;
+/**
+ * Checks if two position details objects, as returned from
+ * `calculatePositionDetails` are the same.
+ *
+ * @param  {object} a The first set of position details.
+ * @param  {object} b The second set of position details.
+ *
+ * @return {boolean} Whether the position details are the same.
+ */
+export function positionDetailsEqual(a: object, b: object): boolean;
+export function isElementAttached(el: any): any;
+/**
+ * Indicates if the given element is on top and visible at the coordinates
+ * specified, relative to the viewport. This excludes the hotspot beacon from
+ * this calculation, since that will technically be the element on top at the
+ * given point.
+ *
+ * @param  {number}  options.xOffset   the % x offset within the element
+ * @param  {number}  options.yOffset   the % y offset within the element
+ * @param  {Element}  options.element  the element to verify is on top and
+ *                                     visible
+ *
+ * @return {Boolean}                   true if on top and visible, else false
+ */
+export function isElementVisible({ xOffset, yOffset, element }: number): boolean;
+export function addClass($el: any, className: any): void;
+export function removeClass($el: any, className: any): void;
+export function isBodyReady(doc: any): any;
+export function onCSSReady(doc: any, url: any, callback: any): void;
+export function afterNextPaint(win: any, callback: any): void;
+export function eventListenerPromise(el: any, event: any, cond: any): {
+    listener: undefined;
+    promise: Promise<any>;
+};
+/**
+ * Attempt to focus an element with delayed retries. Due to iframe related
+ * timing issues, it's possible for the iframe to have been inserted/attached to
+ * the DOM but not focusable yet. Additionally, it's possible that the site
+ * already has focus trapping logic e.g. `material-ui` which is why we only
+ * attempt this a few times before conceding as to prevent any harmonic locks
+ * from occurring as each library fights to trap focus. Finally, it's possible
+ * that the element has been removed between the first focus attempt and next so
+ * we want to check that the element is still contained in the document before
+ * attempting the next focus, otherwise exiting earlier.
+ */
+export function focusElement($element: any, retries?: number): void;
+export function focusPreviouslyFocusedElement(previousActiveElement: any): void;
+/**
+ * Gets keyboard-focusable elements within a specified element
+ * @returns {Array}
+ */
+export function getKeyboardFocusableElements(element: any): any[];
+export function getForceHeaderFocusInstance(elementId?: string, forceFocus?: boolean): (vnode: any) => void;
+export function preventClickPropagating(event: any): void;
+export function getParent(el: any): any;
+/**
+ * Helper function to get event text content
+ *
+ * @param {Event} event - Event from handler
+ * @return {string} Text content of event target
+ */
+export const getTextContent: (...args: any[]) => any;
+export const _testExports: {
+    findUniqueElementFromSelector: typeof findUniqueElementFromSelector;
+    findUniqueElementFromSelectors: typeof findUniqueElementFromSelectors;
+} | null;
+declare function findUniqueElementFromSelector(selector: any, context: any): any;
+declare function findUniqueElementFromSelectors(selectors: any, context: any): any;
+export {};
+//# sourceMappingURL=dom.d.ts.map

package/build/utils/dom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/dom.js"],"names":[],"mappings":"AAuBA,2CAKC;AAyOD,uEAcC;AAED,8DAmBC;AA8HD;;;EAeC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,6DAhCY,MAAM,GAAC,MAAM,EAAE,uBAIf,MAAM,CA6HjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,mCARY,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,GAEN,MAAM,CAWjB;AAED,qEAOC;AAED,wDAiBC;AAyFD,2EA0CC;AAED,gIA0DC;AAWD;;;;;;;;GAQG;AACH,wCALY,MAAM,KACN,MAAM,GAEN,OAAO,CAgBlB;AAED,gDAGC;AAsKD;;;;;;;;;;;;GAYG;AACH,gEAPY,MAAM,WA2DjB;AAED,yDAWC;AAED,4DASC;AAED,2CAKC;AAED,oEAkBC;AAED,8DAMC;AAED;;;EAWC;AAED;;;;;;;;;;GAUG;AACH,oEAsBC;AAID,gFAcC;AAED;;;GAGG;AACH,kEAMC;AAUD,wFAOS,UAAK,UAqCb;AAED,0DAEC;AA9kBM,wCAqBN;AAigBD;;;;;GAKG;AACH,qDAA6E;AA2D7E;;;SAMW;AA7oCX,iFA4EC;AAMD,mFAoBC"}

package/build/utils/embed-grouping.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Extracts the inline trait configuration from an experience object.
+ *
+ * @param {Object} experience - Experience object with traits array
+ * @returns {Object|null} - Inline trait target config or null if not found
+ */
+export function getInlineTraitConfig(experience: Object): Object | null;
+/**
+ * Creates a unique identifier from selector and filters for grouping embeds.
+ *
+ * @param {string} selector - CSS selector string
+ * @param {Object} filters - Optional order and text filters
+ * @returns {string} - Unique key for this selector+filters combination
+ */
+export function createContainerKey(selector: string, filters: Object): string;
+/**
+ * Groups embed experiences by container target, returning first of each group.
+ *
+ * @param {Array} embedExperiences - Array of embed-type experiences
+ * @returns {Array} - Deduplicated array with first experience per container
+ */
+export function groupEmbedsByContainer(embedExperiences: any[]): any[];
+//# sourceMappingURL=embed-grouping.d.ts.map

package/build/utils/embed-grouping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embed-grouping.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/embed-grouping.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,iDAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAiBvB;AAED;;;;;;GAMG;AACH,6CAJW,MAAM,WACN,MAAM,GACJ,MAAM,CA6BlB;AAED;;;;;GAKG;AACH,uEA6BC"}

package/build/utils/escape.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Create escape keyup event listeners
+ *
+ * @param {boolean} condition - Whether we should bind listeners
+ * @param {function} callback - Callback to bind listeners
+ * @param {object} Bound event listeners
+ */
+export function createEscapeEventListeners(condition: boolean, callback: Function): {
+    addEscapeEventListener: (vnode: VNode) => void;
+    removeEscapeEventListener: (vnode: VNode) => void;
+};
+//# sourceMappingURL=escape.d.ts.map

package/build/utils/escape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"escape.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/escape.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,sDAJW,OAAO;oCAkBL,KAAK,KACJ,IAAI;uCAgCL,KAAK,KACJ,IAAI;EAsBjB"}

package/build/utils/evaluate-selector.d.ts

@@ -0,0 +1,4 @@
+export const SHADOW_ROOT_TOKEN: "|shadow-root|";
+export const IFRAME_ROOT_TOKEN: "|iframe|";
+export function evaluateSelectorAll(selector: any, context?: Document): any;
+//# sourceMappingURL=evaluate-selector.d.ts.map

package/build/utils/evaluate-selector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate-selector.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/evaluate-selector.js"],"names":[],"mappings":"AAAA,gCAAiC,eAAe,CAAC;AACjD,gCAAiC,UAAU,CAAC;AAErC,4EAwBN"}

package/build/utils/flow-performance.d.ts

@@ -0,0 +1,19 @@
+export function getTimingReport(requestId: any, stepType: any): {
+    api_response_duration: number;
+    time_to_attempt: number;
+    time_to_render: number;
+    css_load_time: number;
+    time_to_reveal: number;
+    time_to_show: number;
+    step_type: any;
+    request_id: any;
+    init_time?: number | undefined;
+} | null;
+export function recordInitTS(): void;
+export function recordRequestTS(requestId: any): void;
+export function recordResponseTS(requestId: any): void;
+export function recordAttemptTS(requestId: any): void;
+export function recordRenderTS(requestId: any): void;
+export function recordCSSLoadTS(requestId: any): void;
+export function recordShownTS(requestId: any): void;
+//# sourceMappingURL=flow-performance.d.ts.map

package/build/utils/flow-performance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-performance.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/flow-performance.js"],"names":[],"mappings":"AAuJA;;;;;;;;;;SA6CC;AA9GM,qCAAkD;AAKlD,sDAAwE;AAKxE,uDAC+B;AAK/B,sDAAwE;AAKxE,qDAAsE;AAKtE,sDAAoE;AAKpE,oDAAoE"}

package/build/utils/flow-selectors.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Returns a "selector" in the abstract sense, which we should think of as a
+ * collection of things describing an element on screen.
+ *
+ * @param  {Object} annotation
+ *
+ * @return {Array} A list of selector "options" for one annotation. Even though
+ *                 there are potentially many things in this list, we call it a
+ *                 single "selector" for an element, since these are all
+ *                 descriptors to help us select an element on screen.
+ */
+export function getSelectorForAnnotation(annotation?: Object): any[];
+export function isMultiStepFlow(flow: object): boolean;
+export const getFlowSteps: (...args: any[]) => any;
+export const getNumberOfSteps: (...args: any[]) => any;
+export const getStepChildren: (...args: any[]) => any;
+export const getStepChildNumber: (...args: any[]) => any;
+export const getStepChildByIndex: (...args: any[]) => any;
+/**
+ * Used to determine if a particular step contains a stepChild with
+ * the given ID.  Backwards compatible with legacy flow format.
+ *
+ * @param {Object} step
+ * @param {String} stepChildId
+ */
+export const getStepChildById: (...args: any[]) => any;
+export const areHotspotsSequential: (...args: any[]) => any;
+export const isActionDrivenTooltip: (...args: any[]) => any;
+export const isRedirectAction: (...args: any[]) => any;
+export const isWaitForPageAction: (...args: any[]) => any;
+export const isActionStep: (...args: any[]) => any;
+export const hasStandardLifecycleEvents: (...args: any[]) => any;
+export const getStepByIndex: (...args: any[]) => any;
+export const getStepFromFlow: (...args: any[]) => any;
+export const getStepNumber: (...args: any[]) => any;
+/**
+ * Given a stepChildId and a keyed object of Steps, returns the step
+ * which contains that child.
+ *
+ * @param {Object} steps
+ * @param {String} stepChildId
+ */
+export const getStepFromStepChildId: (...args: any[]) => any;
+/**
+ * Given the entirety of storedContent and a stepChildId, returns the flow
+ * that contains that child.  Backwards compatible with legacy flows.
+ *
+ * @param {Object} storedContent
+ * @param {String} stepChildId
+ */
+export const getFlowFromStepChildId: (...args: any[]) => any;
+//# sourceMappingURL=flow-selectors.d.ts.map

package/build/utils/flow-selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-selectors.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/flow-selectors.js"],"names":[],"mappings":"AA+KA;;;;;;;;;;GAUG;AACH,sDAPY,MAAM,SAsBjB;AA7LM,sCAJK,MAAM,GAEN,OAAO,CAGwB;AAE3C,mDAMO;AAEP,uDAMM;AAEN,sDAKO;AAEP,yDAQO;AAEP,0DAEG;AAEH;;;;;;GAMG;AACH,uDAMG;AAEH,4DAGE;AAEF,4DASU;AAEV,uDAKU;AAEV,0DAKU;AAEV,mDAGE;AAEF,iEAEE;AAEF,qDAcG;AAEH,sDAOG;AAEH,oDASO;AAEP;;;;;;GAMG;AAEH,6DAIG;AAEH;;;;;;GAMG;AAEH,6DASG"}

package/build/utils/generate-uuid.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @return {string} A RFC4122 version 4 compliant UUID.
+ *
+ * Taken from http://stackoverflow.com/a/8809472.
+ */
+export default function generateUUID(): string;
+//# sourceMappingURL=generate-uuid.d.ts.map

package/build/utils/generate-uuid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-uuid.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/generate-uuid.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wCAJY,MAAM,CAwBjB"}

package/build/utils/generated-properties.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Generates a set of "auto-properties" for the current user, taking any
+ * existing properties into account. For an "initial" generation of properties
+ * we'll do some special things, like incrementing page views no matter what and
+ * trying to use the document.referrer value to get the _lastPageUrl.
+ *
+ * @param  {Window} win The window with which to calculate the properties.
+ * @param  {boolean} initial Indicates if this should be considered the initial
+ *                           generation of these properties.
+ * @param  {object} existing The existing properties (if any).
+ *
+ * @return {object} The auto-generated properties.
+ */
+export function generateProperties(win: Window, initial: boolean, props?: {}): object;
+export function generateGroupProperties(): {
+    _lastSeenAt: number;
+};
+/**
+ * Filters down the set of passed properties to only those that are included in
+ * the WHITELISTED_PROPERTIES list.
+ *
+ * @param  {object} properties The set of properties to filter.
+ *
+ * @return {object} The filtered set of properties.
+ */
+export function filterGeneratedProperties(properties: object): object;
+//# sourceMappingURL=generated-properties.d.ts.map

package/build/utils/generated-properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generated-properties.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/generated-properties.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;GAYG;AACH,wCAPY,MAAM,WACN,OAAO,eAIP,MAAM,CA6FjB;AAED;;EAEC;AAED;;;;;;;GAOG;AACH,sDAJY,MAAM,GAEN,MAAM,CASjB"}

package/build/utils/handle-navigation.d.ts

@@ -0,0 +1,5 @@
+export function createHandleNavigation(waitForPendingEventsToClear?: () => Promise<void>): ({ type, experienceId, stepId, campaignId, tacticId, ...config }?: {
+    campaignId?: null | undefined;
+    tacticId?: null | undefined;
+}) => Promise<void>;
+//# sourceMappingURL=handle-navigation.d.ts.map

package/build/utils/handle-navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-navigation.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/handle-navigation.js"],"names":[],"mappings":"AAuBA,4FAGyC;;;CAOjC,mBA4EP"}

package/build/utils/humanize.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Turn a word or phrase into a simplified, machine-readable string.
+ * Taken from https://gist.github.com/mathewbyrne/1280286
+ * @param  {string} phrase    The string to convert.
+ * @return {string}           String.
+ */
+export function slugify(phrase: string): string;
+/**
+ * Turn an slug into a human-readable title.
+ * @param  {string} slug      The string to convert.
+ * @param  {string} separator Character dividing each part of the slug.
+ * @return {string}           Human-readable title.
+ */
+export function unslugify(slug: string, separator?: string): string;
+//# sourceMappingURL=humanize.d.ts.map

package/build/utils/humanize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"humanize.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/humanize.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,gCAHY,MAAM,GACN,MAAM,CAWjB;AAED;;;;;GAKG;AACH,gCAJY,MAAM,cACN,MAAM,GACN,MAAM,CAOjB"}

package/build/utils/iframes.d.ts

@@ -0,0 +1,3 @@
+export function isIFrame(el: any): boolean;
+export function getIframeParent(el: any): any;
+//# sourceMappingURL=iframes.d.ts.map

package/build/utils/iframes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iframes.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/iframes.js"],"names":[],"mappings":"AAAO,2CAA8C;AAE9C,8CAMN"}

package/build/utils/is.d.ts

@@ -0,0 +1,8 @@
+export default methods;
+declare namespace methods {
+    let array: (arg: any) => arg is any[];
+    function undefined(value: any): value is undefined;
+    function defined(value: any): boolean;
+    function inArray(a: any, obj: any): boolean;
+}
+//# sourceMappingURL=is.d.ts.map

package/build/utils/is.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/is.js"],"names":[],"mappings":";;;IAiCA,mDAEC;IAED,sCAEC;IAED,4CASC"}

package/build/utils/lazy-loading.d.ts

@@ -0,0 +1,2 @@
+export function injectScript(scriptName: any): Promise<any>;
+//# sourceMappingURL=lazy-loading.d.ts.map

package/build/utils/lazy-loading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-loading.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/lazy-loading.js"],"names":[],"mappings":"AAgBO,4DAqCN"}

package/build/utils/links.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Updates the `target` attribute of a vnode that will become an <a> tag and
+ * does not have the [data-step] attribute.
+ *
+ * @param  {VNode} vnode The VNode.
+ */
+export function correctLinkTarget(vnode: VNode): void;
+/**
+ * Binds the passed function to a 'click' event on the passed VNode, but
+ * still allows the link to be followed.
+ *
+ * @param {VNode} vnode The VNode to add a listener to.
+ * @param {function} onClick The function.
+ */
+export function bindLinkClick(vnode: VNode, onClick: Function): void;
+//# sourceMappingURL=links.d.ts.map

package/build/utils/links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/links.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,yCAFY,KAAK,QAMhB;AAED;;;;;;GAMG;AACH,qCAHW,KAAK,2BA6Df"}

package/build/utils/location.d.ts

@@ -0,0 +1,8 @@
+export function resolveUrl(win: any, url: any): any;
+export function navigate(win: any, url: any, tab: any): Promise<void>;
+/**
+ * If `urlOrPath` or `targetUrl` is undefined, it defaults to trailing slash
+ */
+export function doesLocationMatch(urlOrPath?: string, targetUrl?: string): boolean;
+export function getCurrentURL(): string;
+//# sourceMappingURL=location.d.ts.map

package/build/utils/location.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"location.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/location.js"],"names":[],"mappings":"AAGA,oDAUC;AAED,sEAiBC;AAgDD;;GAEG;AACH,mFAWC;AAED,wCAEC"}

package/build/utils/pending-experience-events.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Increment the pending-event count for an experience and mark that an
+ * activity update is in-flight.  Called from create-appcues.js each time
+ * the `sendEvent` callback fires.
+ */
+export function addPendingEvent(experienceId: any): void;
+/**
+ * Mark that an activity update is in-flight without incrementing the
+ * event-handler count.  Used for dispatches that only go through the
+ * activity pipeline (e.g. sendCustomEvent) and have no matching
+ * FINISHED_EVENT.
+ */
+export function markActivityPending(): void;
+/**
+ * Decrement the event-handler count for an experience.  Called by the
+ * watcher saga when FINISHED_EVENT fires.
+ */
+export function onFinishedEvent(experienceId: any): void;
+/**
+ * Mark that the activity saga has sent its batch.  Called by the watcher
+ * saga when SENT_ACTIVITY_UPDATE fires.
+ */
+export function onSentActivityUpdate(): void;
+/**
+ * Returns a Promise that resolves once there are no more pending events
+ * for the given experience — both the event-handler pipeline and the
+ * activity-update pipeline must be clear.  Resolves immediately if
+ * nothing is pending.
+ */
+export function waitForPendingEventsToClear(experienceId: any): Promise<any>;
+//# sourceMappingURL=pending-experience-events.d.ts.map

package/build/utils/pending-experience-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-experience-events.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/pending-experience-events.js"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,yDAGC;AAED;;;;;GAKG;AACH,4CAEC;AAED;;;GAGG;AACH,yDAWC;AAED;;;GAGG;AACH,6CAKC;AAED;;;;;GAKG;AACH,6EAqBC"}

package/build/utils/query.d.ts

@@ -0,0 +1,4 @@
+export function getTestFlowId(win: any): any;
+export function getPermalinkId(win: any, component?: string): any;
+export function removeQueryParam(url: any, component?: string): any;
+//# sourceMappingURL=query.d.ts.map

package/build/utils/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/query.js"],"names":[],"mappings":"AAiBA,6CAIC;AAED,kEAGC;AAED,oEAmBC"}

package/build/utils/render-contexts.d.ts

@@ -0,0 +1,6 @@
+export function isOverlayContent(content: any): any;
+export function processRenderContexts(contentList: any): {
+    contents: never[];
+    experiences: never[];
+};
+//# sourceMappingURL=render-contexts.d.ts.map

package/build/utils/render-contexts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-contexts.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/render-contexts.js"],"names":[],"mappings":"AAyDA,oDAEC;AAED;;;EAsEC"}

package/build/utils/selector-utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Helper function that takes a "getter" function for retrieving the specified
+ * data and wraps it in a try-catch, such that the default value is returned if
+ * there's an error retrieving the specified data.
+ *
+ * @param  {Function} getter The function to lookup the data in state.
+ * @param  {any type}        The default value to return in case of error. This
+ *                           defaults to null.
+ *
+ * @return The requested data or the default value.
+ */
+export function safeGet(getter: Function, def?: null): (...args: any[]) => any;
+//# sourceMappingURL=selector-utils.d.ts.map

package/build/utils/selector-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selector-utils.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/selector-utils.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wDACU,GAAG,WAAI,SAQhB"}

package/build/utils/show-powered-by.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns true if we should show the powered-by link.
+ *
+ * @param {object} settings Object with settings from the current state of the object
+ *
+ * @return {boolean} Indicates if powered-by link should be shown or not.
+ */
+export default function showPoweredBy(): boolean;
+//# sourceMappingURL=show-powered-by.d.ts.map

package/build/utils/show-powered-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"show-powered-by.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/show-powered-by.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,yCAFY,OAAO,CAIlB"}

package/build/utils/store.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Module provides a simple wrapper around browser Storage APIs.
+ */
+/**
+ * Set data in the specified browser Storage location.
+ *
+ * @param {string} storage The browser storage location (localStorage, sessionStorage, etc).
+ * @param {string} key     The key to store data under.
+ * @param {string} value   The value to store.
+ */
+export function set(storage: string, key: string, value: string): void;
+/**
+ * Get data from the specified browser Storage location.
+ *
+ * @param {string} storage The browser storage location (localStorage, sessionStorage, etc).
+ * @param {string} key     The key to store data under.
+ *
+ * @return {string} The value under the specified key.
+ */
+export function get(storage: string, key: string): string;
+export function remove(storage: any, key: any): void;
+export function removeWithPrefixKey(storage: any, prefix: any): void;
+//# sourceMappingURL=store.d.ts.map

package/build/utils/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/store.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;GAMG;AACH,6BAJW,MAAM,OACN,MAAM,SACN,MAAM,QAQhB;AAED;;;;;;;GAOG;AACH,6BALW,MAAM,OACN,MAAM,GAEL,MAAM,CAQjB;AAED,qDAMC;AACD,qEAWC"}

package/build/utils/temp-store.d.ts

@@ -0,0 +1,5 @@
+export function removeItem(key: any): void;
+export function hasItem(key: any): boolean;
+export function getItem(key: any): string | null;
+export function setItem(key: any, value: any, timeout: any): void;
+//# sourceMappingURL=temp-store.d.ts.map

package/build/utils/temp-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temp-store.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/temp-store.js"],"names":[],"mappings":"AAEA,2CAGC;AAED,2CAcC;AAED,iDAUC;AAED,kEAGC"}

package/build/utils/test-mode.d.ts

@@ -0,0 +1,3 @@
+export function removeTestInformation(): {};
+export function getCurrentTestUrl(): any;
+//# sourceMappingURL=test-mode.d.ts.map

package/build/utils/test-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-mode.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/test-mode.js"],"names":[],"mappings":"AAOA,4CA6BC;AAED,yCAoBC"}

package/build/utils/time.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the current time in milliseconds.
+ * @returns {number}
+ */
+export function getTimestamp(): number;
+//# sourceMappingURL=time.d.ts.map

package/build/utils/time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/time.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,gCAHa,MAAM,CAKlB"}

package/build/utils/trigger-content-changes.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Calls the passed `onContentChange` function with the passed `contentId` and
+ * the element returned by executing the passed `selector` on the passed `doc`
+ * document. It calls the fuction after the next paint and again after 200ms as
+ * backup.
+ *
+ * @param  {Document} doc           The Document that contains the element we
+ *                                  want to call the `onContentChange` function
+ *                                  with.
+ *
+ * @param  {string} contentId       The ID of the content to call the
+ *                                  `onContentChange` function with.
+ *
+ * @param  {[type]} selector        The selector to find the element we want to
+ *                                  call the `onContentChange` function with.
+ *
+ * @param  {[type]} onContentChange The function to call twice.
+ */
+export default function triggerContentChanges(doc: Document, contentId: string, selector: [type], onContentChange: [type]): void;
+//# sourceMappingURL=trigger-content-changes.d.ts.map

package/build/utils/trigger-content-changes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger-content-changes.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/trigger-content-changes.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,mDAZY,QAAQ,aAIR,MAAM,YAGN,CAAC,IAAI,CAAC,mBAGN,CAAC,IAAI,CAAC,QAmBjB"}

package/build/utils/url.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Removes trailing slashes from a URL to prevent double slashes when concatenating paths.
+ * @param {string} url - The URL to normalize
+ * @returns {string} The URL without trailing slashes
+ */
+export function removeTrailingSlash(url: string): string;
+//# sourceMappingURL=url.d.ts.map

package/build/utils/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../src/scripts/utils/url.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,yCAHW,MAAM,GACJ,MAAM,CAIlB"}