@sprig-technologies/sprig-browser 2.19.7 → 2.20.0

package/dist/sprig-browser/index.d.ts

@@ -0,0 +1,168 @@
+import { InstallationMethod } from "../src/types/config";
+export declare class SprigAPI {
+    /**
+     * include external events emitted from Sprig
+     */
+    UPDATES: {
+        SDK_READY: import("../src/constants/sprigEvents").SprigEvent;
+        SURVEY_APPEARED: import("../src/constants/sprigEvents").SprigEvent;
+        SURVEY_CLOSED: import("../src/constants/sprigEvents").SprigEvent;
+        SURVEY_DIMENSIONS: import("../src/constants/sprigEvents").SprigEvent;
+        SURVEY_FADING_OUT: import("../src/constants/sprigEvents").SprigEvent;
+        SURVEY_HEIGHT: import("../src/constants/sprigEvents").SprigEvent;
+        SURVEY_PRESENTED: import("../src/constants/sprigEvents").SprigEvent;
+        SURVEY_LIFE_CYCLE: import("../src/constants/sprigEvents").SprigEvent;
+        SURVEY_WILL_CLOSE: import("../src/constants/sprigEvents").SprigEvent;
+        SURVEY_WILL_PRESENT: import("../src/constants/sprigEvents").SprigEvent;
+        CLOSE_SURVEY_ON_OVERLAY_CLICK: import("../src/constants/sprigEvents").SprigEvent;
+        VISITOR_ID_UPDATED: import("../src/constants/sprigEvents").SprigEvent;
+        DATA: {
+            DISMISS_REASONS: {
+                API: import("../src/constants/sprigEvents").DismissReason;
+                CLOSED: import("../src/constants/sprigEvents").DismissReason;
+                /**
+                 * Remove all listeners set on Sprig
+                 */
+                COMPLETE: import("../src/constants/sprigEvents").DismissReason;
+                PAGE_CHANGE: import("../src/constants/sprigEvents").DismissReason;
+                OVERRIDE: import("../src/constants/sprigEvents").DismissReason;
+            };
+            SURVEY_ID: import("../src/constants/sprigEvents").SprigEventData;
+        };
+    };
+    /**
+     * Triggers displaying specified survey. Does submit answers!
+     * @returns
+     */
+    displaySurvey(surveyId: number): void;
+    /**
+     * Triggers displaying specified survey template. Does not submit answers
+     */
+    previewSurvey(surveyTemplateId: string): void;
+    /**
+     * Triggers displaying specified survey. Does not submit answers
+     */
+    reviewSurvey(surveyId: number): void;
+    /**
+     * pauses api interactions
+     */
+    mute(): void;
+    /**
+     * restart api interactions
+     */
+    unmute(): void;
+    /**
+     * Manually dismiss an opened survey
+     */
+    dismissActiveSurvey(): void;
+    /**
+     * Set an arbitrary attribute on the visitor
+     */
+    setAttribute(attribute: string, value: string): void;
+    /**
+     * Set attributes on visitor
+     */
+    setAttributes(attributes: SprigAttributes): void;
+    /**
+     * Set identifiers and attributes on visitor
+     */
+    identifyAndSetAttributes(payload: {
+        anonymousID?: string;
+        attributes: SprigAttributes;
+        userID?: string;
+    }): void;
+    /**
+     * Remove attributes on visitor
+     */
+    removeAttributes(attributes: SprigAttributes): void;
+    /**
+     * Add a listener for an event defined in ulEvents
+     */
+    addListener(event: string, listener: SprigListener): void;
+    /**
+     * Remove a listener for an event defined in ulEvents
+     */
+    removeListener(event: string, listener: SprigListener): void;
+    /**
+     * Remove all listeners set on Sprig
+     */
+    removeAllListeners(): void;
+    /**
+     * Attach an email address to visitor
+     */
+    setEmail(email: string): void;
+    /**
+     * Attach a user id to the visitor
+     */
+    setUserId(userId: string): void;
+    /**
+     * Set a partner anonymous id for future requests.
+     */
+    setPartnerAnonymousId(partnerAnonymousId: string): void;
+    /**
+     * track an event to show survey if eligible
+     * @param eventName name of event to track
+     * @param properties event properties (optional)
+     * @param metadata event metadata (optional)
+     * @returns
+     */
+    track(eventName: string, properties?: Record<string, unknown>, metadata?: SprigMetadata): void;
+    /**
+     * optionally set userId and/or anonymousId, track an event to show survey if eligible
+     * @param payload
+     * @param payload.anonymousId anonymousId (optional)
+     * @param payload.eventName name of event to track
+     * @param payload.metadata event metadata (optional)
+     * @param payload.userId userId (optional)
+     * @returns
+     */
+    identifyAndTrack(payload: {
+        anonymousId?: string;
+        eventName: string;
+        metadata?: SprigMetadata;
+        userId?: string;
+    }): void;
+    /**
+     * @param styleString css string representing the customized styles
+     */
+    applyStyles(styleString: string): void;
+    /**
+      Set viewport dimensions, in int pixels. necessary if Sprig is installed in an iframe/component defaulting to 0 width and height.
+    */
+    setWindowDimensions(width: number, height: number): void;
+    /**
+     * logs out current visitor and associated ids
+     */
+    logoutUser(): void;
+    /**
+     * clears Sprig from window
+     */
+    teardown(): void;
+}
+declare type NpmConfig = {
+    envId?: string;
+    environmentId?: string;
+    installationMethod?: InstallationMethod;
+    path?: string;
+} & Partial<WindowSprig>;
+export declare const sprig: {
+    /**
+     * Sets up the sprig api and load the sprig sdk on document load
+     * @param config
+     * @returns an instance of the sprig api
+     */
+    configure: (config: NpmConfig) => import("../src/types/global").WindowSprig;
+};
+declare const _default: {
+    sprig: {
+        /**
+         * Sets up the sprig api and load the sprig sdk on document load
+         * @param config
+         * @returns an instance of the sprig api
+         */
+        configure: (config: NpmConfig) => import("../src/types/global").WindowSprig;
+    };
+    SprigAPI: typeof SprigAPI;
+    configure: (config: NpmConfig) => import("../src/types/global").WindowSprig;
+};
+export default _default;

