@screeb/sdk-react 0.1.5 → 0.1.7

package/dist/cjs/context.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import { ScreebContextValues } from "./types";
+declare const ScreebContext: React.Context<ScreebContextValues | undefined>;
+export default ScreebContext;

package/dist/cjs/index.d.ts

@@ -0,0 +1,3 @@
+export { ScreebProvider } from "./provider";
+export { useScreeb } from "./useScreeb";
+export * from "./types";

package/dist/cjs/index.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/cjs/logger.d.ts

@@ -0,0 +1,9 @@
+type LogLevel = "info" | "error" | "warn";
+/**
+ * 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
+ */
+export declare const log: (level: LogLevel, message: string) => void;
+export {};

package/dist/cjs/provider.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import { ScreebContextValues, ScreebProviderProps } from "./types";
+export declare const ScreebProvider: React.FC<React.PropsWithChildren<ScreebProviderProps>>;
+export declare const useScreebContext: () => ScreebContextValues;

package/dist/cjs/types.d.ts

@@ -0,0 +1,375 @@
+import { Hooks, PropertyRecord, ScreebIdentityGetReturn, ScreebOptions } from "@screeb/sdk-browser";
+/** Properties of Screeb provider */
+export type ScreebProps = {
+    /** 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 event */
+    hooks?: Hooks;
+};
+/**
+ * Shutdowns current Screeb session.
+ *
+ * @example
+ * ```ts
+ * const { close } = useScreeb();
+ *
+ * close();
+ * ```
+ */
+export type CloseFunction = () => Promise<void>;
+/**
+ * Prints the actual state information of Screeb tag.
+ *
+ * @example
+ * ```ts
+ * const { debug } = useScreeb();
+ *
+ * debug();
+ * // ******************* SCREEB SESSION DEBUG *********************
+ * // Screeb channel id: <UUID>
+ * // Screeb channel type: widget
+ * // Screeb respondent id: <UUID>
+ * // Screeb survey id: none
+ * // Screeb response id: none
+ * //
+ * // Screeb current session start: Thu May 04 2023 16:53:49 GMT+0200 (Central European Summer Time)
+ * // Screeb current session last activity: Thu May 04 2023 17:41:30 GMT+0200 (Central European Summer Time)
+ * //
+ * // Screeb targeting engine status: disabled
+ * // Screeb targeting engine: 3 surveys
+ * //
+ * // Detected platform: desktop
+ * // Detected locale: en-GB
+ * // Detected timezone: -120
+ * // **************************************************************
+ * ```
+ */
+export type DebugFunction = () => Promise<unknown>;
+/**
+ * Tracks a user event.
+ *
+ * @param eventName The event name.
+ * @param eventProperties The properties of your event.
+ * ```text Requirements:
+ *   - Property names must be limited to 128 characters
+ *   - No more than 1000 attributes
+ *   - Supported types for values: string, number, boolean and Date.
+ * ```
+ *
+ * @example
+ * ```ts
+ * const { eventTrack } = useScreeb();
+ *
+ * eventTrack(
+ *   "Product added to cart",
+ *   {
+ *     product_name: 'Red bike 2021',
+ *     category: 'sport',
+ *     color: 'red',
+ *     price: 299,
+ *     count: 1,
+ *     reference: '2CF093TG1',
+ *     delivery_method: 'UPS',
+ *     user_logged: false,
+ *     added_at: new Date(),
+ *   }
+ * );
+ * ```
+ */
+export type EventTrackFunction = (eventName: string, eventProperties?: PropertyRecord) => Promise<unknown>;
+/**
+ * Change the current user identity.
+ * Warning: Running surveys will be closed.
+ *
+ * @param userId The unique identifier of your user.
+ * @param userProperties The properties of your user.
+ * ```text Requirements:
+ *   - Property names must be limited to 128 characters
+ *   - No more than 1000 attributes
+ *   - Supported types for values: string, number, boolean and Date.
+ * ```
+ *
+ * @example
+ * ```ts
+ * const { identity } = useScreeb();
+ *
+ * identity(
+ *   "<your-user-id>",
+ *   {
+ *     firstname: '<user-firstname>',
+ *     lastname: '<user-lastname>',
+ *     plan: '<user-plan>',
+ *     last_seen_at: new Date(),
+ *     authenticated: true
+ *   }
+ * );
+ * ```
+ */
+export type IdentityFunction = (userId: string, userProperties?: PropertyRecord) => Promise<unknown>;
+/**
+ * Retrieves the current user identity.
+ *
+ * @example
+ * ```ts
+ * const { identityGet } = useScreeb();
+ *
+ * console.log(await identityGet());
+ * // {
+ * //   anonymous_id: "<UUID>",
+ * //   user_id: "<UUID>",
+ * //   session_id: "<UUID>",
+ * //   session_start: "2023-05-04T16:30:15.882Z",
+ * //   session_end: "2023-05-04T17:02:09.087Z",
+ * //   channel_id: "<UUID>",
+ * //   is_ready: true,
+ * // }
+ * ```
+ */
+export type IdentityGetFunction = () => Promise<ScreebIdentityGetReturn>;
+/**
+ * Assigns the current user to a group.
+ *
+ * @param groupName
+ * @param groupType
+ * @param groupProperties The properties of your user group.
+ * ```text Requirements:
+ *   - Property names must be limited to 128 characters
+ *   - No more than 1000 attributes
+ *   - Supported types for values: string, number, boolean and Date.
+ * ```
+ *
+ * @example
+ * ```ts
+ * const { identityGroupAssign } = useScreeb();
+ *
+ * identityGroupAssign(
+ *   'company',
+ *   'Apple',
+ *   {
+ *     address_line_1: 'Apple Campus',
+ *     address_line_2: '1 Infinite Loop',
+ *     city: 'Cupertino',
+ *     zipcode: 95014,
+ *     state: 'California',
+ *     country: 'United states',
+ *   }
+ * );
+ * ```
+ */
+export type IdentityGroupAssignFunction = (groupName: string, groupType?: string, groupProperties?: PropertyRecord) => Promise<unknown>;
+/**
+ * Unassigns the current user to a group.
+ *
+ * @param groupName The name of your user group.
+ * @param groupType The type of your user group.
+ *
+ * @example
+ * ```ts
+ * const { identityGroupUnassign } = useScreeb();
+ *
+ * identityGroupUnassign('company', 'Apple');
+ * ```
+ */
+export type IdentityGroupUnassignFunction = (groupName: string, groupType?: string) => Promise<unknown>;
+/**
+ * Adds properties to the current user identity.
+ *
+ * @param userProperties The properties of your user.
+ * ```text Requirements:
+ *   - Property names must be limited to 128 characters
+ *   - No more than 1000 attributes
+ *   - Supported types for values: string, number, boolean and Date.
+ * ```
+ *
+ * @example
+ * ```ts
+ * const { identityProperties } = useScreeb();
+ *
+ * // Set user properties
+ * identityProperties(
+ *   {
+ *     firstname: '<user-firstname>',
+ *     lastname: '<user-lastname>',
+ *     plan: '<user-plan>',
+ *     last_seen_at: new Date(),
+ *     authenticated: true
+ *   }
+ * );
+ *
+ * // Delete user property : set values to null
+ * identityProperties(
+ *   {
+ *     age: null,
+ *     company: null,
+ *     logged: true,
+ *   }
+ * );
+ * ```
+ */
+export type IdentityPropertiesFunction = (userProperties: PropertyRecord) => Promise<unknown>;
+/**
+ * Resets the current user identity.
+ * Warning: This command must be called only once, since it creates a new identity on Screeb side.
+ *
+ * @example
+ * ```ts
+ * const { identityReset } = useScreeb();
+ *
+ * identityReset();
+ * ```
+ */
+export type IdentityResetFunction = () => Promise<unknown>;
+/**
+ * Initializes Screeb tag.
+ *
+ * @param websiteId Your website/channel id.
+ * @param userId The unique identifier of your user.
+ * @param userProperties The properties of your user.
+ * ```text Requirements:
+ *   - Property names must be limited to 128 characters
+ *   - No more than 1000 attributes
+ *   - Supported types for values: string, number, boolean and Date
+ * ```
+ *
+ * @example
+ * ```ts
+ * const { init } = useScreeb();
+ *
+ * init(
+ *   "<your-website-id>",
+ *   "<your-user-id>",
+ *   {
+ *     firstname: '<user-firstname>',
+ *     lastname: '<user-lastname>',
+ *     plan: '<user-plan>',
+ *     last_seen_at: new Date(),
+ *     authenticated: true
+ *   }
+ * );
+ * ```
+ */
+export type InitFunction = (websiteId: string, userId?: string, userProperties?: PropertyRecord) => Promise<void>;
+/**
+ * Appends Screeb tag into your dom.
+ *
+ * @param options Screeb module options.
+ * @param options.window If you're running Screeb tag in an iframe, please set the inner window here.
+ * @param options.screebEndpoint Please don't do this.
+ *
+ * @example
+ * ```ts
+ * const { load } = useScreeb();
+ *
+ * load();
+ * ```
+ */
+export type LoadFunction = (options?: ScreebOptions) => Promise<void>;
+/**
+ * Interrupts a running survey.
+ *
+ * @example
+ * ```ts
+ * const { surveyClose } = useScreeb();
+ *
+ * surveyClose();
+ * ```
+ */
+export type SurveyCloseFunction = () => Promise<unknown>;
+/**
+ * Starts a survey by its ID.
+ *
+ * @example
+ * ```ts
+ * const { surveyStart } = useScreeb();
+ *
+ * surveyStart(
+ *   '<UUID>',
+ *   false,
+ *   {
+ *     color: "green",
+ *     article_id: 42
+ *   }
+ * );
+ * ```
+ */
+export type SurveyStartFunction = (surveyId: string, allowMultipleResponses: boolean, hiddenFields: PropertyRecord) => Promise<unknown>;
+/**
+ * Forces a targeting check.
+ *
+ * @example
+ * ```ts
+ * const { targetingCheck } = useScreeb();
+ *
+ * targetingCheck();
+ * ```
+ */
+export type TargetingCheckFunction = () => Promise<unknown>;
+/**
+ * Prints the current state of the targeting engine.
+ *
+ * @example
+ * ```ts
+ * const { targetingDebug } = useScreeb();
+ *
+ * console.log(await targetingDebug());
+ * // targeting ************ SCREEB TARGETING RULES DEBUG **************
+ * // Disabled surveys are not listed here.
+ * //
+ * // Screeb channel id: <UUID>
+ * // Screeb respondent id: <UUID>
+ * //
+ * // Survey <UUID>:
+ * // https://admin.screeb.app/org/last/survey/<UUID>/share
+ * //
+ * //   - Rule of type "Device type (desktop/mobile/tablet)": true 🟢
+ * //   - Rule of type "Multiple display": true 🟢
+ * //   - Rule of type "Capping per time between survey display on current respondent": true 🟢
+ * //   - Rule of type "User event count": false 🔴
+ * //   - Rule of type "Capping per respondent display count": false 🔴
+ * ```
+ */
+export type TargetingDebugFunction = () => Promise<unknown>;
+/** Screeb context API */
+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;
+    targetingCheck: TargetingCheckFunction;
+    targetingDebug: TargetingDebugFunction;
+};
+/** Properties of Screeb provider */
+export type ScreebProviderProps = {
+    /**
+     * Indicates if Screeb should be automatically loaded.
+     * This will ping to the Screeb servers.
+     *
+     * @remarks if `true`, 'load' does not need to be called manually. Can be used for multistaged environments
+     */
+    shouldLoad?: boolean;
+    /**
+     * Indicates if Screeb should be automatically initialized.
+     *
+     * @remarks if `true`, 'init' does not need to be called manually
+     * */
+    autoInit?: boolean;
+    /**
+     * Screeb tag initialization options.
+     *
+     * @remarks this is used is really particular cases, handle with care.
+     * */
+    options?: ScreebOptions;
+} & Partial<ScreebProps>;

