@upscopeio/react 1.0.4 → 2.2.137

package/README.md

@@ -0,0 +1 @@
+# Upscope for React

package/index.d.ts

@@ -0,0 +1,21 @@
+import { CobrowsingSdkConfiguration, Upscope } from "./sdk";
+
+type UpscopeProviderProps = {
+  enabled?: boolean;
+  children: React.ReactNode;
+} & CobrowsingSdkConfiguration;
+
+type UpscopeContext = {
+  Upscope: Upscope | undefined;
+  shortId: string | undefined;
+  getLookupCode: () => Promise<string | undefined>;
+  listen: (event: string, callback: (data: any) => void) => void;
+  reset: () => void;
+  isSharing: boolean;
+};
+
+export function useUpscope(): UpscopeContext;
+
+export const UpscopeProvider: React.FC<UpscopeProviderProps>;
+export const Masked: React.FC<{ children: React.ReactNode }>;
+export const NoRemoteControl: React.FC<{ children: React.ReactNode }>;

package/index.js

@@ -1,43 +1,359 @@
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-import UpscopeSDK from '@upscopeio/sdk';
-import { useEffect, useState } from 'react';
-const Upscope = function ({ children, ...props }) {
-    const [initiated, setInitiated] = useState(false);
-    const keys = Object.keys(props).sort((a, b) => a.localeCompare(b));
-    const values = keys.map((key) => props[key]);
-    useEffect(() => {
-        if (initiated) {
-            UpscopeSDK('updateConnection', props);
-        }
-        else {
-            UpscopeSDK('init', props);
-            setInitiated(true);
-        }
-    }, values);
-    return children;
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _objectWithoutProperties(source, excluded) {
+    if (source == null) return {};
+    var target = _objectWithoutPropertiesLoose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+var __generator = this && this.__generator || function(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    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(_)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
+        };
+    }
 };