package/dist/src/constants/css.d.ts

@@ -0,0 +1,43 @@
+export declare const APP_ID = "ul-app";
+export declare const enum CssConstant {
+    Caption = "ul-caption",
+    CardContainer = "ul-card__container",
+    CardMainContent = "ul-card-main-content",
+    Choice = "choice",
+    ChoiceCheckbox = "select-checkbox",
+    ChoiceGroup = "ul-card__choices",
+    ChoiceLabel = "select-label",
+    ChoiceLabelContainer = "choice-label-container",
+    ChoiceRadio = "select-radio",
+    ChoiceTextEntryContainer = "choice-text-entry-container",
+    ChoiceTextInput = "choice-text-input",
+    CloseButton = "close-btn",
+    CloseContainer = "close-container",
+    ConsentLegalNameInput = "ul-consent-legal__name-input",
+    CustomStyle = "ul-custom-style",
+    DesktopSuffix = "--desktop",
+    FadeInTransition = "fade-in-transition",
+    LikertNumber = "likert-number",
+    LikertSmiley = "likert-smiley",
+    LikertStar = "likert-star",
+    LoadingSpinner = "ul-loading-spinner",
+    LoadingSpinnerContainer = "ul-loading-spinner-container",
+    LoadingSpinnerFirst = "first",
+    LoadingSpinnerFourth = "fourth",
+    LoadingSpinnerSecond = "second",
+    LoadingSpinnerThird = "third",
+    MobileSuffix = "--mobile",
+    NPSNumber = "nps-number",
+    OpenTextInput = "ul-card-text__input",
+    QuestionHeader = "ul-question",
+    VideoCard = "ul-card--video",
+    CheckmarkButton = "ul-button-checkmark",
+    InactiveButton = "ul-button-inactive",
+    LeftAlignButton = "ul-button-left-align",
+    SubmitButtonDisabled = "submit-button-disabled"
+}
+export declare const DEFAULT_BORDER_COLOR = "#e6e6e6";
+export declare const DEFAULT_TRANSPARENT_COLOR = "#ffffff";
+export declare const ERROR_BORDER_COLOR = "#bd282a";
+export declare const MOBILE_MAX_WIDTH = 500;
+export declare const EMBED_MOBILE_MAX_WIDTH = 1030;