package/dist/cjs/useScreeb.d.ts

@@ -0,0 +1 @@
+export declare const useScreeb: () => import("./types").ScreebContextValues;

package/dist/cjs/utils.d.ts

@@ -0,0 +1,7 @@
+export declare const isSSR: boolean;
+/**
+ * Removes object entries where the value equals to `undefined`
+ *
+ * @param obj
+ */
+export declare const removeUndefined: (obj: never) => never;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@screeb/sdk-react",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Screeb's browser sdk, optimized for React.",
   "keywords": [
     "product discovery",
@@ -25,13 +25,8 @@
   "author": "Screeb's frontend team",
   "sideEffects": false,
   "type": "module",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": {
-      "import": "./dist/es/index.js"
-    }
-  },
   "module": "dist/es/index.js",
+  "main": "dist/cjs/index.js",
   "types": "dist/es/index.d.ts",
   "files": [
     "dist",
@@ -46,12 +41,12 @@
     "test": "echo '@TODO'"
   },
   "dependencies": {
-    "@screeb/sdk-browser": "^0.1.11"
+    "@screeb/sdk-browser": "^0.1.13"
   },
   "devDependencies": {
     "@screeb/eslint-config": "^0.1.6",
     "@screeb/sdk-browser": "^0.1.6",
-    "@screeb/typescript-config": "^0.1.6",
+    "@screeb/typescript-config": "^0.1.8",
     "@types/jest": "^29.5.5",
     "@types/node": "^20.8.4",
     "@types/react": "^18.2.28",