@screeb/sdk-vue 0.1.1

package/dist/es/index.mjs

@@ -0,0 +1,376 @@
+import { reactive, watch, inject } from 'vue';
+import * as Screeb from '@screeb/sdk-browser';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+var CONSTANTS = { version: "0.0.0-dev" };
+
+var log = function (level, message) {
+    var packageName = "[@screeb/vue-sdk]";
+    switch (level) {
+        case "info":
+            // eslint-disable-next-line no-console
+            console.log("".concat(packageName, " ").concat(message));
+            break;
+        case "warn":
+            // eslint-disable-next-line no-console
+            console.warn("".concat(packageName, " ").concat(message));
+            break;
+        case "error":
+            // eslint-disable-next-line no-console
+            console.error("".concat(packageName, " ").concat(message));
+            break;
+        default:
+            // eslint-disable-next-line no-console
+            console.log("".concat(packageName, " ").concat(message));
+    }
+};
+
+var isSSR = typeof window === "undefined";
+
+var SCREEB_PLUGIN_KEY = Symbol("screeb");
+var isInitialized = false;
+var ScreebPlugin = {
+    install: function (app, config) {
+        var _this = this;
+        var _a;
+        var reactiveConfig = reactive(config);
+        var ensureScreeb = function (functionName_1, callback_1) {
+            return __awaiter(this, arguments, void 0, function (functionName, callback, onlyLoaded) {
+                var shouldLoad, message, message;
+                var _a;
+                if (onlyLoaded === void 0) { onlyLoaded = false; }
+                return __generator(this, function (_b) {
+                    shouldLoad = (_a = reactiveConfig.shouldLoad) !== null && _a !== void 0 ? _a : true;
+                    if (!Screeb.isLoaded() && !shouldLoad) {
+                        message = "Screeb instance is not loaded because `shouldLoad` is set to `false` in `ScreebPlugin`";
+                        log("warn", message);
+                        return [2 /*return*/, Promise.reject(message)];
+                    }
+                    if (!isInitialized && !onlyLoaded) {
+                        message = [
+                            "\"".concat(functionName, "\" was called but Screeb has not been initialized yet. "),
+                            "Please call 'init' before calling '".concat(functionName, "' or "),
+                            "set 'autoInit' to true in the ScreebPlugin config.",
+                        ].join("");
+                        log("warn", message);
+                        return [2 /*return*/, Promise.reject(message)];
+                    }
+                    return [2 /*return*/, Promise.resolve(callback())];
+                });
+            });
+        };
+        var close = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!Screeb.isLoaded()) return [3 /*break*/, 2];
+                        return [4 /*yield*/, Screeb.close()];
+                    case 1:
+                        _a.sent();
+                        isInitialized = false;
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        }); };
+        var debug = function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ensureScreeb("debug", function () { return Screeb.debug(); })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        }); }); };
+        var eventTrack = function (eventName, eventProperties) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureScreeb("eventTrack", function () {
+                            return Screeb.eventTrack(eventName, eventProperties);
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        var identity = function (userId, userProperties) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureScreeb("identity", function () {
+                            return Screeb.identity(userId, userProperties);
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        var identityGet = function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ensureScreeb("identityGet", function () { return Screeb.identityGet(); })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        }); }); };
+        var identityGroupAssign = function (groupName, groupType, groupProperties) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureScreeb("identityGroupAssign", function () {
+                            return Screeb.identityGroupAssign(groupName, groupType, groupProperties);
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        var identityGroupUnassign = function (groupName, groupType) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureScreeb("identityGroupUnassign", function () {
+                            return Screeb.identityGroupUnassign(groupName, groupType);
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        var identityProperties = function (userProperties) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureScreeb("identityProperties", function () {
+                            return Screeb.identityProperties(userProperties);
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        var identityReset = function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ensureScreeb("identityReset", function () { return Screeb.identityReset(); })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        }); }); };
+        var init = function (websiteId, userId, userProperties, hooks, language) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureScreeb("init", function () {
+                            if (!isInitialized) {
+                                Screeb.init(websiteId, userId, userProperties, hooks, language);
+                                isInitialized = true;
+                            }
+                        }, true)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        var load = function (options) { return __awaiter(_this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!!Screeb.isLoaded()) return [3 /*break*/, 3];
+                        Screeb.load(__assign({ sdkName: "sdk-vue", sdkVersion: CONSTANTS.version }, options));
+                        if (!((_a = reactiveConfig.autoInit) !== null && _a !== void 0 ? _a : false)) return [3 /*break*/, 3];
+                        if (!reactiveConfig.websiteId) return [3 /*break*/, 2];
+                        return [4 /*yield*/, init(reactiveConfig.websiteId, reactiveConfig.userId, reactiveConfig.userProperties, reactiveConfig.hooks, reactiveConfig.language)];
+                    case 1:
+                        _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        log("warn", "autoInit is set to true, but no websiteId have been provided.");
+                        _b.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); };
+        var surveyClose = function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ensureScreeb("surveyClose", function () { return Screeb.surveyClose(); })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        }); }); };
+        var surveyStart = function (surveyId, distributionId, allowMultipleResponses, hiddenFields, hooks, language, selectors) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureScreeb("surveyStart", function () {
+                            return Screeb.surveyStart(surveyId, distributionId, allowMultipleResponses, hiddenFields, hooks, language, selectors);
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        var messageClose = function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ensureScreeb("messageClose", function () { return Screeb.messageClose(); })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        }); }); };
+        var messageStart = function (messageId_1) {
+            var args_1 = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args_1[_i - 1] = arguments[_i];
+            }
+            return __awaiter(_this, __spreadArray([messageId_1], args_1, true), void 0, function (messageId, allowMultipleResponses, hiddenFields, hooks, language) {
+                if (allowMultipleResponses === void 0) { allowMultipleResponses = true; }
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, ensureScreeb("messageStart", function () {
+                                return Screeb.messageStart(messageId, allowMultipleResponses, hiddenFields, hooks, language);
+                            })];
+                        case 1: return [2 /*return*/, _a.sent()];
+                    }
+                });
+            });
+        };
+        var sessionReplayStop = function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ensureScreeb("sessionReplayStop", function () { return Screeb.sessionReplayStop(); })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        }); }); };
+        var sessionReplayStart = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureScreeb("sessionReplayStart", function () {
+                            return Screeb.sessionReplayStart();
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        var targetingCheck = function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ensureScreeb("targetingCheck", function () { return Screeb.targetingCheck(); })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        }); }); };
+        var targetingDebug = function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ensureScreeb("targetingDebug", function () { return Screeb.targetingDebug(); })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        }); }); };
+        watch(function () { return reactiveConfig.userId; }, function (newId, oldId) {
+            if (!isInitialized)
+                return;
+            if (newId === oldId)
+                return;
+            if (newId) {
+                Screeb.identity(newId);
+            }
+            else {
+                Screeb.identityReset();
+            }
+        });
+        var context = {
+            close: close,
+            debug: debug,
+            eventTrack: eventTrack,
+            identity: identity,
+            identityGet: identityGet,
+            identityGroupAssign: identityGroupAssign,
+            identityGroupUnassign: identityGroupUnassign,
+            identityProperties: identityProperties,
+            identityReset: identityReset,
+            init: init,
+            load: load,
+            surveyClose: surveyClose,
+            surveyStart: surveyStart,
+            messageClose: messageClose,
+            messageStart: messageStart,
+            sessionReplayStop: sessionReplayStop,
+            sessionReplayStart: sessionReplayStart,
+            targetingCheck: targetingCheck,
+            targetingDebug: targetingDebug,
+        };
+        app.provide(SCREEB_PLUGIN_KEY, context);
+        if (!isSSR && ((_a = reactiveConfig.shouldLoad) !== null && _a !== void 0 ? _a : true)) {
+            load(reactiveConfig.options);
+        }
+    },
+};
+
+function useScreeb() {
+    var context = inject(SCREEB_PLUGIN_KEY);
+    if (!context) {
+        // eslint-disable-next-line no-console
+        console.warn("`useScreeb` must be called inside a component tree where ScreebPlugin is installed.");
+    }
+    return context;
+}
+
+export { SCREEB_PLUGIN_KEY, ScreebPlugin, useScreeb };
+CONSTANTS.version = '0.1.1'