package/dist/src/constants/sprigEvents.d.ts

@@ -0,0 +1,62 @@
+export declare const enum DismissReason {
+    Closed = "close.click",
+    Complete = "survey.completed",
+    PageChange = "page.change",
+    API = "api",
+    Override = "override"
+}
+export declare enum SprigEvent {
+    SDKReady = "sdk.ready",
+    SurveyAppeared = "survey.appeared",
+    SurveyClosed = "survey.closed",
+    SurveyDimensions = "survey.dimensions",
+    SurveyFadingOut = "survey.fadingOut",
+    SurveyHeight = "survey.height",
+    SurveyPresented = "survey.presented",
+    SurveyLifeCycle = "survey.lifeCycle",
+    SurveyWillClose = "survey.willClose",
+    SurveyWillPresent = "survey.will.present",
+    CloseSurveyOnOverlayClick = "close.survey.overlayClick",
+    VisitorIDUpdated = "visitor.id.updated"
+}
+export declare const enum SprigEventData {
+    SurveyId = "survey.id"
+}
+export declare const EVENTS: {
+    SDK_READY: SprigEvent;
+    SURVEY_APPEARED: SprigEvent;
+    SURVEY_CLOSED: SprigEvent;
+    SURVEY_DIMENSIONS: SprigEvent;
+    SURVEY_FADING_OUT: SprigEvent;
+    SURVEY_HEIGHT: SprigEvent;
+    SURVEY_PRESENTED: SprigEvent;
+    SURVEY_LIFE_CYCLE: SprigEvent;
+    SURVEY_WILL_CLOSE: SprigEvent;
+    SURVEY_WILL_PRESENT: SprigEvent;
+    CLOSE_SURVEY_ON_OVERLAY_CLICK: SprigEvent;
+    VISITOR_ID_UPDATED: SprigEvent;
+    DATA: {
+        DISMISS_REASONS: {
+            API: DismissReason;
+            CLOSED: DismissReason;
+            COMPLETE: DismissReason;
+            PAGE_CHANGE: DismissReason;
+            OVERRIDE: DismissReason;
+        };
+        SURVEY_ID: SprigEventData;
+    };
+};
+export declare const enum InternalEventName {
+    VerifyViewVersion = "verify.view.version",
+    CurrentQuestion = "survey.question",
+    ViewPrototypeClick = "question.prototype.click",
+    ViewAgreementClick = "question.agreement.click",
+    RecordedTaskStart = "recorded.task.start",
+    RecordedTaskPermissionScreen = "recorded.task.permission.screen",
+    SurveyComplete = "survey.complete"
+}
+export declare const enum InternalEventData {
+    ViewVersion = "view.version",
+    QuestionId = "qid",
+    Props = "props"
+}

package/dist/src/constants/sprigRecordingEvents.d.ts

