@eventop/sdk 1.0.8 → 1.0.9

package/dist/index.cjs

@@ -1,12 +1,12 @@
 'use strict';
 
-var react = require('react');
+var require$$0 = require('react');
 
 /**
  * Root context — holds the global feature registry.
  * Set by EventopAIProvider at the root of the app.
  */
-const EventopRegistryContext = /*#__PURE__*/react.createContext(null);
+const EventopRegistryContext = /*#__PURE__*/require$$0.createContext(null);
 
 /**
  * Feature scope context — set by EventopTarget.
@@ -15,14 +15,14 @@ const EventopRegistryContext = /*#__PURE__*/react.createContext(null);
  * the feature id. Also supports explicit feature="id" on EventopStep
  * for steps that live outside their parent EventopTarget in the tree.
  */
-const EventopFeatureScopeContext = /*#__PURE__*/react.createContext(null);
+const EventopFeatureScopeContext = /*#__PURE__*/require$$0.createContext(null);
 function useRegistry() {
-  const ctx = react.useContext(EventopRegistryContext);
+  const ctx = require$$0.useContext(EventopRegistryContext);
   if (!ctx) throw new Error('[EventopAI] Must be used inside <EventopAIProvider>.');
   return ctx;
 }
 function useFeatureScope() {
-  return react.useContext(EventopFeatureScopeContext); // null is fine — steps can declare feature explicitly
+  return require$$0.useContext(EventopFeatureScopeContext); // null is fine — steps can declare feature explicitly
 }
 
 /**
@@ -187,25 +187,290 @@ function createFeatureRegistry() {
   };
 }
 
+var jsxRuntime = {exports: {}};
+
+var reactJsxRuntime_production = {};
+
 /**
- * EventopProvider
+ * @license React
+ * react-jsx-runtime.production.js
  *
- * Drop this once at the root of your app.
- * Every EventopTarget and EventopStep anywhere in the tree will
- * register with this provider automatically.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
- * @example
- * <EventopProvider
- *   provider={myServerFetcher}
- *   appName="PixelCraft"
- *   assistantName="Pixel AI"
- *   suggestions={['Add a shadow', 'Export design']}
- *   theme={{ mode: 'dark', tokens: { accent: '#6366f1' } }}
- *   position={{ corner: 'bottom-right' }}
- * >
- *   <App />
- * </EventopProvider>
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
  */