package/dist/es/logger.d.ts

@@ -0,0 +1,3 @@
+type LogLevel = "info" | "error" | "warn";
+export declare const log: (level: LogLevel, message: string) => void;
+export {};

package/dist/es/plugin.d.ts

@@ -0,0 +1,4 @@
+import { InjectionKey, Plugin } from "vue";
+import { ScreebContextValues } from "./types";
+export declare const SCREEB_PLUGIN_KEY: InjectionKey<ScreebContextValues>;
+export declare const ScreebPlugin: Plugin;

package/dist/es/types.d.ts

@@ -0,0 +1,69 @@
+import { HooksInit, HooksMessageStart, HooksSurveyStart, PropertyRecord, ScreebIdentityGetReturn, ScreebOptions } from "@screeb/sdk-browser";
+/** Configuration for the ScreebPlugin */
+export type ScreebConfig = {
+    /** Your website/channel id. */
+    websiteId: string;
+    /** The unique identifier of your user. */
+    userId?: string;
+    /** The properties of your user. */
+    userProperties?: PropertyRecord;
+    /** Hooks to define callback for various Screeb events */
+    hooks?: HooksInit;
+    /** Force a specific language (e.g. 'en'). Default: browser language. */
+    language?: string;
+    /**
+     * Indicates if Screeb should be automatically loaded.
+     * Set to false to prevent the SDK from loading (e.g. in CI).
+     * @default true
+     */
+    shouldLoad?: boolean;
+    /**
+     * Indicates if Screeb should be automatically initialized.
+     * When true, `init` is called automatically with `websiteId` and `userId`.
+     * @default false
+     */
+    autoInit?: boolean;
+    /** Screeb tag initialization options — handle with care. */
+    options?: ScreebOptions;
+};
+export type CloseFunction = () => Promise<void>;
+export type DebugFunction = () => Promise<unknown>;
+export type EventTrackFunction = (eventName: string, eventProperties?: PropertyRecord) => Promise<unknown>;
+export type IdentityFunction = (userId: string, userProperties?: PropertyRecord) => Promise<unknown>;
+export type IdentityGetFunction = () => Promise<ScreebIdentityGetReturn>;
+export type IdentityGroupAssignFunction = (groupName: string, groupType?: string, groupProperties?: PropertyRecord) => Promise<unknown>;
+export type IdentityGroupUnassignFunction = (groupName: string, groupType?: string) => Promise<unknown>;
+export type IdentityPropertiesFunction = (userProperties: PropertyRecord) => Promise<unknown>;
+export type IdentityResetFunction = () => Promise<unknown>;
+export type InitFunction = (websiteId: string, userId?: string, userProperties?: PropertyRecord, hooks?: HooksInit, language?: string) => Promise<void>;
+export type LoadFunction = (options?: ScreebOptions) => Promise<void>;
+export type SurveyCloseFunction = () => Promise<unknown>;
+export type SurveyStartFunction = (surveyId: string, distributionId?: string, allowMultipleResponses?: boolean, hiddenFields?: PropertyRecord, hooks?: HooksSurveyStart, language?: string, selectors?: string | string[]) => Promise<unknown>;
+export type MessageCloseFunction = () => Promise<unknown>;
+export type MessageStartFunction = (messageId: string, allowMultipleResponses?: boolean, hiddenFields?: PropertyRecord, hooks?: HooksMessageStart, language?: string) => Promise<unknown>;
+export type SessionReplayStopFunction = () => Promise<unknown>;
+export type SessionReplayStartFunction = () => Promise<unknown>;
+export type TargetingCheckFunction = () => Promise<unknown>;
+export type TargetingDebugFunction = () => Promise<unknown>;
+/** All Screeb methods provided via `useScreeb()` */
+export type ScreebContextValues = {
+    close: CloseFunction;
+    debug: DebugFunction;
+    eventTrack: EventTrackFunction;
+    identity: IdentityFunction;
+    identityGet: IdentityGetFunction;
+    identityGroupAssign: IdentityGroupAssignFunction;
+    identityGroupUnassign: IdentityGroupUnassignFunction;
+    identityProperties: IdentityPropertiesFunction;
+    identityReset: IdentityResetFunction;
+    init: InitFunction;
+    load: LoadFunction;
+    surveyClose: SurveyCloseFunction;
+    surveyStart: SurveyStartFunction;
+    messageClose: MessageCloseFunction;
+    messageStart: MessageStartFunction;
+    sessionReplayStart: SessionReplayStartFunction;
+    sessionReplayStop: SessionReplayStopFunction;
+    targetingCheck: TargetingCheckFunction;
+    targetingDebug: TargetingDebugFunction;
+};

package/dist/es/utils.d.ts

@@ -0,0 +1 @@
+export declare const isSSR: boolean;

package/docs/.nojekyll

@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.