@@ -0,0 +1,40 @@
+export declare const enum MediaType {
+    Video = "video",
+    Audio = "audio",
+    Screen = "screen"
+}
+export declare const enum SprigRecordingEvent {
+    PermissionStatus = "permission.status",
+    AvPermission = "av.permission",
+    ScreenPermission = "screen.permission",
+    BeginRecording = "begin.recording",
+    StartTask = "start.task",
+    FinishTask = "finish.task"
+}
+export declare const enum TaskStatus {
+    Abandoned = "abandoned",
+    GivenUp = "given.up",
+    Completed = "completed"
+}
+export declare const enum SprigRecordingEventData {
+    PermissionDescriptors = "permission.descriptors",
+    PermissionStatusCallback = "permission.status.callback",
+    StreamReadyCallback = "stream.ready.callback",
+    StreamCanceledCallback = "stream.canceled.callback",
+    TaskCompleteCallback = "task.complete.callback",
+    TaskResponse = "task.response",
+    TaskStatus = "task.status",
+    RecordingMediaTypes = "recording.media.types",
+    StartRecordingCallback = "start.recording.callback",
+    PassthroughData = "passthrough.data",
+    CurrentIndex = "current.index",
+    UploadCallback = "upload.callback",
+    ProgressCallback = "progress.callback",
+    BeginCallback = "begin.callback"
+}
+export interface PassthroughData {
+    questionId: number;
+    surveyId: number;
+    visitorId: string | null;
+    responseGroupUid: UUID;
+}

package/dist/src/controller/OptimizelyIntegration.d.ts

@@ -0,0 +1,40 @@
+export declare const OPTIMIZELY_EVENT_PREFIX = "!optimizely_experiments_";
+/**
+ *
+ * @param state the object returned from optimizely getExperimentStates
+ * @returns simplified object with experiment id to variation name pairing
+ *
+ */
+export declare const extractExperimentState: (state: Record<string, {
+    variation: {
+        name: string;
+    };
+}>) => Record<string, string>;
+interface Experiment {
+    id: string;
+    variation?: string;
+}
+export declare class OptimizelyIntegration {
+    _optimizelyData: Record<string, string>;
+    /**
+     * @param data object containing experimentIds as keys and variation name as the value
+     * @example { environments: [ { id: 1, variation: 'Variation 1' } ] }
+     * @returns boolean if set action was successful
+     */
+    setOptimizelyExperiment(data: {
+        experiments: Experiment[];
+    }): boolean;
+    /**
+     *
+     * @returns all active experiments to variation
+     */
+    getAllOptimizelyExperiments(): Record<string, string>;
+    /**
+     * @returns the variation name associated to the experimentId the current user is bucketed in.
+     */
+    getOptimizelyVariationName(experimentId: string): string;
+    transformExperimentId(experimentId: string): string;
+    getAndSetWebOptimizelyExperiments(): boolean;
+}
+declare const optimizely: OptimizelyIntegration;
+export default optimizely;

package/dist/src/controller/Queue.d.ts

@@ -0,0 +1,18 @@
+export declare type QueueItem = string[] | (() => void);
+declare class SprigQueue {
+    paused: boolean;
+    queue: QueueItem[];
+    ul: WindowSprig;
+    constructor(ul: WindowSprig, queue: QueueItem[]);
+    flush(queue: QueueItem[]): void;
+    isPaused(): boolean;
+    pause(): void;
+    unpause(): void;
+    push(action: string[] | (() => void)): void;
+    perform(func: () => void): void | Promise<unknown>;
+    /**
+     * Removes all queued items
+     */
+    empty(): void;
+}
+export default SprigQueue;

package/dist/src/controller/controller.d.ts

@@ -0,0 +1,9 @@
+import { Config } from "../types/config";
+/**
+ * Initialize frame and bootstrap data
+ * @param config this is included in the compilation step (points to the default viewSDKURL)
+ * @param config.envId Environment Id
+ * @param config.path Frame script url
+ * @param [config.border] Border color
+ */
+export default function sprigInitializer(config?: Partial<Config>): void;

package/dist/src/controller/iframe.d.ts

