@screeb/sdk-react 0.1.4 → 0.1.6

package/dist/index.cjs.js

@@ -0,0 +1,364 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var Screeb = require('@screeb/sdk-browser');
+var React = require('react');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var Screeb__namespace = /*#__PURE__*/_interopNamespaceDefault(Screeb);
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+/******************************************************************************
+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 */
+
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+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 };
+    }
+}
+
+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 ScreebContext = React__namespace.createContext(undefined);
+
+/**
+ * Logs messages in the console with a corresponding urgency
+ *
+ * @param level the urgency of the message
+ * @param message the message to log in the console
+ */
+var log = function (level, message) {
+    var packageName = "[@screeb/react-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 isInitialized = false;
+var ScreebProvider = function (_a) {
+    var websiteId = _a.websiteId, userId = _a.userId, userProperties = _a.userProperties, hooks = _a.hooks, children = _a.children, _b = _a.shouldLoad, shouldLoad = _b === void 0 ? !isSSR : _b, _c = _a.autoInit, autoInit = _c === void 0 ? false : _c, options = _a.options, rest = __rest(_a, ["websiteId", "userId", "userProperties", "hooks", "children", "shouldLoad", "autoInit", "options"]);
+    var isLoaded = React__namespace.useRef(Screeb__namespace.isLoaded());
+    // Allow data-x attributes, see https://github.com/devrnt/react-use-screeb/issues/478
+    var invalidPropKeys = Object.keys(rest).filter(function (key) { return !key.startsWith("data-"); });
+    if (invalidPropKeys.length > 0) {
+        log("warn", [
+            "some invalid props were passed to ScreebProvider. ",
+            "Please check following props: ".concat(invalidPropKeys.join(", "), "."),
+        ].join(""));
+    }
+    var ensureScreeb = React__namespace.useCallback(
+    // eslint-disable-next-line no-unused-vars
+    function (functionName, callback, onlyLoaded) {
+        if (onlyLoaded === void 0) { onlyLoaded = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var message, message;
+            return __generator(this, function (_a) {
+                if (!Screeb__namespace.isLoaded() && !shouldLoad) {
+                    message = "Screeb instance is not loaded because `shouldLoad` is set to `false` in `ScreebProvider`";
+                    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 ScreebProvider.",
+                    ].join("");
+                    log("warn", message);
+                    return [2 /*return*/, Promise.reject(message)];
+                }
+                return [2 /*return*/, Promise.resolve(callback())];
+            });
+        });
+    }, [shouldLoad]);
+    var close = React__namespace.useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!isLoaded.current) return [3 /*break*/, 2];
+                    return [4 /*yield*/, Screeb__namespace.close()];
+                case 1:
+                    _a.sent();
+                    isLoaded.current = false;
+                    _a.label = 2;
+                case 2: return [2 /*return*/];
+            }
+        });
+    }); }, [isLoaded.current]);
+    var debug = React__namespace.useCallback(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, ensureScreeb("debug", function () { return Screeb__namespace.debug(); })];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    }); }); }, []);
+    var eventTrack = React__namespace.useCallback(function (eventName, eventProperties) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ensureScreeb("eventTrack", function () {
+                        return Screeb__namespace.eventTrack(eventName, eventProperties);
+                    })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }); }, []);
+    var identity = React__namespace.useCallback(function (userId, userProperties) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ensureScreeb("identity", function () {
+                        return Screeb__namespace.identity(userId, userProperties);
+                    })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }); }, []);
+    var identityGet = React__namespace.useCallback(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, ensureScreeb("identityGet", function () { return Screeb__namespace.identityGet(); })];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    }); }); }, []);
+    var identityGroupAssign = React__namespace.useCallback(function (groupName, groupType, groupProperties) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ensureScreeb("identityGroupAssign", function () {
+                        return Screeb__namespace.identityGroupAssign(groupName, groupType, groupProperties);
+                    })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }); }, []);
+    var identityGroupUnassign = React__namespace.useCallback(function (groupName, groupType) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ensureScreeb("identityGroupUnassign", function () {
+                        return Screeb__namespace.identityGroupUnassign(groupName, groupType);
+                    })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }); }, []);
+    var identityProperties = React__namespace.useCallback(function (userProperties) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ensureScreeb("identityProperties", function () {
+                        return Screeb__namespace.identityProperties(userProperties);
+                    })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }); }, []);
+    var identityReset = React__namespace.useCallback(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, ensureScreeb("identityReset", function () { return Screeb__namespace.identityReset(); })];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    }); }); }, []);
+    var init = React__namespace.useCallback(function (websiteId, userId, userProperties, hooks) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ensureScreeb("init", function () {
+                        if (!isInitialized) {
+                            Screeb__namespace.init(websiteId, userId, userProperties, hooks);
+                            isInitialized = true;
+                        }
+                    }, true)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); }, [ensureScreeb, websiteId, shouldLoad]);
+    var load = React__namespace.useCallback(function (options) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!!isLoaded.current) return [3 /*break*/, 3];
+                    Screeb__namespace.load(options);
+                    isLoaded.current = true;
+                    if (!autoInit) return [3 /*break*/, 3];
+                    if (!websiteId) return [3 /*break*/, 2];
+                    return [4 /*yield*/, init(websiteId, userId, userProperties, hooks)];
+                case 1:
+                    _a.sent();
+                    return [3 /*break*/, 3];
+                case 2:
+                    log("warn", "autoInit is set to true, but no websiteId have been provided.");
+                    _a.label = 3;
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); }, [isLoaded.current, autoInit]);
+    var surveyClose = React__namespace.useCallback(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, ensureScreeb("surveyClose", function () { return Screeb__namespace.surveyClose(); })];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    }); }); }, []);
+    var surveyStart = React__namespace.useCallback(function (surveyId, allowMultipleResponses, hiddenFields, hooks) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ensureScreeb("surveyStart", function () {
+                        return Screeb__namespace.surveyStart(surveyId, allowMultipleResponses, hiddenFields, hooks);
+                    })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }); }, []);
+    var targetingCheck = React__namespace.useCallback(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, ensureScreeb("targetingCheck", function () { return Screeb__namespace.targetingCheck(); })];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    }); }); }, []);
+    var targetingDebug = React__namespace.useCallback(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, ensureScreeb("targetingDebug", function () { return Screeb__namespace.targetingDebug(); })];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    }); }); }, []);
+    var providerValue = React__namespace.useMemo(function () { return ({
+        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,
+        targetingCheck: targetingCheck,
+        targetingDebug: targetingDebug,
+    }); }, [
+        close,
+        debug,
+        eventTrack,
+        identity,
+        identityGet,
+        identityGroupAssign,
+        identityGroupUnassign,
+        identityProperties,
+        identityReset,
+        init,
+        load,
+        surveyClose,
+        surveyStart,
+        targetingCheck,
+        targetingDebug,
+    ]);
+    if (!isSSR && shouldLoad) {
+        load(options);
+    }
+    return (jsxRuntime.jsx(ScreebContext.Provider, { value: providerValue, children: children }));
+};
+var useScreebContext = function () {
+    var context = React__namespace.useContext(ScreebContext);
+    if (context === undefined) {
+        // eslint-disable-next-line no-console
+        console.warn("`useScreeb` must be used within `ScreebProvider`.");
+    }
+    return context;
+};
+
+var useScreeb = function () {
+    return useScreebContext();
+};
+
+exports.ScreebProvider = ScreebProvider;
+exports.useScreeb = useScreeb;