-export default Upscope;
-export function Masked({ children }) {
-    useEffect(() => {
-        if (children) {
-            children.__upscopeMasked = true;
-            // @ts-ignore
-            for (const child of children) {
-                child.__upscopeMasked = true;
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState, createContext, useContext, useRef } from "react";
+import Upscope from "./sdk";
+var UpscopeContext = createContext({
+    Upscope: undefined,
+    shortId: undefined,
+    getLookupCode: function getLookupCode() {
+        return _asyncToGenerator(function() {
+            return __generator(this, function(_state) {
+                return [
+                    2,
+                    ""
+                ];
+            });
+        })();
+    },
+    listen: function(event, callback) {},
+    reset: function() {},
+    isSharing: false
+});
+export function useUpscope() {
+    return useContext(UpscopeContext);
+}
+export function UpscopeProvider(_param) {
+    var getLookupCode = function getLookupCode() {
+        return new Promise(function(resolve) {
+            if (!loaded || !enabled) {
+                return resolve(undefined);
+            }
+            Upscope("getLookupCode", function(lookupCode) {
+                resolve(lookupCode);
+            });
+        });
+    };
+    var listen = function listen(event, callback) {
+        Upscope("on", event, callback);
+    };
+    var reset = function reset() {
+        Upscope("reset", true);
+    };
+    var children = _param.children, enabled = _param.enabled, config = _objectWithoutProperties(_param, [
+        "children",
+        "enabled"
+    ]);
+    var _useState = _slicedToArray(useState(false), 2), loaded = _useState[0], setLoaded = _useState[1];
+    var _useState1 = _slicedToArray(useState(false), 2), sharing = _useState1[0], setSharing = _useState1[1];
+    var _useState2 = _slicedToArray(useState(undefined), 2), shortId = _useState2[0], setShortId = _useState2[1];
+    useEffect(function() {
+        if (enabled && !loaded) {
+            setLoaded(true);
+            Upscope("init", config);
+            Upscope("getShortId", function(shortId) {
+                setShortId(shortId);
+            });
+        } else if (!enabled && loaded) {
+            Upscope("reset", false);
+            setShortId(undefined);
+        } else if (enabled && loaded) {
+            Upscope("getShortId", function(shortId) {
+                setShortId(shortId);
+            });
+        }
+    }, [
+        enabled
+    ]);
+    useEffect(function() {
+        if (enabled && loaded) {
+            Upscope("updateConnection", config);
+        }
+    }, [
+        enabled,
+        loaded,
+        config
+    ]);
+    useEffect(function() {
+        if (loaded) {
+            Upscope("on", "sessionStart", function() {
+                setSharing(true);
+            });
+            Upscope("on", "sessionContinue", function() {
+                setSharing(true);
+            });
+            Upscope("on", "sessionEnd", function() {
+                setSharing(false);
+            });
+        }
+    }, [
+        loaded
+    ]);
+    return _jsx(UpscopeContext.Provider, {
+        value: {
+            Upscope: Upscope,
+            shortId: shortId,
+            getLookupCode: getLookupCode,
+            listen: listen,
+            reset: reset,
+            isSharing: sharing
+        },
+        children: children
+    });
+}
+export function Masked(param) {
+    var children = param.children;
+    var beforeRef = useRef(null);
+    var afterRef = useRef(null);
+    useEffect(function() {
+        if (beforeRef.current && afterRef.current) {
+            var nextSibling = beforeRef.current.nextSibling;
+            while(nextSibling && nextSibling !== afterRef.current){
+                nextSibling.dataset.upscopeMasked = true;
+                nextSibling = nextSibling.nextSibling;
             }
         }
-    }, [children]);
-    return (_jsx(_Fragment, { children: children }));
+    }, [
+        beforeRef,
+        afterRef,
+        children
+    ]);
+    return _jsxs(_Fragment, {
+        children: [
+            _jsx("script", {
+                ref: beforeRef
+            }),
+            children,
+            _jsx("script", {
+                ref: afterRef
+            })
+        ]
+    });
 }
-export function NoRemoteControl({ children }) {
-    useEffect(() => {
-        if (children) {
-            children.__upscopeNoRemoteControl = true;
-            // @ts-ignore
-            for (const child of children) {
-                child.__upscopeNoRemoteControl = true;
+export function NoRemoteControl(param) {
+    var children = param.children;
+    var beforeRef = useRef(null);
+    var afterRef = useRef(null);
+    useEffect(function() {
+        if (beforeRef.current && afterRef.current) {
+            var nextSibling = beforeRef.current.nextSibling;
+            while(nextSibling && nextSibling !== afterRef.current){
+                nextSibling.dataset.upscopeNoRemoteControl = true;
+                nextSibling = nextSibling.nextSibling;
             }
         }
-    }, [children]);
-    return (_jsx(_Fragment, { children: children }));
+    }, [
+        beforeRef,
+        afterRef,
+        children
+    ]);
+    return _jsxs(_Fragment, {
+        children: [
+            _jsx("script", {
+                ref: beforeRef
+            }),
+            children,
+            _jsx("script", {
+                ref: afterRef
+            })
+        ]
+    });
 }
+
+
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.js"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from \"react/jsx-runtime\";\nimport { useEffect, useState, createContext, useContext, useRef } from \"react\";\nimport Upscope from \"./sdk\";\nconst UpscopeContext = createContext({\n    Upscope: undefined,\n    shortId: undefined,\n    async getLookupCode() {\n        return \"\";\n    },\n    listen: (event, callback) => { },\n    reset: () => { },\n    isSharing: false,\n});\nexport function useUpscope() {\n    return useContext(UpscopeContext);\n}\nexport function UpscopeProvider({ children, enabled, ...config }) {\n    const [loaded, setLoaded] = useState(false);\n    const [sharing, setSharing] = useState(false);\n    const [shortId, setShortId] = useState(undefined);\n    useEffect(() => {\n        if (enabled && !loaded) {\n            setLoaded(true);\n            Upscope(\"init\", config);\n            Upscope(\"getShortId\", (shortId) => {\n                setShortId(shortId);\n            });\n        }\n        else if (!enabled && loaded) {\n            Upscope(\"reset\", false);\n            setShortId(undefined);\n        }\n        else if (enabled && loaded) {\n            Upscope(\"getShortId\", (shortId) => {\n                setShortId(shortId);\n            });\n        }\n    }, [enabled]);\n    useEffect(() => {\n        if (enabled && loaded) {\n            Upscope(\"updateConnection\", config);\n        }\n    }, [enabled, loaded, config]);\n    useEffect(() => {\n        if (loaded) {\n            Upscope(\"on\", \"sessionStart\", () => {\n                setSharing(true);\n            });\n            Upscope(\"on\", \"sessionContinue\", () => {\n                setSharing(true);\n            });\n            Upscope(\"on\", \"sessionEnd\", () => {\n                setSharing(false);\n            });\n        }\n    }, [loaded]);\n    function getLookupCode() {\n        return new Promise((resolve) => {\n            if (!loaded || !enabled) {\n                return resolve(undefined);\n            }\n            Upscope(\"getLookupCode\", (lookupCode) => {\n                resolve(lookupCode);\n            });\n        });\n    }\n    function listen(event, callback) {\n        Upscope(\"on\", event, callback);\n    }\n    function reset() {\n        Upscope(\"reset\", true);\n    }\n    return (_jsx(UpscopeContext.Provider, { value: {\n            Upscope,\n            shortId,\n            getLookupCode,\n            listen,\n            reset,\n            isSharing: sharing,\n        }, children: children }));\n}\nexport function Masked({ children }) {\n    const beforeRef = useRef(null);\n    const afterRef = useRef(null);\n    useEffect(() => {\n        if (beforeRef.current && afterRef.current) {\n            let nextSibling = beforeRef.current.nextSibling;\n            while (nextSibling && nextSibling !== afterRef.current) {\n                nextSibling.dataset.upscopeMasked = true;\n                nextSibling = nextSibling.nextSibling;\n            }\n        }\n    }, [beforeRef, afterRef, children]);\n    return (_jsxs(_Fragment, { children: [_jsx(\"script\", { ref: beforeRef }), children, _jsx(\"script\", { ref: afterRef })] }));\n}\nexport function NoRemoteControl({ children }) {\n    const beforeRef = useRef(null);\n    const afterRef = useRef(null);\n    useEffect(() => {\n        if (beforeRef.current && afterRef.current) {\n            let nextSibling = beforeRef.current.nextSibling;\n            while (nextSibling && nextSibling !== afterRef.current) {\n                nextSibling.dataset.upscopeNoRemoteControl = true;\n                nextSibling = nextSibling.nextSibling;\n            }\n        }\n    }, [beforeRef, afterRef, children]);\n    return (_jsxs(_Fragment, { children: [_jsx(\"script\", { ref: beforeRef }), children, _jsx(\"script\", { ref: afterRef })] }));\n}\n"]}

package/package.json

@@ -1,13 +1,11 @@
 {
   "name": "@upscopeio/react",
   "main": "index.js",
-  "dependencies": {
-    "@upscopeio/sdk": "1.0.4",
-    "react": "^18.2.0"
+  "type": "module",
+  "dependencies": {},
+  "peerDependencies": {
+    "react": "^16.2.0",
+    "react-dom": "^16.2.0"
   },
-  "devDependencies": {
-    "@types/react": "^18.2.14",
-    "typescript": "^5.1.6"
-  },
-  "version": "1.0.4"
+  "version": "2.2.137"
 }

package/sdk.d.ts

@@ -0,0 +1,159 @@
+type SubmitRating = {
+  userSessionRating?: number;
+  userAgentRating?: number;
+  userAgentFeedback?: string;
+};
+
+type CobrowsingSdkConfiguration = {
+  jsConfiguration?: boolean;
+  uniqueId?: null | string;
+  identities?: null | string | string[];
+  tags?: null | string | string[];
+  integrationIds?: null | string | string[];
+  agentPrompt?: string;
+  callName?: string;
+
+  // Automatic
+  version: string;
+  apiKey: string;
+  beta: boolean;
+  region: string | null;
+  readonly regionWhitelist: string[] | null;
+  dataEndpoint: string;
+  pageviewsEndpoint: string;
+  phoneEndpoint: string;
+  javascriptEndpoint: string;
+  storageImplementation: null | Storage;
+  proxyRedirectEndpoint: string;
+  requireAuthorizationForSession: boolean;
+  integrateWithLivechat: boolean;
+  liveChatRewrite: boolean;
+  grabIdentityFromLivechat: boolean;
+  showUpscopeLink: boolean;
+  cursorColor: string;
+  enlargeCursor: boolean;
+  showTerminateButton: boolean;
+  screenWakeLock: boolean;
+  useFingerprinting: boolean;
+  autoconnect: boolean;
+  trackConsole: boolean;
+  allowRemoteConsole: boolean;
+  allowRemoteClick: boolean;
+  allowRemoteScroll: boolean;
+  allowRemoteType: boolean;
+  allowAgentRedirect: boolean;
+  rewriteExternalLinks: boolean;
+  collectHistory: boolean;
+  consoleAllowed: boolean;
+  drawingsTtlMs: number;
+  enableLookupCodeOnKey: boolean;
+  lookupCodeKey: number;
+  lookupCodeKeyRepetitions: number;
+  lookupCodeKeyTitle: string;
+  lookupCodeKeyMessage: string;
+  lookupCodeElement: null | HTMLElement | string;
+  injectLookupCodeButton: boolean;
+  lookupCodeButtonPages: string[];
+  lookupCodeButtonStyle: string;
+  disconnectAfterSeconds: number;
+  proxyAssets: string[];
+  maskedElements: string[];
+  domChangesDelay: number;
+  ignoreBrowserSupport: boolean;
+  enableCanvases: boolean;
+  customCallController: null | ((callback: (accepted: boolean) => void) => void);
+  callPromptText: string;
+  callRingtone: string;
+  authorizationPromptTitle: string;
+  authorizationPromptMessage: string;
+  endOfScreenshareMessage: null | string;
+  callWaitMessage: string;
+  translationsYes: string;
+  translationsNo: string;
+  translationsOk: string;
+  translationsStopSession: string;
+  agentRequestButtonStyle: string;
+  agentRequestButtonTitle: string;
+  agentRequestButtonSubtitle: string;
+  agentRequestButtonRequestingTitle: string;
+  agentRequestButtonRequestingSubtitle: string;
+  agentRequestResultTitle: string;
+  agentRequestNotAvailableText: string;
+  agentRequestAcceptedText: string;
+  showAgentRequestButton: "always" | "when_available" | "never"; // One of: always / when_available / never
+  agentRequestButtonPages: string[];
+  callPopupFailedTitle: string;
+  callPopupFailedMessage: string;
+  callPopupNoInputTitle: string;
+  callPopupNoInputMessage: string;
+  callPopupNoOutputTitle: string;
+  callPopupNoOutputMessage: string;
+  callAudioAuthorizationFailedTitle: string;
+  callAudioAuthorizationFailedMessage: string;
+  unavailableAgentRequestRedirectImmediately: boolean;
+  unavailableAgentRequestRedirectTo: null | string;
+  fromProxy: boolean;
+  sfdcFieldLabel: string;
+  sfdcFieldId: string;
+  baseProxyUrl: string;
+  proxyDomain: string;
+  needsProxy: (url: string) => boolean;
+  onSessionRequest: (cb: (accepted: boolean) => void, requestingAgent: string | null) => void;
+  onSessionStart: () => void;
+  onSessionEnd: () => void;
+  onWaitingForCall: () => void;
+  onSessionContinue: () => void;
+  onConnection: null | (() => void);
+  maskElementMiddleware: (element: HTMLElement) => boolean;
+  noRemoteElements: string[];
+  allowRemoteMiddleware: (element: HTMLElement) => boolean;
+  styleSheetContentFromRules: (stylesheet: HTMLLinkElement | HTMLStyleElement) => boolean;
+};
+
+type SDKEvents = {
+  connection: undefined;
+  waitingForCall: undefined;
+  sessionStart: undefined;
+  callStart: undefined;
+  callAccepted: undefined;
+  agentRequestUpdate: ["pending" | "unavailable" | "canceled" | "accepted"];
+  newObserver: [string];
+  observerGone: [string];
+  agentsAvailable: undefined;
+  sessionContinue: undefined;
+  sessionEnd: undefined;
+  callEnd: undefined;
+  connectionReset: undefined;
+  sessionRequest: undefined;
+};
+
+type Instruction =
+  | ["init", Partial<CobrowsingSdkConfiguration>]
+  | ["reset"]
+  | ["connect"]
+  | ["cancelRequestAgent"]
+  | ["getShortId", (shortId: string) => void]
+  | ["getUserId", (shortId: string) => void] // Legacy version of getShortId
+  | ["getLookupCode", (code: string) => void]
+  | ["getWatchLink", (link: string) => void]
+  | ["logEvent", "success" | "error" | "info" | "warn" | "contact", string]
+  | ["newPageview"]
+  | ["on", ...(keyof SDKEvents)[], (event: any) => void]
+  | ["requestAgent"]
+  | ["reset", boolean]
+  | ["redirect", string]
+  | ["saveHistory"]
+  | ["stopSession"]
+  | [
+      "submitRating",
+      {
+        userSessionRating?: number;
+        userAgentRating?: number;
+        userAgentFeedback?: string;
+      },
+    ]
+  | ["updateConnection", Partial<CobrowsingSdkConfiguration>];
+
+type Upscope = (...instruction: Instruction) => void;
+
+export default function Upscope(...instruction: Instruction): void;

package/sdk.js

@@ -0,0 +1,71 @@
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+var loaded = false;
+function loadSDK(apiKey) {
+    var _x_parentNode;
+    if (typeof window.Upscope !== "undefined") {
+        loaded = true;
+        return;
+    }
+    var i = function i1() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        i.q.push(args);
+    };
+    i.q = [];
+    // The real Upscope implementation is loaded below
+    window.Upscope = i;
+    var s = document.createElement("script");
+    s.type = "text/javascript";
+    s.async = true;
+    s.src = "https://code.upscope.io/".concat(apiKey, ".js");
+    var x = document.getElementsByTagName("script")[0];
+    (_x_parentNode = x.parentNode) === null || _x_parentNode === void 0 ? void 0 : _x_parentNode.insertBefore(s, x);
+    loaded = true;
+}
+var _Upscope = function _Upscope() {
+    for(var _len = arguments.length, instruction = new Array(_len), _key = 0; _key < _len; _key++){
+        instruction[_key] = arguments[_key];
+    }
+    var _window;
+    if (!loaded) {
+        if (instruction[0] === "init") {
+            var config = instruction[1];
+            if (!(config === null || config === void 0 ? void 0 : config.apiKey)) {
+                throw new Error("API key not specified");
+            }
+            loadSDK(config.apiKey);
+        } else {
+            throw new Error("Upscope is not loaded");
+        }
+    }
+    return (_window = window).Upscope.apply(_window, _toConsumableArray(instruction));
+};
+export default _Upscope;
+
+
+//# sourceMappingURL=sdk.js.map

package/sdk.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["sdk.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAI,SAAS,KAAK;AAClB,SAAS,QAAQ,MAAM,EAAE;QAgBrB;IAfA,IAAI,OAAO,OAAO,OAAO,KAAK,aAAa;QACvC,SAAS,IAAI;QACb;IACJ,CAAC;IACD,IAAM,IAAI,SAAJ,KAAuB;QAAT,IAAA,IAAA,OAAA,UAAA,QAAA,AAAG,OAAH,UAAA,OAAA,OAAA,GAAA,OAAA,MAAA,OAAA;YAAG,KAAH,QAAA,SAAA,CAAA,KAAO;QAAD;QACtB,EAAE,CAAC,CAAC,IAAI,CAAC;IACb;IACA,EAAE,CAAC,GAAG,EAAE;IACR,kDAAkD;IAClD,OAAO,OAAO,GAAG;IACjB,IAAM,IAAI,SAAS,aAAa,CAAC;IACjC,EAAE,IAAI,GAAG;IACT,EAAE,KAAK,GAAG,IAAI;IACd,EAAE,GAAG,GAAG,AAAC,2BAAiC,OAAP,QAAO;IAC1C,IAAM,IAAI,SAAS,oBAAoB,CAAC,SAAS,CAAC,EAAE;IACpD,CAAA,gBAAA,EAAE,UAAU,cAAZ,2BAAA,KAAA,IAAA,cAAc,aAAa,GAAG;IAC9B,SAAS,IAAI;AACjB;AACA,IAAM,WAAW,SAAX,WAAqC;IAAhB,IAAA,IAAA,OAAA,UAAA,QAAA,AAAG,cAAH,UAAA,OAAA,OAAA,GAAA,OAAA,MAAA,OAAA;QAAG,YAAH,QAAA,SAAA,CAAA,KAAc;IAAD;QAa7B;IAZP,IAAI,CAAC,QAAQ;QACT,IAAI,WAAW,CAAC,EAAE,KAAK,QAAQ;YAC3B,IAAM,SAAS,WAAW,CAAC,EAAE;YAC7B,IAAI,CAAC,CAAA,mBAAA,oBAAA,KAAA,IAAA,OAAQ,MAAK,AAAC,GAAE;gBACjB,MAAM,IAAI,MAAM,yBAAyB;YAC7C,CAAC;YACD,QAAQ,OAAO,MAAM;QACzB,OACK;YACD,MAAM,IAAI,MAAM,yBAAyB;QAC7C,CAAC;IACL,CAAC;IACD,OAAO,CAAA,UAAA,QAAO,OAAO,CAAd,MAAA,SAAe,mBAAG;AAC7B;AACA,eAAe,SAAS","file":"sdk.js","sourcesContent":["let loaded = false;\nfunction loadSDK(apiKey) {\n    if (typeof window.Upscope !== \"undefined\") {\n        loaded = true;\n        return;\n    }\n    const i = function (...args) {\n        i.q.push(args);\n    };\n    i.q = [];\n    // The real Upscope implementation is loaded below\n    window.Upscope = i;\n    const s = document.createElement(\"script\");\n    s.type = \"text/javascript\";\n    s.async = true;\n    s.src = `https://code.upscope.io/${apiKey}.js`;\n    const x = document.getElementsByTagName(\"script\")[0];\n    x.parentNode?.insertBefore(s, x);\n    loaded = true;\n}\nconst _Upscope = function (...instruction) {\n    if (!loaded) {\n        if (instruction[0] === \"init\") {\n            const config = instruction[1];\n            if (!config?.apiKey) {\n                throw new Error(\"API key not specified\");\n            }\n            loadSDK(config.apiKey);\n        }\n        else {\n            throw new Error(\"Upscope is not loaded\");\n        }\n    }\n    return window.Upscope(...instruction);\n};\nexport default _Upscope;\n"]}

package/index.tsx

@@ -1,68 +0,0 @@
-import type {CobrowsingSdkConfiguration, Upscope} from '@upscopeio/sdk';
-import type {ReactNode} from 'react';
-import UpscopeSDK from '@upscopeio/sdk';
-import React, {useEffect, useState} from 'react';
-
-type Child = ReactNode & {
-  __upscopeMasked?: boolean;
-  __upscopeNoRemoteControl?: boolean;
-};
-
-type Children = {children: Child};
-
-type Props = Children & Partial<CobrowsingSdkConfiguration>;
-
-
-const Upscope: React.FC<Props> = function({children, ...props}: Props) {
-  const [initiated, setInitiated] = useState(false);
-  const keys = Object.keys(props).sort((a, b) => a.localeCompare(b)) as (keyof CobrowsingSdkConfiguration)[];
-  const values: unknown[] = keys.map((key: keyof CobrowsingSdkConfiguration) => props[key] as unknown);
-
-  useEffect(() => {
-    if (initiated) {
-      (UpscopeSDK as Upscope)('updateConnection', props);
-    } else {
-      (UpscopeSDK as Upscope)('init', props);
-      setInitiated(true);
-    }
-  }, values);
-
-  return children;
-};
-export default Upscope;
-
-
-export function Masked({children}: Children): ReactNode {
-  useEffect(() => {
-    if (children) {
-      children.__upscopeMasked = true;
-      // @ts-ignore
-      for (const child of children) {
-        (child as Child).__upscopeMasked = true;
-      }
-    }
-  }, [children]);
-  return (
-    <>
-      {children}
-    </>
-  );
-}
-
-
-export function NoRemoteControl({children}: Children): ReactNode {
-  useEffect(() => {
-    if (children) {
-      children.__upscopeNoRemoteControl = true;
-      // @ts-ignore
-      for (const child of children) {
-        (child as Child).__upscopeNoRemoteControl = true;
-      }
-    }
-  }, [children]);
-  return (
-    <>
-      {children}
-    </>
-  );
-}

package/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "esnext",
-    "jsx": "react-jsx",
-    "module": "esnext",
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "moduleResolution": "node",
-    "strict": true,
-    "skipLibCheck": true
-  }
-}