@@ -0,0 +1,17 @@
+import { ProductConfig } from "../types/config";
+export declare const createContainer: () => void;
+export declare const removeContainer: (initiator?: unknown) => void;
+export declare const removeContainerOnClose: () => void;
+/**
+ * Create iframe
+ */
+export declare const createFrame: (productConfig: ProductConfig, useMobileStyling: boolean) => {
+    frameId: string;
+    contentWinDocHead: HTMLHeadElement | undefined;
+    contentWindow: Window | null;
+    hasOverlay: boolean;
+    iframe: HTMLIFrameElement & {
+        eventEmitter?: import("../helpers/eventEmitter").SprigEventEmitter | undefined;
+        setHeight?: ((height: number) => void) | undefined;
+    };
+};

package/dist/src/helpers/Deferred.d.ts

@@ -0,0 +1,9 @@
+declare class Deferred<T = unknown, R = unknown> {
+    payload: T;
+    promise: Promise<R>;
+    reject: (reason?: unknown) => void;
+    resolve: (value: R) => void;
+    constructor(payload: T);
+    resolveRequest(result: R): void;
+}
+export default Deferred;

package/dist/src/helpers/conflicting_widgets/index.d.ts

@@ -0,0 +1,4 @@
+export default class ConflictingWidgets {
+    static disable(): void;
+    static enable(): void;
+}

package/dist/src/helpers/conflicting_widgets/intercom.d.ts

@@ -0,0 +1,2 @@
+export declare const enable: () => void;
+export declare const disable: () => void;

package/dist/src/helpers/document.d.ts

@@ -0,0 +1,6 @@
+export declare const isTargetElement: (element: EventTarget | null) => element is HTMLElement;
+export declare const isTargetInputElement: (element: EventTarget | null) => element is HTMLInputElement;
+export declare const isTargetTextAreaElement: (element: EventTarget | null) => element is HTMLTextAreaElement;
+export declare const overrideStyles: (document: Document, styleString: string, nonce?: string) => void;
+export declare const calculateFrameHeight: (document: Document) => number;
+export declare const resetScrollPosition: (document: Document) => void;

package/dist/src/helpers/eventEmitter.d.ts