+var hasRequiredReactJsxRuntime_production;
+function requireReactJsxRuntime_production() {
+  if (hasRequiredReactJsxRuntime_production) return reactJsxRuntime_production;
+  hasRequiredReactJsxRuntime_production = 1;
+  var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+    REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+  function jsxProd(type, config, maybeKey) {
+    var key = null;
+    void 0 !== maybeKey && (key = "" + maybeKey);
+    void 0 !== config.key && (key = "" + config.key);
+    if ("key" in config) {
+      maybeKey = {};
+      for (var propName in config) "key" !== propName && (maybeKey[propName] = config[propName]);
+    } else maybeKey = config;
+    config = maybeKey.ref;
+    return {
+      $$typeof: REACT_ELEMENT_TYPE,
+      type: type,
+      key: key,
+      ref: void 0 !== config ? config : null,
+      props: maybeKey
+    };
+  }
+  reactJsxRuntime_production.Fragment = REACT_FRAGMENT_TYPE;
+  reactJsxRuntime_production.jsx = jsxProd;
+  reactJsxRuntime_production.jsxs = jsxProd;
+  return reactJsxRuntime_production;
+}
+
+var reactJsxRuntime_development = {};
+
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredReactJsxRuntime_development;
+function requireReactJsxRuntime_development() {
+  if (hasRequiredReactJsxRuntime_development) return reactJsxRuntime_development;
+  hasRequiredReactJsxRuntime_development = 1;
+  "production" !== process.env.NODE_ENV && function () {
+    function getComponentNameFromType(type) {
+      if (null == type) return null;
+      if ("function" === typeof type) return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+      if ("string" === typeof type) return type;
+      switch (type) {
+        case REACT_FRAGMENT_TYPE:
+          return "Fragment";
+        case REACT_PROFILER_TYPE:
+          return "Profiler";
+        case REACT_STRICT_MODE_TYPE:
+          return "StrictMode";
+        case REACT_SUSPENSE_TYPE:
+          return "Suspense";
+        case REACT_SUSPENSE_LIST_TYPE:
+          return "SuspenseList";
+        case REACT_ACTIVITY_TYPE:
+          return "Activity";
+      }
+      if ("object" === typeof type) switch ("number" === typeof type.tag && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof) {
+        case REACT_PORTAL_TYPE:
+          return "Portal";
+        case REACT_CONTEXT_TYPE:
+          return type.displayName || "Context";
+        case REACT_CONSUMER_TYPE:
+          return (type._context.displayName || "Context") + ".Consumer";
+        case REACT_FORWARD_REF_TYPE:
+          var innerType = type.render;
+          type = type.displayName;
+          type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+          return type;
+        case REACT_MEMO_TYPE:
+          return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+        case REACT_LAZY_TYPE:
+          innerType = type._payload;
+          type = type._init;
+          try {
+            return getComponentNameFromType(type(innerType));
+          } catch (x) {}
+      }
+      return null;
+    }
+    function testStringCoercion(value) {
+      return "" + value;
+    }
+    function checkKeyStringCoercion(value) {
+      try {
+        testStringCoercion(value);
+        var JSCompiler_inline_result = !1;
+      } catch (e) {
+        JSCompiler_inline_result = true;
+      }
+      if (JSCompiler_inline_result) {
+        JSCompiler_inline_result = console;
+        var JSCompiler_temp_const = JSCompiler_inline_result.error;
+        var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+        JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0);
+        return testStringCoercion(value);
+      }
+    }
+    function getTaskName(type) {
+      if (type === REACT_FRAGMENT_TYPE) return "<>";
+      if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE) return "<...>";
+      try {
+        var name = getComponentNameFromType(type);
+        return name ? "<" + name + ">" : "<...>";
+      } catch (x) {
+        return "<...>";
+      }
+    }
+    function getOwner() {
+      var dispatcher = ReactSharedInternals.A;
+      return null === dispatcher ? null : dispatcher.getOwner();
+    }
+    function UnknownOwner() {
+      return Error("react-stack-top-frame");
+    }
+    function hasValidKey(config) {
+      if (hasOwnProperty.call(config, "key")) {
+        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+        if (getter && getter.isReactWarning) return false;
+      }
+      return void 0 !== config.key;
+    }
+    function defineKeyPropWarningGetter(props, displayName) {
+      function warnAboutAccessingKey() {
+        specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName));
+      }
+      warnAboutAccessingKey.isReactWarning = true;
+      Object.defineProperty(props, "key", {
+        get: warnAboutAccessingKey,
+        configurable: true
+      });
+    }
+    function elementRefGetterWithDeprecationWarning() {
+      var componentName = getComponentNameFromType(this.type);
+      didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."));
+      componentName = this.props.ref;
+      return void 0 !== componentName ? componentName : null;
+    }
+    function ReactElement(type, key, props, owner, debugStack, debugTask) {
+      var refProp = props.ref;
+      type = {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type: type,
+        key: key,
+        props: props,
+        _owner: owner
+      };
+      null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", {
+        enumerable: false,
+        get: elementRefGetterWithDeprecationWarning
+      }) : Object.defineProperty(type, "ref", {
+        enumerable: false,
+        value: null
+      });
+      type._store = {};
+      Object.defineProperty(type._store, "validated", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: 0
+      });
+      Object.defineProperty(type, "_debugInfo", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: null
+      });
+      Object.defineProperty(type, "_debugStack", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugStack
+      });
+      Object.defineProperty(type, "_debugTask", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugTask
+      });
+      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+      return type;
+    }
+    function jsxDEVImpl(type, config, maybeKey, isStaticChildren, debugStack, debugTask) {
+      var children = config.children;
+      if (void 0 !== children) if (isStaticChildren) {
+        if (isArrayImpl(children)) {
+          for (isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++) validateChildKeys(children[isStaticChildren]);
+          Object.freeze && Object.freeze(children);
+        } else console.error("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+      } else validateChildKeys(children);
+      if (hasOwnProperty.call(config, "key")) {
+        children = getComponentNameFromType(type);
+        var keys = Object.keys(config).filter(function (k) {
+          return "key" !== k;
+        });
+        isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
+        didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error('A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />', isStaticChildren, children, keys, children), didWarnAboutKeySpread[children + isStaticChildren] = true);
+      }
+      children = null;
+      void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
+      hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
+      if ("key" in config) {
+        maybeKey = {};
+        for (var propName in config) "key" !== propName && (maybeKey[propName] = config[propName]);
+      } else maybeKey = config;
+      children && defineKeyPropWarningGetter(maybeKey, "function" === typeof type ? type.displayName || type.name || "Unknown" : type);
+      return ReactElement(type, children, maybeKey, getOwner(), debugStack, debugTask);
+    }
+    function validateChildKeys(node) {
+      isValidElement(node) ? node._store && (node._store.validated = 1) : "object" === typeof node && null !== node && node.$$typeof === REACT_LAZY_TYPE && ("fulfilled" === node._payload.status ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+    }
+    function isValidElement(object) {
+      return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    var React = require$$0,
+      REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+      REACT_PORTAL_TYPE = Symbol.for("react.portal"),
+      REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
+      REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
+      REACT_PROFILER_TYPE = Symbol.for("react.profiler"),
+      REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
+      REACT_CONTEXT_TYPE = Symbol.for("react.context"),
+      REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
+      REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
+      REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
+      REACT_MEMO_TYPE = Symbol.for("react.memo"),
+      REACT_LAZY_TYPE = Symbol.for("react.lazy"),
+      REACT_ACTIVITY_TYPE = Symbol.for("react.activity"),
+      REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"),
+      ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
+      hasOwnProperty = Object.prototype.hasOwnProperty,
+      isArrayImpl = Array.isArray,
+      createTask = console.createTask ? console.createTask : function () {
+        return null;
+      };
+    React = {
+      react_stack_bottom_frame: function (callStackForError) {
+        return callStackForError();
+      }
+    };
+    var specialPropKeyWarningShown;
+    var didWarnAboutElementRef = {};
+    var unknownOwnerDebugStack = React.react_stack_bottom_frame.bind(React, UnknownOwner)();
+    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+    var didWarnAboutKeySpread = {};
+    reactJsxRuntime_development.Fragment = REACT_FRAGMENT_TYPE;
+    reactJsxRuntime_development.jsx = function (type, config, maybeKey) {
+      var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+      return jsxDEVImpl(type, config, maybeKey, false, trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+    };
+    reactJsxRuntime_development.jsxs = function (type, config, maybeKey) {
+      var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+      return jsxDEVImpl(type, config, maybeKey, true, trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+    };
+  }();
+  return reactJsxRuntime_development;
+}
+
+if (process.env.NODE_ENV === 'production') {
+  jsxRuntime.exports = requireReactJsxRuntime_production();
+} else {
+  jsxRuntime.exports = requireReactJsxRuntime_development();
+}
+var jsxRuntimeExports = jsxRuntime.exports;
+
 function EventopProvider({
   children,
   provider,
@@ -217,15 +482,15 @@ function EventopProvider({
 }) {
   if (!provider) throw new Error('[Eventop] <EventopProvider> requires a provider prop.');
   if (!appName) throw new Error('[Eventop] <EventopProvider> requires an appName prop.');
-  const registry = react.useRef(createFeatureRegistry()).current;
-  const sdkReady = react.useRef(false);
-  const syncToSDK = react.useCallback(() => {
+  const registry = require$$0.useRef(createFeatureRegistry()).current;
+  const sdkReady = require$$0.useRef(false);
+  const syncToSDK = require$$0.useCallback(() => {
     if (!sdkReady.current || !window.Eventop) return;
     window.Eventop._updateConfig?.({
       features: registry.snapshot()
     });
   }, [registry]);
-  react.useEffect(() => {
+  require$$0.useEffect(() => {
     function boot() {
       window.Eventop.init({
         provider,
@@ -256,17 +521,12 @@ function EventopProvider({
     unregisterStep: registry.unregisterStep,
     isRegistered: registry.isRegistered
   };
-  return /*#__PURE__*/React.createElement(EventopRegistryContext.Provider, {
-    value: ctx
-  }, children);
+  return /*#__PURE__*/jsxRuntimeExports.jsx(EventopRegistryContext.Provider, {
+    value: ctx,
+    children: children
+  });
 }
 
-/**
- * EventopTarget
- *
- * Wraps any component and registers it as an Eventop feature at the call site.
- * The wrapped component does not need to know about Eventop.
- */
 function EventopTarget({
   children,
   id,
@@ -279,10 +539,10 @@ function EventopTarget({
   ...rest
 }) {
   const registry = useRegistry();
-  const ref = react.useRef(null);
+  const ref = require$$0.useRef(null);
   const dataAttr = `data-evtp-${id}`;
   const selector = `[${dataAttr}]`;
-  react.useEffect(() => {
+  require$$0.useEffect(() => {
     if (!id || !name) {
       console.warn('[Eventop] <EventopTarget> requires id and name props.');
       return;
@@ -302,10 +562,10 @@ function EventopTarget({
     });
     return () => registry.unregisterFeature(id);
   }, [id, name, description]);
-  const child = react.Children.only(children);
+  const child = require$$0.Children.only(children);
   let wrapped;
   try {
-    wrapped = /*#__PURE__*/react.cloneElement(child, {
+    wrapped = /*#__PURE__*/require$$0.cloneElement(child, {
       [dataAttr]: '',
       ref: node => {
         ref.current = node;
@@ -314,25 +574,21 @@ function EventopTarget({
       }
     });
   } catch {
-    wrapped = /*#__PURE__*/React.createElement("span", {
+    wrapped = /*#__PURE__*/jsxRuntimeExports.jsx("span", {
       [dataAttr]: '',
       ref: ref,
       style: {
         display: 'contents'
-      }
-    }, child);
+      },
+      children: child
+    });
   }
-  return /*#__PURE__*/React.createElement(EventopFeatureScopeContext.Provider, {
-    value: id
-  }, wrapped);
+  return /*#__PURE__*/jsxRuntimeExports.jsx(EventopFeatureScopeContext.Provider, {
+    value: id,
+    children: wrapped
+  });
 }
 
-/**
- * EventopStep
- *
- * Registers one step in a multi-step flow. Can live anywhere in the tree.
- * Steps self-assemble into order via the `index` prop.
- */
 function EventopStep({
   children,
   feature,
@@ -344,7 +600,7 @@ function EventopStep({
   const registry = useRegistry();
   const featureScope = useFeatureScope();
   const featureId = feature || featureScope;
-  const ref = react.useRef(null);
+  const ref = require$$0.useRef(null);
   if (!featureId) {
     console.warn('[Eventop] <EventopStep> needs either a feature prop or an <EventopTarget> ancestor.');
   }
@@ -353,7 +609,7 @@ function EventopStep({
   }
   const dataAttr = `data-evtp-step-${featureId}-${parentStep != null ? `${parentStep}-` : ''}${index}`;
   const selector = `[${dataAttr}]`;
-  react.useEffect(() => {
+  require$$0.useEffect(() => {
     if (!featureId || index == null) return;
     registry.registerStep(featureId, index, parentStep ?? null, {
       selector,
@@ -365,10 +621,10 @@ function EventopStep({
     });
     return () => registry.unregisterStep(featureId, index, parentStep ?? null);
   }, [featureId, index, parentStep]);
-  const child = react.Children.only(children);
+  const child = require$$0.Children.only(children);
   let wrapped;
   try {
-    wrapped = /*#__PURE__*/react.cloneElement(child, {
+    wrapped = /*#__PURE__*/require$$0.cloneElement(child, {
       [dataAttr]: '',
       ref: node => {
         ref.current = node;
@@ -377,13 +633,14 @@ function EventopStep({
       }
     });
   } catch {
-    wrapped = /*#__PURE__*/React.createElement("span", {
+    wrapped = /*#__PURE__*/jsxRuntimeExports.jsx("span", {
       [dataAttr]: '',
       ref: ref,
       style: {
         display: 'contents'
-      }
-    }, child);
+      },
+      children: child
+    });
   }
   return wrapped;
 }
@@ -441,11 +698,11 @@ function useEventop() {
 // ═══════════════════════════════════════════════════════════════════════════
 
 function useEventopTour() {
-  const [state, setState] = react.useState({
+  const [state, setState] = require$$0.useState({
     isActive: false,
     isPaused: false
   });
-  react.useEffect(() => {
+  require$$0.useEffect(() => {
     const id = setInterval(() => {
       const sdk = window.Eventop;
       if (!sdk) return;
@@ -459,10 +716,10 @@ function useEventopTour() {
   }, []);
   return {
     ...state,
-    resume: react.useCallback(() => window.Eventop?.resumeTour(), []),
-    cancel: react.useCallback(() => window.Eventop?.cancelTour(), []),
-    open: react.useCallback(() => window.Eventop?.open(), []),
-    close: react.useCallback(() => window.Eventop?.close(), [])
+    resume: require$$0.useCallback(() => window.Eventop?.resumeTour(), []),
+    cancel: require$$0.useCallback(() => window.Eventop?.cancelTour(), []),
+    open: require$$0.useCallback(() => window.Eventop?.open(), []),
+    close: require$$0.useCallback(() => window.Eventop?.close(), [])
   };
 }