package/dist/{es/index.js → index.es.js}

@@ -328,8 +328,8 @@ var ScreebProvider = function (_a) {
 var useScreebContext = function () {
     var context = React.useContext(ScreebContext);
     if (context === undefined) {
-        // eslint-disable-next-line quotes
-        throw new Error('"useScreeb" must be used within `ScreebProvider`.');
+        // eslint-disable-next-line no-console
+        console.warn("`useScreeb` must be used within `ScreebProvider`.");
     }
     return context;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@screeb/sdk-react",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Screeb's browser sdk, optimized for React.",
   "keywords": [
     "product discovery",
@@ -28,11 +28,20 @@
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "import": "./dist/es/index.js"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.es.js"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs.js"
+      }
     }
   },
-  "module": "dist/es/index.js",
-  "types": "dist/es/index.d.ts",
+  "module": "dist/index.es.js",
+  "main": "dist/index.cjs.js",
+  "jsnext:main": "dist/index.es.js",
+  "types": "dist/index.d.ts",
   "files": [
     "dist",
     "docs",
@@ -46,12 +55,12 @@
     "test": "echo '@TODO'"
   },
   "dependencies": {
-    "@screeb/sdk-browser": "^0.1.11"
+    "@screeb/sdk-browser": "^0.1.12"
   },
   "devDependencies": {
     "@screeb/eslint-config": "^0.1.6",
     "@screeb/sdk-browser": "^0.1.6",
-    "@screeb/typescript-config": "^0.1.6",
+    "@screeb/typescript-config": "^0.1.7",
     "@types/jest": "^29.5.5",
     "@types/node": "^20.8.4",
     "@types/react": "^18.2.28",