@@ -0,0 +1,85 @@
+import { StrictEventEmitter } from "strict-event-emitter";
+import { SprigEvent, InternalEventName, InternalEventData, DismissReason } from "../constants/sprigEvents";
+import { MediaType, PassthroughData, SprigRecordingEvent, SprigRecordingEventData } from "../constants/sprigRecordingEvents";
+import { AvPermission } from "../types/card";
+import { RecordedTaskResponseType } from "../view/cards/recordedTask/store";
+interface SprigEventMap {
+    [InternalEventName.CurrentQuestion]: (data: {
+        [InternalEventData.QuestionId]: number;
+        [InternalEventData.Props]: unknown;
+    }) => void;
+    [InternalEventName.RecordedTaskPermissionScreen]: () => void;
+    [InternalEventName.RecordedTaskStart]: () => void;
+    [InternalEventName.SurveyComplete]: () => void;
+    [InternalEventName.VerifyViewVersion]: (data: {
+        [InternalEventData.ViewVersion]: string;
+    }) => void;
+    [SprigEvent.CloseSurveyOnOverlayClick]: () => void;
+    [SprigEvent.SDKReady]: () => void;
+    [SprigEvent.SurveyAppeared]: () => void;
+    [SprigEvent.SurveyDimensions]: (data: {
+        contentFrameHeight: number;
+        contentFrameWidth: number;
+        name: string;
+    }) => void;
+    [SprigEvent.SurveyClosed]: (data: {
+        initiator?: unknown;
+        name: string;
+    }) => void;
+    [SprigEvent.SurveyFadingOut]: () => void;
+    [SprigEvent.SurveyHeight]: (data: {
+        name: string;
+        contentFrameHeight: number;
+    }) => void;
+    [SprigEvent.SurveyLifeCycle]: (data: {
+        state: string;
+    }) => void;
+    [SprigEvent.SurveyPresented]: (data: {
+        name: string;
+    }) => void;
+    [SprigEvent.SurveyWillClose]: (data: {
+        initiator: DismissReason;
+        name?: string;
+    }) => void;
+    [SprigEvent.SurveyWillPresent]: (data: {
+        name: string;
+        "survey.id": number;
+    }) => void;
+    [SprigEvent.VisitorIDUpdated]: (data: {
+        visitorId: string | null;
+    }) => void;
+    [SprigRecordingEvent.AvPermission]: (data: {
+        [SprigRecordingEventData.StreamCanceledCallback]: () => void;
+        [SprigRecordingEventData.StreamReadyCallback]: (avStream: MediaStream | null, captureStream?: MediaStream | null) => void;
+        [SprigRecordingEventData.PermissionDescriptors]: AvPermission[];
+    }) => void;
+    [SprigRecordingEvent.BeginRecording]: (data: {
+        [SprigRecordingEventData.RecordingMediaTypes]: MediaType[];
+        [SprigRecordingEventData.StartRecordingCallback]: (mediaRecordingUids: UUID[]) => void;
+    }) => void;
+    [SprigRecordingEvent.FinishTask]: (data: {
+        [SprigRecordingEventData.BeginCallback]: (mediaRecordingUid: UUID) => void;
+        [SprigRecordingEventData.CurrentIndex]: number;
+        [SprigRecordingEventData.PassthroughData]: PassthroughData;
+        [SprigRecordingEventData.ProgressCallback]: (mediaRecordingUid: UUID, data: {
+            detail: number;
+        }) => void;
+        [SprigRecordingEventData.TaskCompleteCallback]: (taskDurationMillisecond: number) => void;
+        [SprigRecordingEventData.TaskResponse]: RecordedTaskResponseType;
+        [SprigRecordingEventData.UploadCallback]: (mediaRecordingUid: UUID | null, successOrError: true | unknown) => void;
+    }) => void;
+    [SprigRecordingEvent.PermissionStatus]: (data: {
+        [SprigRecordingEventData.PermissionStatusCallback]: (avStream: MediaStream | undefined, hasVideoPermission: boolean, hasScreenPermission: boolean) => void;
+    }) => void;
+    [SprigRecordingEvent.ScreenPermission]: (data: {
+        [SprigRecordingEventData.StreamCanceledCallback]: () => void;
+        [SprigRecordingEventData.StreamReadyCallback]: (avStream: MediaStream | null, captureStream: MediaStream | null) => void;
+    }) => void;
+    [SprigRecordingEvent.StartTask]: () => void;
+}
+export declare type EventPayload = {
+    [Property in keyof SprigEventMap]: Parameters<SprigEventMap[Property]>[0];
+};
+export declare type SprigEventEmitter = StrictEventEmitter<SprigEventMap>;
+declare const eventEmitter: StrictEventEmitter<SprigEventMap>;
+export default eventEmitter;

package/dist/src/helpers/general.d.ts

@@ -0,0 +1,9 @@
+import { Config } from "../types/config";
+export declare const delay: (ms: number) => Promise<void>;
+/**
+ * Get true or false for whether to direct embed from platform headers
+ * @returns user meta information
+ */
+export declare const shouldDirectEmbed: ({ "userleap-platform": platform, }: Config["headers"]) => boolean;
+export declare const getClasses: (baseClass: string, useMobileStyling: boolean) => string[];
+export declare const getPlatformClass: (baseClass: string, platform: string) => string[];

package/dist/src/helpers/network.d.ts

@@ -0,0 +1,15 @@
+import { Config } from "../types/config";
+export declare const NETWORK_CONFIG: {
+    RATELIMIT_RESET_DEFAULT: number;
+};
+declare type Result = {
+    error?: Error;
+    ok?: boolean;
+    json?: any;
+    reportError?: boolean;
+    status?: number;
+} & Partial<Response>;
+export declare const killNetworkRequests: (reason?: string) => void;
+export declare function getHttpHeaders(Sprig?: Partial<WindowSprig>): Config["headers"];
+export declare const ulFetch: (url: string, options: RequestInit, attempt?: number, shouldDropOnRateLimit?: boolean, shouldRetryRequest?: boolean) => Promise<Result>;
+export {};