@kizenapps/engine 0.0.1-b1f3597

package/dist/react.js

@@ -0,0 +1,2732 @@
+import { runScript, runExpression, getStableHash, isFlagEnabled } from './chunk-2MW4AGSN.js';
+import './chunk-LGJYUPYZ.js';
+import { generateExecutionKey } from './chunk-XKKZPZMB.js';
+import { getAllNestedInputsFromConfig, getFieldFromAction } from './chunk-VYBEGZLN.js';
+import { runFrameScriptEventName } from './chunk-GGGXYD3K.js';
+import { QUERY_KEYS, ROUTE_CHANGE_INTERNAL_EVENT, IFRAME_PREFIX, ROUTE_CHANGE_IFRAME_EVENT } from './chunk-P7GQBCEH.js';
+import './chunk-5WRI5ZAA.js';
+import { useQueries, useQueryClient } from '@tanstack/react-query';
+import { createContext, useContext, useState, useCallback, useMemo, useRef, useEffect } from 'react';
+import { jsx } from 'react/jsx-runtime';
+import { formatInTimeZone } from 'date-fns-tz';
+import { startOfDay, endOfDay } from 'date-fns';
+import { flushSync } from 'react-dom';
+import DOMPurify from 'dompurify';
+
+var TerminatorsContext = createContext(null);
+var TerminatorsWrapper = ({ children }) => {
+  const terminators = useRef({});
+  const cleanupWorkers = useCallback(() => {
+    Object.keys(terminators.current).forEach((key) => {
+      terminators.current[key]?.forEach((fn) => {
+        fn();
+      });
+      terminators.current[key] = [];
+    });
+  }, []);
+  useEffect(() => {
+    return () => {
+      cleanupWorkers();
+    };
+  }, [cleanupWorkers]);
+  return /* @__PURE__ */ jsx(TerminatorsContext.Provider, { value: { terminators, cleanupWorkers }, children });
+};
+var useTerminators = () => {
+  const context = useContext(TerminatorsContext);
+  if (!context) {
+    throw new Error("useTerminators must be used within a TerminatorsWrapper");
+  }
+  return context;
+};
+var SessionDataContext = createContext(null);
+var SessionDataWrapper = ({ children }) => {
+  const [sessionData, _setSessionData] = useState({});
+  const setSessionData = useCallback((pluginId, update) => {
+    _setSessionData((prev) => ({
+      ...prev,
+      [pluginId]: {
+        ...prev[pluginId],
+        ...update
+      }
+    }));
+  }, []);
+  return /* @__PURE__ */ jsx(SessionDataContext.Provider, { value: { sessionData, setSessionData }, children });
+};
+var useSessionData = () => {
+  const context = useContext(SessionDataContext);
+  if (!context) {
+    throw new Error("useSessionData must be used within a SessionDataWrapper");
+  }
+  return context;
+};
+var AppStateContext = createContext(null);
+var AppStateWrapper = ({
+  children,
+  bootstrapPlugins = [],
+  userConfigs = [],
+  user,
+  teamMember,
+  business,
+  clientObject,
+  appPath
+}) => {
+  const [hasFinishedBootstrapping, setHasFinishedBootstrapping] = useState(false);
+  const [routeScriptRunState, setRouteScriptRunState] = useState({});
+  const waitingOnRouteScript = useMemo(() => {
+    return Object.values(routeScriptRunState).some((state) => state.waitingOnRouteScript);
+  }, [routeScriptRunState]);
+  const installedPluginAPINamesToIds = useMemo(() => {
+    return bootstrapPlugins.reduce((acc, plugin) => {
+      return {
+        ...acc,
+        [plugin.api_name]: plugin.id
+      };
+    }, {});
+  }, [bootstrapPlugins]);
+  const userConfigsByApiName = useMemo(() => {
+    return userConfigs.reduce((acc, item) => {
+      return {
+        ...acc,
+        [item.api_name]: item.config
+      };
+    }, {});
+  }, [userConfigs]);
+  const onInitialBootstrap = useCallback(() => {
+    setHasFinishedBootstrapping(true);
+  }, []);
+  return /* @__PURE__ */ jsx(
+    AppStateContext.Provider,
+    {
+      value: {
+        installedPluginAPINamesToIds,
+        userConfigsByApiName,
+        user,
+        teamMember,
+        business,
+        clientObject,
+        appPath,
+        onInitialBootstrap,
+        setRouteScriptRunState
+      },
+      children: children({
+        waitingOnRouteScript,
+        hasFinishedBootstrapping
+      })
+    }
+  );
+};
+var useAppState = () => {
+  const context = useContext(AppStateContext);
+  if (!context) {
+    throw new Error("useAppState must be used within an AppStateWrapper");
+  }
+  return context;
+};
+var RunnerStateContext = createContext(null);
+var RunnerStateWrapper = ({ children }) => {
+  const [runnerState, setRunnerState] = useState({});
+  const getRunnerStateUpdater = useCallback(
+    (key) => (getNewState) => {
+      setRunnerState((prev) => {
+        const result = {
+          ...prev,
+          [key]: getNewState(
+            prev[key] ?? { indicator: "none" /* NONE */, hidden: false, pending: false }
+          )
+        };
+        return result;
+      });
+    },
+    []
+  );
+  const getRunnerState = useCallback(
+    (key) => {
+      if (!key || !runnerState[key]) {
+        return {
+          indicator: "none" /* NONE */,
+          hidden: false,
+          pending: false
+        };
+      }
+      return {
+        ...runnerState[key]
+      };
+    },
+    [runnerState]
+  );
+  const showLoadingIndicator = useMemo(() => {
+    const keys = Object.keys(runnerState);
+    return keys.length > 0 && keys.some((name) => runnerState[name]?.indicator === "block" /* BLOCK */);
+  }, [runnerState]);
+  return /* @__PURE__ */ jsx(
+    RunnerStateContext.Provider,
+    {
+      value: {
+        getRunnerStateUpdater,
+        getRunnerState
+      },
+      children: children(showLoadingIndicator)
+    }
+  );
+};
+var useRunnerState = () => {
+  const context = useContext(RunnerStateContext);
+  if (!context) {
+    throw new Error("useRunnerState must be used within a RunnerStateWrapper");
+  }
+  return context;
+};
+var ModalsContext = createContext(null);
+var ModalsWrapper = ({
+  children,
+  showing,
+  showPrompt,
+  show,
+  onConfirm,
+  onHide
+}) => {
+  const [modalQueue, setModalQueue] = useState([]);
+  const [createRecordModalQueue, setCreateRecordModalQueue] = useState([]);
+  const [createRelatedRecordModalQueue, setCreateRelatedRecordModalQueue] = useState([]);
+  const configRef = useRef(void 0);
+  const cbRef = useRef(void 0);
+  const handleShowModal = useCallback((config, cb) => {
+    setModalQueue((prev) => [...prev, { config, cb }]);
+  }, []);
+  const handleShowCreateRecordModal = useCallback(
+    (objectId, cb) => {
+      setCreateRecordModalQueue((prev) => [...prev, { objectId, cb }]);
+    },
+    []
+  );
+  const handleShowCreateRelatedRecordModal = useCallback(
+    (objectId, relatedEntityId, cb) => {
+      setCreateRelatedRecordModalQueue((prev) => [...prev, { objectId, relatedEntityId, cb }]);
+    },
+    []
+  );
+  const handleCreateRecordComplete = useCallback(
+    (result) => {
+      const current = createRecordModalQueue[0];
+      current?.cb(result);
+      setCreateRecordModalQueue((prev) => prev.slice(1));
+    },
+    [createRecordModalQueue]
+  );
+  const handleCreateRelatedRecordComplete = useCallback(
+    (result) => {
+      const current = createRelatedRecordModalQueue[0];
+      current?.cb(result);
+      setCreateRelatedRecordModalQueue((prev) => prev.slice(1));
+    },
+    [createRelatedRecordModalQueue]
+  );
+  useEffect(() => {
+    if (modalQueue.length > 0 && !showing) {
+      configRef.current = modalQueue[0]?.config;
+      cbRef.current = modalQueue[0]?.cb;
+      showPrompt();
+    }
+  }, [modalQueue, showing, showPrompt]);
+  const completeModal = useCallback(() => {
+    configRef.current = void 0;
+    cbRef.current = void 0;
+    setModalQueue((prev) => prev.slice(1));
+  }, []);
+  const derivedModalState = useMemo(() => {
+    return {
+      props: {
+        show,
+        onConfirm: (values) => {
+          onConfirm();
+          if (cbRef.current) {
+            cbRef.current({ canceled: false, values });
+          }
+          completeModal();
+        },
+        onHide: (eventSource, ...args) => {
+          onHide(...args);
+          if (cbRef.current) {
+            cbRef.current({ canceled: true, values: {}, eventSource });
+          }
+          completeModal();
+        }
+      },
+      config: configRef.current ?? {}
+    };
+  }, [onConfirm, onHide, show, completeModal]);
+  return /* @__PURE__ */ jsx(
+    ModalsContext.Provider,
+    {
+      value: {
+        modalState: derivedModalState,
+        showModal: handleShowModal,
+        showCreateRecordModal: handleShowCreateRecordModal,
+        showCreateRelatedRecordModal: handleShowCreateRelatedRecordModal,
+        onCreateRecordComplete: handleCreateRecordComplete,
+        onCreateRelatedRecordComplete: handleCreateRelatedRecordComplete
+      },
+      children: children({
+        showPluginModal: derivedModalState.props.show,
+        pluginApiName: derivedModalState.config.pluginApiName ?? "",
+        handleShowModal,
+        handleShowCreateRecordModal,
+        handleShowCreateRelatedRecordModal,
+        derivedModalState,
+        handleCreateRecordComplete,
+        handleCreateRelatedRecordComplete,
+        showCreateRecordModal: createRecordModalQueue.length > 0,
+        createRecordModalObjectId: createRecordModalQueue[0]?.objectId ?? "",
+        showCreateRelatedRecordModal: createRelatedRecordModalQueue.length > 0,
+        createRelatedRecordModalObjectId: createRelatedRecordModalQueue[0]?.objectId ?? "",
+        createRelatedRecordModalRelatedEntityId: createRelatedRecordModalQueue[0]?.relatedEntityId ?? ""
+      })
+    }
+  );
+};
+var useModals = () => {
+  const context = useContext(ModalsContext);
+  if (!context) {
+    throw new Error("useModals must be used within a ModalsWrapper");
+  }
+  return context;
+};
+var MonitoringContext = createContext(null);
+var MonitoringWrapper = ({
+  children,
+  monitoringExceptionHelper
+}) => {
+  const sendException = useCallback(
+    (error, extra) => {
+      monitoringExceptionHelper(error, {
+        extra
+      });
+    },
+    [monitoringExceptionHelper]
+  );
+  return /* @__PURE__ */ jsx(
+    MonitoringContext.Provider,
+    {
+      value: {
+        sendException
+      },
+      children
+    }
+  );
+};
+var useMonitoring = () => {
+  const context = useContext(MonitoringContext);
+  if (!context) {
+    throw new Error("useMonitoring must be used within an MonitoringWrapper");
+  }
+  return context;
+};
+var HistoryContext = createContext(null);
+var HistoryWrapper = ({ children, onNavigate }) => {
+  const push = useCallback(
+    (path) => {
+      onNavigate(path, { replace: false });
+    },
+    [onNavigate]
+  );
+  const replace = useCallback(
+    (path) => {
+      onNavigate(path, { replace: true });
+    },
+    [onNavigate]
+  );
+  return /* @__PURE__ */ jsx(
+    HistoryContext.Provider,
+    {
+      value: {
+        push,
+        replace
+      },
+      children
+    }
+  );
+};
+var useHistory = () => {
+  const context = useContext(HistoryContext);
+  if (!context) {
+    throw new Error("useHistory must be used within an HistoryWrapper");
+  }
+  return context;
+};
+var NetworkContext = createContext(null);
+var NetworkWrapper = ({
+  children,
+  performRequest,
+  createFileId,
+  performFileUpload,
+  getPendingCacheCount,
+  invalidateCache
+}) => {
+  return /* @__PURE__ */ jsx(
+    NetworkContext.Provider,
+    {
+      value: {
+        performRequest,
+        createFileId,
+        performFileUpload,
+        getPendingCacheCount,
+        invalidateCache
+      },
+      children
+    }
+  );
+};
+var useNetwork = () => {
+  const context = useContext(NetworkContext);
+  if (!context) {
+    throw new Error("useNetwork must be used within a NetworkWrapper");
+  }
+  return context;
+};
+var defaultT = (s) => s;
+var TranslationContext = createContext({ t: defaultT });
+var TranslationWrapper = (props) => {
+  const { children, t = defaultT } = props;
+  return /* @__PURE__ */ jsx(TranslationContext.Provider, { value: { t }, children });
+};
+var useTranslation = () => {
+  const context = useContext(TranslationContext);
+  return context;
+};
+
+// src/react/hooks/useCalendarSourceCustomScript.ts
+var validateSchema = (result, schema) => {
+  if (!Array.isArray(result)) {
+    throw new Error("Return value must be an array");
+  }
+  schema.required.forEach((requiredField) => {
+    result.forEach((resultRow, index) => {
+      if (!(requiredField.key in resultRow)) {
+        throw new Error(
+          `Missing required field: ${requiredField.key} in result row ${String(index)}`
+        );
+      }
+      const actualType = typeof resultRow[requiredField.key];
+      if (actualType !== requiredField.type) {
+        throw new Error(
+          `Invalid type for field: ${requiredField.key} in result row ${String(index)}. Expected ${requiredField.type}, got ${actualType}`
+        );
+      }
+    });
+  });
+  schema.optional.forEach((optionalField) => {
+    result.forEach((resultRow, index) => {
+      if (optionalField.key in resultRow) {
+        const actualType = typeof resultRow[optionalField.key];
+        if (actualType !== optionalField.type) {
+          throw new Error(
+            `Invalid type for field: ${optionalField.key} in result row ${String(index)}. Expected ${optionalField.type}, got ${actualType}`
+          );
+        }
+      }
+    });
+  });
+};
+var useCalendarSourceCustomScript = ({
+  onError,
+  showToast,
+  clearToasts
+}) => {
+  const { t } = useTranslation();
+  const [pending, setPending] = useState(false);
+  const [executionKey, setExeutionKey] = useState(void 0);
+  const { terminators } = useTerminators();
+  const { sessionData, setSessionData } = useSessionData();
+  const {
+    installedPluginAPINamesToIds,
+    userConfigsByApiName,
+    user,
+    teamMember,
+    business,
+    clientObject,
+    appPath
+  } = useAppState();
+  const { getRunnerState, getRunnerStateUpdater } = useRunnerState();
+  const { showModal, showCreateRecordModal } = useModals();
+  const { sendException } = useMonitoring();
+  const history = useHistory();
+  const { performRequest, createFileId, performFileUpload, getPendingCacheCount, invalidateCache } = useNetwork();
+  const handleError = useCallback(
+    (plugin) => (error) => {
+      onError?.(error);
+      const errorMessage = error?.message ?? "Unknown plugin error";
+      sendException(new Error(errorMessage), {
+        error,
+        workerName: "calendarSource",
+        pluginApiName: plugin?.plugin_api_name ?? ""
+      });
+    },
+    [onError, sendException]
+  );
+  const executeScript = useCallback(
+    async (scriptBody, plugin, args, schema) => {
+      let stringArgs = "";
+      const runnerStateKey = generateExecutionKey(plugin);
+      setExeutionKey(runnerStateKey);
+      try {
+        const pluginAppId = installedPluginAPINamesToIds[plugin.plugin_api_name];
+        stringArgs = JSON.stringify({
+          ...args,
+          pluginId: pluginAppId,
+          __kizen_user_config: userConfigsByApiName[plugin.plugin_api_name]
+        });
+      } catch {
+        handleError(plugin)({
+          message: t("Arguments passed to the script are invalid")
+        });
+      }
+      let authError = false;
+      const result = await runScript({
+        user,
+        teamMember,
+        business,
+        onError: handleError(plugin),
+        setLoadingState: setPending,
+        scriptBody,
+        clientObject,
+        onStateChange: (state) => {
+          getRunnerStateUpdater(runnerStateKey)((prev) => {
+            return {
+              ...prev,
+              ...state
+            };
+          });
+        },
+        workerName: "calendarSource",
+        args: stringArgs,
+        pushHistory: history.push,
+        onShowToast: showToast,
+        onClearToasts: clearToasts,
+        terminators,
+        plugin,
+        sessionData,
+        setSessionData,
+        onShowModal: showModal,
+        onShowCreateRecordModal: showCreateRecordModal,
+        onShowCreateRelatedRecordModal: () => {
+        },
+        onNetworkError: (error) => {
+          const networkError = error;
+          if (networkError?.status === 503) {
+            authError = true;
+          }
+        },
+        appPath,
+        onNetworkRequest: performRequest,
+        createFileId,
+        performFileUpload,
+        getPendingCacheCount,
+        invalidateCache
+      });
+      try {
+        if (schema) {
+          validateSchema(result, schema);
+        }
+      } catch (ex) {
+        onError?.(ex);
+      }
+      return { result, authError };
+    },
+    [
+      user,
+      teamMember,
+      installedPluginAPINamesToIds,
+      business,
+      clientObject,
+      history,
+      showToast,
+      clearToasts,
+      terminators,
+      sessionData,
+      setSessionData,
+      showModal,
+      showCreateRecordModal,
+      handleError,
+      getRunnerStateUpdater,
+      userConfigsByApiName,
+      onError,
+      performRequest,
+      createFileId,
+      appPath,
+      performFileUpload,
+      getPendingCacheCount,
+      invalidateCache,
+      t
+    ]
+  );
+  return [
+    executeScript,
+    {
+      ...getRunnerState(executionKey),
+      pending
+    }
+  ];
+};
+var ToastContext = createContext(null);
+var ToastWrapper = ({ children, showToast, clearToasts }) => {
+  return /* @__PURE__ */ jsx(ToastContext.Provider, { value: { showToast, clearToasts }, children });
+};
+var useToast = () => {
+  const context = useContext(ToastContext);
+  if (!context) {
+    throw new Error("useToast must be used within a ToastWrapper");
+  }
+  return context;
+};
+
+// src/react/hooks/useCalendarSourceData.ts
+var executeCalendarSourceScript = async (script, plugin, executeScript, args) => {
+  const schema = {
+    required: [
+      {
+        key: "id",
+        type: "string"
+      },
+      {
+        key: "name",
+        type: "string"
+      }
+    ],
+    optional: [
+      {
+        key: "description",
+        type: "string"
+      }
+    ]
+  };
+  const { result, authError } = await executeScript(script, plugin, args, schema);
+  if (Array.isArray(result)) {
+    return { result, authError };
+  } else {
+    console.warn(`Expected calendar source script to return an array, but got:`, result);
+    return { result: [], authError };
+  }
+};
+var executeCalendarEventScript = async (script, plugin, executeScript, args) => {
+  const schema = {
+    required: [
+      {
+        key: "id",
+        type: "string"
+      },
+      {
+        key: "calendar_id",
+        type: "string"
+      },
+      {
+        key: "title",
+        type: "string"
+      },
+      {
+        key: "start_time",
+        type: "number"
+      },
+      {
+        key: "end_time",
+        type: "number"
+      }
+    ],
+    optional: [
+      {
+        key: "description",
+        type: "string"
+      },
+      {
+        key: "url",
+        type: "string"
+      },
+      {
+        key: "activity_id",
+        type: "string"
+      },
+      {
+        key: "all_day",
+        type: "boolean"
+      },
+      {
+        key: "busy",
+        type: "boolean"
+      }
+    ]
+  };
+  const { result, authError } = await executeScript(script, plugin, args, schema);
+  if (Array.isArray(result)) {
+    return { result, authError };
+  } else {
+    console.warn(`Expected calendar event script to return an array, but got:`, result);
+    return { result: [], authError };
+  }
+};
+var useCalendarOptions = (enabled, calendarSources, plugins = {}) => {
+  const { showToast, clearToasts } = useToast();
+  const { t } = useTranslation();
+  const [executeScript] = useCalendarSourceCustomScript({
+    onError: (error) => {
+      showToast({
+        message: `${t("Error fetching calendar options.")} ${error?.message ?? ""}`,
+        variant: "failure"
+      });
+    },
+    showToast,
+    clearToasts
+  });
+  const calendarsQueries = useQueries({
+    queries: calendarSources.map((source) => {
+      return {
+        queryKey: QUERY_KEYS.CALENDAR_SOURCE_CALENDAR_LIST(source.plugin_api_name, source.api_name),
+        queryFn: async () => {
+          const config = plugins[source.plugin_api_name]?.business_config ?? {};
+          const { result, authError } = await executeCalendarSourceScript(
+            source.calendars_script,
+            source,
+            executeScript,
+            config
+          );
+          return {
+            source,
+            calendars: result,
+            authError
+          };
+        },
+        enabled: enabled && Boolean(source.calendars_script)
+      };
+    })
+  });
+  const isLoading = calendarsQueries.some((q) => q.isLoading);
+  const calendarOptionsByPluginApiName = useMemo(() => {
+    if (isLoading || !enabled) {
+      return {};
+    }
+    return calendarsQueries.reduce(
+      (acc, curr) => {
+        if (!curr.data?.source.plugin_api_name || typeof curr.data.source.plugin_api_name !== "string") {
+          return acc;
+        }
+        const pluginApiName = curr.data.source.plugin_api_name;
+        acc[pluginApiName] ??= [];
+        acc[pluginApiName].push(
+          ...curr.data.calendars.map((c) => ({
+            calendar: c,
+            source: curr.data.source
+          }))
+        );
+        return acc;
+      },
+      {}
+    );
+  }, [calendarsQueries, isLoading, enabled]);
+  const servicesWithErrors = useMemo(() => {
+    return calendarsQueries.filter((q) => q.data?.authError).map((q) => q.data?.source.plugin_api_name);
+  }, [calendarsQueries]);
+  return {
+    calendars: calendarOptionsByPluginApiName,
+    errorServices: servicesWithErrors,
+    isLoading
+  };
+};
+var formatString = "yyyy-MM-dd'T'HH:mm:ssXXX";
+var createDate = (dateString) => {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(dateString)) {
+    throw new Error(`Invalid date string: ${dateString}. Expected format: YYYY-MM-DD`);
+  }
+  const [year, month, day] = dateString.split("-").map(Number);
+  return new Date(year, month - 1, day);
+};
+var getTzDateString = (date, timeZone) => {
+  return formatInTimeZone(date, timeZone, formatString);
+};
+var useCalendarEvents = (flatCalendars, params, plugins = {}) => {
+  const userTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const rangeStartFilter = getTzDateString(startOfDay(createDate(params.rangeStart)), userTimezone);
+  const rangeEndFilter = getTzDateString(endOfDay(createDate(params.rangeEnd)), userTimezone);
+  const { showToast, clearToasts } = useToast();
+  const { t } = useTranslation();
+  const [executeScript] = useCalendarSourceCustomScript({
+    onError: (error) => {
+      showToast({
+        message: `${t("Error fetching calendar events.")} ${error?.message ?? ""}`,
+        variant: "failure"
+      });
+    },
+    showToast,
+    clearToasts
+  });
+  const eventsQueries = useQueries({
+    queries: flatCalendars.map(({ calendar, source }) => {
+      return {
+        queryKey: QUERY_KEYS.CALENDAR_SOURCE_EVENTS(
+          source.plugin_api_name,
+          source.api_name,
+          calendar.id,
+          params
+        ),
+        queryFn: async () => {
+          const config = plugins[source.plugin_api_name]?.business_config ?? {};
+          const { result, authError } = await executeCalendarEventScript(
+            source.events_script,
+            source,
+            executeScript,
+            {
+              ...config,
+              calendar: {
+                calendar_id: calendar.id,
+                range_start: rangeStartFilter,
+                range_end: rangeEndFilter
+              }
+            }
+          );
+          return {
+            calendarId: calendar.id,
+            events: result,
+            authError
+          };
+        }
+      };
+    })
+  });
+  const isEventsLoading = eventsQueries.some((q) => q.isLoading);
+  const sourcesByCalendarId = useMemo(() => {
+    return flatCalendars.reduce((acc, { calendar, source }) => {
+      acc[calendar.id] = { source, calendar };
+      return acc;
+    }, {});
+  }, [flatCalendars]);
+  const eventsByCalendarId = useMemo(() => {
+    if (isEventsLoading) {
+      return {};
+    }
+    return eventsQueries.reduce((acc, curr) => {
+      if (!curr.data?.calendarId) {
+        return acc;
+      }
+      acc[curr.data.calendarId] = curr.data.events;
+      return acc;
+    }, {});
+  }, [eventsQueries, isEventsLoading]);
+  return {
+    events: eventsByCalendarId,
+    sources: sourcesByCalendarId,
+    isLoading: isEventsLoading
+  };
+};
+var useFloatingFrameCustomScript = ({
+  onError,
+  scriptUIRef,
+  plugin,
+  onChangeMinimized
+}) => {
+  const { terminators } = useTerminators();
+  const { sessionData, setSessionData } = useSessionData();
+  const {
+    installedPluginAPINamesToIds,
+    userConfigsByApiName,
+    user,
+    teamMember,
+    business,
+    clientObject,
+    appPath
+  } = useAppState();
+  const { showModal, showCreateRecordModal, showCreateRelatedRecordModal } = useModals();
+  const { sendException } = useMonitoring();
+  const { showToast, clearToasts } = useToast();
+  const history = useHistory();
+  const { performRequest, createFileId, performFileUpload, getPendingCacheCount, invalidateCache } = useNetwork();
+  const { t } = useTranslation();
+  const [pending, setPending] = useState(false);
+  const [floatingFrameRunnerState, setFloatingFrameRunnerState] = useState({
+    indicator: "none",
+    hidden: true,
+    triggerHidden: false,
+    hideHeader: false
+  });
+  const pendingOnceLock = useRef(false);
+  const [pendingLocked, setPendingLocked] = useState(false);
+  if (pending && !pendingOnceLock.current) {
+    pendingOnceLock.current = true;
+  }
+  if (!pending && pendingOnceLock.current && !pendingLocked) {
+    setPendingLocked(true);
+  }
+  const handleError = useCallback(
+    (error) => {
+      onError?.(error);
+      const errorMessage = error?.message ?? "Unknown plugin error";
+      sendException(new Error(errorMessage), {
+        error,
+        workerName: "floatingFrame",
+        pluginApiName: plugin.plugin_api_name
+      });
+    },
+    [onError, plugin, sendException]
+  );
+  const executeScript = useCallback(
+    (scriptBody, args) => {
+      let stringArgs = "";
+      try {
+        const pluginAppId = installedPluginAPINamesToIds[plugin.plugin_api_name];
+        stringArgs = JSON.stringify({
+          ...args,
+          pluginId: pluginAppId,
+          __kizen_user_config: userConfigsByApiName[plugin.plugin_api_name]
+        });
+      } catch {
+        handleError({ message: t("Arguments passed to the script are invalid") });
+      }
+      return runScript({
+        user,
+        teamMember,
+        business,
+        onError: handleError,
+        setLoadingState: (...args2) => {
+          flushSync(() => {
+            setPending(...args2);
+          });
+        },
+        scriptBody,
+        clientObject,
+        scriptUIRef,
+        onStateChange: (state) => {
+          const { minimized, ...rest } = state;
+          if (typeof minimized === "boolean") {
+            onChangeMinimized?.(minimized);
+          }
+          setFloatingFrameRunnerState((s) => {
+            return { ...s, ...rest };
+          });
+        },
+        workerName: "floatingFramePlugin",
+        args: stringArgs,
+        pushHistory: history.push,
+        plugin,
+        onShowToast: showToast,
+        onClearToasts: clearToasts,
+        terminators,
+        sessionData,
+        setSessionData,
+        onShowModal: showModal,
+        onShowCreateRecordModal: showCreateRecordModal,
+        onShowCreateRelatedRecordModal: showCreateRelatedRecordModal,
+        appPath,
+        onNetworkRequest: performRequest,
+        createFileId,
+        performFileUpload,
+        getPendingCacheCount,
+        invalidateCache
+      });
+    },
+    [
+      user,
+      teamMember,
+      business,
+      installedPluginAPINamesToIds,
+      clientObject,
+      scriptUIRef,
+      history,
+      plugin,
+      onChangeMinimized,
+      showToast,
+      clearToasts,
+      terminators,
+      sessionData,
+      setSessionData,
+      handleError,
+      setFloatingFrameRunnerState,
+      userConfigsByApiName,
+      showModal,
+      showCreateRecordModal,
+      showCreateRelatedRecordModal,
+      performRequest,
+      appPath,
+      createFileId,
+      performFileUpload,
+      getPendingCacheCount,
+      invalidateCache,
+      t
+    ]
+  );
+  return [
+    executeScript,
+    {
+      ...floatingFrameRunnerState,
+      pending: pendingLocked ? false : pending
+    }
+  ];
+};
+var useGenericPluginCustomScript = ({
+  onError,
+  scriptUIRef,
+  plugin
+}) => {
+  const { terminators } = useTerminators();
+  const { sessionData, setSessionData } = useSessionData();
+  const {
+    installedPluginAPINamesToIds,
+    userConfigsByApiName,
+    user,
+    teamMember,
+    business,
+    clientObject,
+    appPath
+  } = useAppState();
+  const { getRunnerState, getRunnerStateUpdater } = useRunnerState();
+  const { showModal, showCreateRecordModal } = useModals();
+  const { sendException } = useMonitoring();
+  const { showToast, clearToasts } = useToast();
+  const history = useHistory();
+  const { performRequest, createFileId, performFileUpload, getPendingCacheCount, invalidateCache } = useNetwork();
+  const { t } = useTranslation();
+  const [pending, setPending] = useState(false);
+  const [executionKey, setExeutionKey] = useState(void 0);
+  const handleError = useCallback(
+    (error, executionPlugin) => {
+      onError?.(error);
+      const errorMessage = error?.message ?? "Unknown plugin error";
+      sendException(new Error(errorMessage), {
+        error,
+        workerName: "genericPlugin",
+        pluginApiName: plugin?.plugin_api_name ?? executionPlugin?.plugin_api_name ?? ""
+      });
+    },
+    [onError, plugin, sendException]
+  );
+  const executeScript = useCallback(
+    (scriptBody, args, executionPlugin) => {
+      let stringArgs = "";
+      const runnerStateKey = generateExecutionKey(executionPlugin);
+      setExeutionKey(runnerStateKey);
+      try {
+        const pluginAppId = installedPluginAPINamesToIds[plugin?.plugin_api_name ?? executionPlugin?.plugin_api_name ?? ""];
+        stringArgs = JSON.stringify({
+          ...args,
+          pluginId: pluginAppId,
+          __kizen_user_config: userConfigsByApiName[plugin?.plugin_api_name ?? executionPlugin?.plugin_api_name ?? ""]
+        });
+      } catch {
+        handleError({ message: t("Arguments passed to the script are invalid") });
+      }
+      return runScript({
+        user,
+        teamMember,
+        business,
+        onError: handleError,
+        setLoadingState: setPending,
+        scriptBody,
+        clientObject,
+        scriptUIRef,
+        onStateChange: (state) => {
+          getRunnerStateUpdater(runnerStateKey)((prev) => {
+            return {
+              ...prev,
+              ...state
+            };
+          });
+        },
+        workerName: "genericPlugin",
+        args: stringArgs,
+        pushHistory: history.push,
+        onShowToast: showToast,
+        onClearToasts: clearToasts,
+        terminators,
+        plugin,
+        executionPlugin,
+        sessionData,
+        setSessionData,
+        onShowModal: showModal,
+        onShowCreateRecordModal: showCreateRecordModal,
+        onShowCreateRelatedRecordModal: () => {
+        },
+        appPath,
+        onNetworkRequest: performRequest,
+        createFileId,
+        performFileUpload,
+        getPendingCacheCount,
+        invalidateCache
+      });
+    },
+    [
+      user,
+      teamMember,
+      installedPluginAPINamesToIds,
+      business,
+      clientObject,
+      scriptUIRef,
+      history,
+      showToast,
+      clearToasts,
+      terminators,
+      plugin,
+      sessionData,
+      setSessionData,
+      handleError,
+      getRunnerStateUpdater,
+      userConfigsByApiName,
+      showModal,
+      showCreateRecordModal,
+      performRequest,
+      appPath,
+      createFileId,
+      performFileUpload,
+      getPendingCacheCount,
+      invalidateCache,
+      t
+    ]
+  );
+  return [
+    executeScript,
+    {
+      ...getRunnerState(executionKey),
+      pending
+    }
+  ];
+};
+var useRecordDetailCustomScript = ({
+  entityId,
+  objectId,
+  onError,
+  scriptUIRef,
+  onReleaseBlockingScript
+}) => {
+  const { terminators } = useTerminators();
+  const { sessionData, setSessionData } = useSessionData();
+  const {
+    installedPluginAPINamesToIds,
+    userConfigsByApiName,
+    user,
+    teamMember,
+    business,
+    clientObject,
+    appPath
+  } = useAppState();
+  const { getRunnerState, getRunnerStateUpdater } = useRunnerState();
+  const { showModal, showCreateRecordModal, showCreateRelatedRecordModal } = useModals();
+  const { sendException } = useMonitoring();
+  const { showToast, clearToasts } = useToast();
+  const history = useHistory();
+  const { performRequest, createFileId, performFileUpload, getPendingCacheCount, invalidateCache } = useNetwork();
+  const { t } = useTranslation();
+  const [pending, setPending] = useState(false);
+  const [executionKey, setExeutionKey] = useState(void 0);
+  const handleError = useCallback(
+    (error, executionPlugin) => {
+      onError?.(error);
+      const errorMessage = error?.message ?? "Unknown plugin error";
+      sendException(new Error(errorMessage), {
+        error,
+        workerName: "recordDetail",
+        pluginApiName: executionPlugin?.plugin_api_name ?? "",
+        objectId,
+        entityId
+      });
+    },
+    [onError, objectId, entityId, sendException]
+  );
+  const executeScript = useCallback(
+    (scriptBody, args, executionPlugin, overrideContext) => {
+      let stringArgs = "";
+      try {
+        const pluginAppId = installedPluginAPINamesToIds[executionPlugin?.plugin_api_name ?? ""];
+        stringArgs = JSON.stringify({
+          ...args,
+          pluginId: pluginAppId,
+          __kizen_user_config: userConfigsByApiName[executionPlugin?.plugin_api_name ?? ""]
+        });
+      } catch {
+        handleError({ message: t("Arguments passed to the script are invalid") }, executionPlugin);
+      }
+      const runnerStateKey = generateExecutionKey(executionPlugin);
+      setExeutionKey(runnerStateKey);
+      return runScript({
+        user,
+        teamMember,
+        business,
+        onReleaseBlockingScript,
+        onError: (e) => {
+          handleError(e, executionPlugin);
+        },
+        setLoadingState: setPending,
+        scriptBody,
+        clientObject,
+        scriptUIRef,
+        onStateChange: (state) => {
+          getRunnerStateUpdater(runnerStateKey)((prev) => {
+            return {
+              ...prev,
+              ...state
+            };
+          });
+        },
+        workerName: "recordDetail",
+        args: stringArgs,
+        context: overrideContext ?? {
+          entityId,
+          objectId
+        },
+        pushHistory: history.push,
+        onShowToast: showToast,
+        onClearToasts: clearToasts,
+        terminators,
+        executionPlugin,
+        sessionData,
+        setSessionData,
+        onShowModal: showModal,
+        onShowCreateRecordModal: showCreateRecordModal,
+        onShowCreateRelatedRecordModal: showCreateRelatedRecordModal,
+        appPath,
+        onNetworkRequest: performRequest,
+        createFileId,
+        performFileUpload,
+        getPendingCacheCount,
+        invalidateCache
+      });
+    },
+    [
+      user,
+      teamMember,
+      installedPluginAPINamesToIds,
+      business,
+      entityId,
+      objectId,
+      clientObject,
+      scriptUIRef,
+      history,
+      showToast,
+      clearToasts,
+      terminators,
+      sessionData,
+      setSessionData,
+      showModal,
+      showCreateRecordModal,
+      showCreateRelatedRecordModal,
+      onReleaseBlockingScript,
+      handleError,
+      getRunnerStateUpdater,
+      userConfigsByApiName,
+      performRequest,
+      appPath,
+      createFileId,
+      performFileUpload,
+      getPendingCacheCount,
+      invalidateCache,
+      t
+    ]
+  );
+  return [
+    executeScript,
+    {
+      ...getRunnerState(executionKey),
+      pending
+    }
+  ];
+};
+var usePluginCustomHTML = (currentPage, args) => {
+  const { showToast } = useToast();
+  const { t } = useTranslation();
+  const outputUIRef = useRef(null);
+  const interactableScriptRef = useRef(null);
+  const css = currentPage?.css;
+  const html = useMemo(() => {
+    const rawHTML = currentPage?.html;
+    return rawHTML ? DOMPurify.sanitize(rawHTML) : null;
+  }, [currentPage]);
+  const interactableScripts = useMemo(() => {
+    return currentPage?.event_scripts ?? {};
+  }, [currentPage]);
+  const [executeInline, { pending: inlinePending }] = useGenericPluginCustomScript({
+    onError: (e) => {
+      showToast({
+        message: `${t("Script could not be executed:")} ${e?.message ?? "Unknown Error"}`,
+        variant: "failure"
+      });
+    },
+    scriptUIRef: outputUIRef,
+    plugin: currentPage
+  });
+  const handleClick = useCallback(
+    (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      if (!inlinePending) {
+        const target = e.target;
+        const scriptName = target.getAttribute("data-script");
+        if (scriptName && interactableScripts[scriptName]) {
+          void executeInline(interactableScripts[scriptName], args);
+        }
+      }
+    },
+    [inlinePending, executeInline, interactableScripts, args]
+  );
+  useEffect(() => {
+    const e = interactableScriptRef.current;
+    if (e) {
+      e.addEventListener("click", handleClick);
+    }
+    return () => {
+      if (e) {
+        e.removeEventListener("click", handleClick);
+      }
+    };
+  }, [handleClick, currentPage]);
+  return {
+    scopedCss: `
+        @scope {
+          ${css ?? ""}
+        }
+    `,
+    sanitizedHtml: html,
+    outputUIRef,
+    interactableScriptRef
+  };
+};
+var useCalendarSourceReset = () => {
+  const queryClient = useQueryClient();
+  const resetFn = useCallback(
+    (pluginApiName, sourceApiName) => {
+      queryClient.removeQueries({
+        queryKey: QUERY_KEYS.CALENDAR_SOURCE_CALENDAR_LIST(pluginApiName, sourceApiName),
+        exact: true
+      });
+    },
+    [queryClient]
+  );
+  return resetFn;
+};
+var useManualInteraction = (execute, currentPage, elementRef, pending, args = {}) => {
+  const interactableScripts = useMemo(() => {
+    return currentPage?.event_scripts ?? {};
+  }, [currentPage]);
+  const handleClick = useCallback(
+    (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      if (!pending) {
+        const target = e.target;
+        const scriptName = target.getAttribute("data-script");
+        if (scriptName && interactableScripts[scriptName]) {
+          void execute(interactableScripts[scriptName], { ...args });
+        }
+      }
+    },
+    [pending, execute, interactableScripts, args]
+  );
+  useEffect(() => {
+    const e = elementRef?.current;
+    if (e) {
+      e.addEventListener("click", handleClick);
+    }
+    return () => {
+      if (e) {
+        e.removeEventListener("click", handleClick);
+      }
+    };
+  }, [handleClick, currentPage, elementRef]);
+};
+var usePluginCallback = (search) => {
+  useEffect(() => {
+    const queryString = new URLSearchParams(search);
+    const query = Object.fromEntries(queryString);
+    window.parent.postMessage({ type: "kizen:plugin_callback", query }, "*");
+  }, [search]);
+};
+var usePluginPage = (currentPage, search, isLoading) => {
+  const iframeURL = currentPage?.iframe_url;
+  const script = currentPage?.script;
+  const callback = currentPage?.callback;
+  const pluginArgs = currentPage?.args;
+  const { showToast } = useToast();
+  const { t } = useTranslation();
+  const scriptUIRef = useRef(null);
+  const [execute, { pending }] = useGenericPluginCustomScript({
+    onError: (e) => {
+      showToast({
+        message: `${t("Plugin error:")} ${e?.message ?? ""}`,
+        variant: "failure"
+      });
+    },
+    scriptUIRef,
+    plugin: currentPage
+  });
+  const args = useMemo(() => {
+    const queryString = new URLSearchParams(search);
+    const query = Object.fromEntries(queryString);
+    return {
+      ...query,
+      ...pluginArgs
+    };
+  }, [search, pluginArgs]);
+  const { outputUIRef, scopedCss, sanitizedHtml, interactableScriptRef } = usePluginCustomHTML(
+    currentPage,
+    args
+  );
+  useManualInteraction(execute, currentPage, scriptUIRef, pending);
+  const hasRunScript = useRef(false);
+  useEffect(() => {
+    if (!iframeURL && !hasRunScript.current && script && !isLoading) {
+      hasRunScript.current = true;
+      void execute(script, args);
+    }
+  }, [iframeURL, execute, script, args, isLoading]);
+  const handleMessage = useCallback(
+    (e) => {
+      const message = e.data;
+      if (message?.type === "kizen:plugin_callback") {
+        const args2 = message.query;
+        if (callback) {
+          void execute(callback, args2);
+        }
+      }
+    },
+    [execute, callback]
+  );
+  useEffect(() => {
+    window.addEventListener("message", handleMessage);
+    return () => {
+      window.removeEventListener("message", handleMessage);
+    };
+  }, [handleMessage]);
+  return {
+    scriptUIRef,
+    outputUIRef,
+    scopedCss,
+    sanitizedHtml,
+    interactableScriptRef,
+    iframeURL,
+    pending
+  };
+};
+var FloatingFrameContext = createContext(null);
+var FloatingFrameWrapper = ({ children }) => {
+  const [floatingFrameOrder, setFloatingFrameOrder] = useState([]);
+  const [hiddenByModal, setHiddenByModal] = useState(false);
+  const touchFloatingFrame = useCallback((id, cb) => {
+    setFloatingFrameOrder((prev) => {
+      const res = prev.filter((i) => i !== id);
+      const done = [id, ...res];
+      cb?.(done);
+      return done;
+    });
+  }, []);
+  const floatingFrameOffset = useMemo(() => {
+    return [...floatingFrameOrder].reverse().reduce((acc, id, index) => {
+      return {
+        ...acc,
+        [id]: index
+      };
+    }, {});
+  }, [floatingFrameOrder]);
+  useEffect(() => {
+    const observer = new MutationObserver(() => {
+      const modal = document.querySelector('div[role="dialog"]');
+      if (modal) {
+        setHiddenByModal(true);
+      } else {
+        setHiddenByModal(false);
+      }
+    });
+    observer.observe(document.body, {
+      childList: true
+    });
+    return () => {
+      observer.disconnect();
+    };
+  }, []);
+  return /* @__PURE__ */ jsx(
+    FloatingFrameContext.Provider,
+    {
+      value: {
+        touchFloatingFrame,
+        floatingFrameOffset
+      },
+      children: children(hiddenByModal)
+    }
+  );
+};
+var useFloatingFrameContext = () => {
+  const context = useContext(FloatingFrameContext);
+  if (!context) {
+    throw new Error("useFloatingFrame must be used within a FloatingFrameWrapper");
+  }
+  return context;
+};
+var defaultIgnorePatterns = [
+  "^/$",
+  "^/login*",
+  "/settings/mine$",
+  "/settings/others$",
+  "/create-new-business$",
+  "^/choose-business*",
+  "^/inactive-business$",
+  "^/reset$",
+  "/welcome$",
+  "/embed/*",
+  "/create-new-business$",
+  "/businessbuilder"
+];
+var defaultFrameIgnoreUrls = [
+  "https://js.stripe.com"
+  // Exlude irrelevant Stripe events
+];
+var getQuadrant = (topDelta, leftDelta, bottomDelta, rightDelta) => {
+  if (topDelta < bottomDelta) {
+    if (leftDelta < rightDelta) {
+      return "top-left";
+    } else {
+      return "top-right";
+    }
+  } else {
+    if (leftDelta < rightDelta) {
+      return "bottom-left";
+    } else {
+      return "bottom-right";
+    }
+  }
+};
+var useFloatingFrame = (params) => {
+  const {
+    currentWindow,
+    pathname,
+    id,
+    frameHeaderSize,
+    defaultPositionGap = 0,
+    viewportHeight = window.innerHeight,
+    hiddenByModal,
+    updateEmployeeConfig: maybeUpdateEmployeeConfig
+  } = params;
+  const scriptUIRef = useRef(null);
+  const hasRunScript = useRef(false);
+  const { showToast } = useToast();
+  const { t } = useTranslation();
+  const { installedPluginAPINamesToIds, clientObject } = useAppState();
+  const { touchFloatingFrame, floatingFrameOffset } = useFloatingFrameContext();
+  const frameOffset = floatingFrameOffset[id] ?? -1;
+  const hideOnMinimized = currentWindow.minimized_style === "none";
+  const isCircle = currentWindow.minimized_style === "circle" || hideOnMinimized;
+  const isBottomRightFixed = currentWindow.default_position === "bottom-right-fixed";
+  const isBottomLeftFixed = currentWindow.default_position === "bottom-left-fixed";
+  const isFixed = isBottomRightFixed || isBottomLeftFixed;
+  const circleIcon = currentWindow.minimized_config?.icon ?? "action-drag-handle";
+  const circleColor = currentWindow.minimized_config?.color ?? "blue";
+  const additionalArgs = useMemo(() => {
+    const splits = pathname.split("/");
+    const first = splits[1];
+    const second = splits[2];
+    if (first === "client") {
+      return {
+        objectId: clientObject?.id,
+        entityId: second
+      };
+    }
+    if (first === "custom-objects") {
+      return {
+        objectId: second,
+        entityId: splits[3]
+      };
+    }
+  }, [clientObject, pathname]);
+  const isHiddenByPattern = useMemo(() => {
+    const matchers = currentWindow.match;
+    const ignore = currentWindow.ignore;
+    if (matchers?.length && !matchers.some((m) => new RegExp(m).test(pathname))) {
+      return true;
+    }
+    if (defaultIgnorePatterns.concat(ignore ?? []).filter(Boolean).some((m) => {
+      try {
+        return new RegExp(m).test(pathname);
+      } catch {
+        return false;
+      }
+    })) {
+      return true;
+    }
+    return false;
+  }, [currentWindow, pathname]);
+  const currentPluginId = currentWindow.plugin_api_name ? installedPluginAPINamesToIds[currentWindow.plugin_api_name] : "";
+  const [minimized, _setMinimized] = useState(
+    () => currentWindow.employee_config?.[id]?.minimized ?? false
+  );
+  const script = currentWindow.script;
+  const type = currentWindow.type;
+  const args = currentWindow.args;
+  const messageHandlerScript = currentWindow.message_handler;
+  const width = currentWindow.width ?? 0;
+  const [height, setHeight] = useState(() => {
+    const viewportHeight2 = window.innerHeight;
+    return Math.min(currentWindow.height ?? 0, viewportHeight2 - frameHeaderSize);
+  });
+  const [windowPosition, setWindowPosition] = useState(null);
+  const defaultPosition = currentWindow.default_position;
+  const getDesiredPosition = useCallback(
+    (assumeExpanded) => {
+      const position = currentWindow.employee_config?.[id]?.position;
+      if (!position?.quadrant) {
+        const maxAllowedLeft = window.innerWidth - width;
+        let maxAllowedTop = window.innerHeight - height - frameHeaderSize;
+        if (minimized && !assumeExpanded) {
+          maxAllowedTop = window.innerHeight - frameHeaderSize;
+        }
+        if (position) {
+          try {
+            const coords = position;
+            if (coords.left > maxAllowedLeft) {
+              coords.left = maxAllowedLeft;
+            }
+            if (coords.top > maxAllowedTop) {
+              coords.top = maxAllowedTop;
+            }
+            if (coords.left < 0) {
+              coords.left = defaultPositionGap;
+            }
+            if (coords.top < 0) {
+              coords.top = defaultPositionGap;
+            }
+            return coords;
+          } catch {
+          }
+        }
+        let defaultLeft = maxAllowedLeft;
+        if (defaultPosition === "bottom-left") {
+          defaultLeft = defaultPositionGap;
+        }
+        return { left: defaultLeft, top: maxAllowedTop - defaultPositionGap };
+      } else if (position.quadrant === "top-left") {
+        const left = position.deltas?.left ?? 0;
+        const top = position.deltas?.top ?? 0;
+        return { ...position, left, top };
+      } else if (position.quadrant === "top-right") {
+        const left = window.innerWidth - width - (position.deltas?.right ?? 0);
+        const top = position.deltas?.top ?? 0;
+        return { ...position, left, top };
+      } else if (position.quadrant === "bottom-left") {
+        const left = position.deltas?.left ?? 0;
+        const top = window.innerHeight - (minimized ? 0 : height) - (position.deltas?.bottom ?? 0) - frameHeaderSize;
+        return { ...position, left, top };
+      } else {
+        const left = window.innerWidth - width - (position.deltas?.right ?? 0);
+        const top = window.innerHeight - (minimized ? 0 : height) - (position.deltas?.bottom ?? 0) - frameHeaderSize;
+        return { ...position, left, top };
+      }
+    },
+    [
+      currentWindow,
+      id,
+      defaultPosition,
+      minimized,
+      width,
+      height,
+      frameHeaderSize,
+      defaultPositionGap
+    ]
+  );
+  const getPosition = useCallback(
+    (assumeExpanded) => {
+      const position = getDesiredPosition(assumeExpanded);
+      const isBottom = ["bottom-right", "bottom-left"].includes(position.quadrant ?? "");
+      const calculatedHeight = isBottom && minimized ? 0 : height;
+      if (position.left < 0) {
+        position.left = 0;
+      } else if (position.left > window.innerWidth - width) {
+        position.left = window.innerWidth - width;
+      }
+      if (position.top < 0) {
+        position.top = 0;
+      } else if (position.top > window.innerHeight - calculatedHeight) {
+        position.top = window.innerHeight - calculatedHeight;
+      }
+      return position;
+    },
+    [getDesiredPosition, width, height, minimized]
+  );
+  useEffect(() => {
+    const currentHeight = currentWindow.height ?? 0;
+    if (currentHeight > viewportHeight) {
+      setHeight(viewportHeight - frameHeaderSize);
+      const position = getDesiredPosition(true);
+      position.top = 0;
+      setWindowPosition(position);
+    } else {
+      setHeight(currentHeight);
+    }
+  }, [currentWindow.height, getDesiredPosition, viewportHeight, frameHeaderSize]);
+  const [delayedModalHide, setDelayedModalHide] = useState(minimized);
+  const [circleMinimized, setCircleMinimized] = useState(minimized && isCircle);
+  const animationDelay = height * 5e-4 * 1e3;
+  const setMinimized = (min) => {
+    _setMinimized(min);
+    if (min && isCircle) {
+      setTimeout(() => {
+        setCircleMinimized(min);
+      }, animationDelay);
+    } else if (isCircle) {
+      setCircleMinimized(min);
+    }
+    if (hiddenByModal) {
+      setTimeout(() => {
+        setDelayedModalHide(min);
+      }, animationDelay);
+    } else {
+      setDelayedModalHide(min);
+    }
+    if (windowPosition?.quadrant === "bottom-left" || windowPosition?.quadrant === "bottom-right") {
+      if (min) {
+        setWindowPosition((p) => {
+          if (!p) {
+            return null;
+          }
+          return {
+            ...p,
+            top: p.top + height
+          };
+        });
+      } else {
+        setWindowPosition((p) => {
+          if (!p) {
+            return null;
+          }
+          const windowHeight = window.innerHeight;
+          const movePositionUp = p.top >= 0 && p.top + height <= windowHeight;
+          return {
+            ...p,
+            top: movePositionUp ? p.top : p.top - height
+          };
+        });
+      }
+    }
+    maybeUpdateEmployeeConfig?.(id, minimized, windowPosition)({ minimized: min });
+  };
+  const [
+    execute,
+    { pending, hidden: hiddenByScript, indicator, triggerHidden, hideHeader: hideHeaderByScript }
+  ] = useFloatingFrameCustomScript({
+    onError: (e) => {
+      showToast({
+        message: `${t("Plugin error:")} ${e?.message ?? ""}`,
+        variant: "failure"
+      });
+    },
+    scriptUIRef,
+    plugin: currentWindow,
+    onChangeMinimized: (minimized2) => {
+      setMinimized(minimized2);
+    }
+  });
+  const hideHeader = useMemo(() => hideHeaderByScript && isFixed, [hideHeaderByScript, isFixed]);
+  const tooltipPosition = useMemo(() => {
+    if (!windowPosition) return "top";
+    const { left, top } = windowPosition;
+    const windowWidth = window.innerWidth;
+    const atRightEdge = windowWidth - (left + width) < 40;
+    const atTopEdge = top < 40;
+    if (atRightEdge) {
+      return "left";
+    }
+    if (atTopEdge) {
+      return "bottom";
+    }
+    return "top";
+  }, [windowPosition, width]);
+  const resolveCircleEl = useCallback(() => {
+    const currentSide2 = isBottomLeftFixed ? "left" : "right";
+    const elementId = `${currentWindow.plugin_api_name}-${currentWindow.api_name}-trigger-${currentSide2}`;
+    const el = document.getElementById(elementId);
+    return el;
+  }, [isBottomLeftFixed, currentWindow]);
+  const computeFixedPosition = useCallback(() => {
+    if (!isFixed) return;
+    const circleEl = resolveCircleEl();
+    if (!circleEl) return;
+    const rect = circleEl.getBoundingClientRect();
+    const contentHeight = minimized ? 0 : height;
+    const headerH = hideHeader ? 0 : frameHeaderSize;
+    let top = rect.top - (contentHeight + headerH) - defaultPositionGap;
+    let left = isBottomLeftFixed ? rect.left : rect.right - width;
+    const fullFrameHeight = contentHeight + headerH;
+    const maxLeft = Math.max(0, window.innerWidth - width);
+    const maxTop = Math.max(0, window.innerHeight - fullFrameHeight);
+    left = Math.min(Math.max(0, left), maxLeft);
+    top = Math.min(Math.max(0, top), maxTop);
+    setWindowPosition({
+      left,
+      top,
+      quadrant: isBottomLeftFixed ? "bottom-left" : "bottom-right",
+      deltas: {
+        top,
+        left,
+        right: window.innerWidth - (left + width),
+        bottom: window.innerHeight - (top + fullFrameHeight)
+      }
+    });
+  }, [
+    isFixed,
+    isBottomLeftFixed,
+    height,
+    minimized,
+    width,
+    hideHeader,
+    resolveCircleEl,
+    frameHeaderSize,
+    defaultPositionGap
+  ]);
+  useEffect(() => {
+    if (isFixed) {
+      computeFixedPosition();
+    }
+  }, [isFixed, height, minimized, computeFixedPosition]);
+  useEffect(() => {
+    if (!isFixed) return;
+    computeFixedPosition();
+    const bodyRO = new ResizeObserver(() => {
+      computeFixedPosition();
+    });
+    bodyRO.observe(document.body);
+    return () => {
+      bodyRO.disconnect();
+    };
+  }, [isFixed, computeFixedPosition]);
+  useEffect(() => {
+    if (!hasRunScript.current && script && type === "script" && !isHiddenByPattern) {
+      hasRunScript.current = true;
+      execute(script, { ...args });
+    }
+  }, [execute, script, type, args, isHiddenByPattern]);
+  useEffect(() => {
+    const handleRunFrameScriptFromInteraction = (e) => {
+      const event = e;
+      if (event?.detail?.recipient?.frame === currentWindow.api_name) {
+        const payload = event.detail;
+        if (payload.recipient?.plugin !== currentWindow.plugin_api_name) {
+          return;
+        }
+        if (payload.recipient.script && currentWindow.event_scripts?.[payload.recipient.script]) {
+          const script2 = currentWindow.event_scripts[payload.recipient.script] ?? "";
+          execute(script2, {
+            ...payload.args,
+            ...args,
+            ...additionalArgs
+          });
+        }
+      }
+    };
+    window.addEventListener(runFrameScriptEventName, handleRunFrameScriptFromInteraction);
+    return () => {
+      window.removeEventListener(runFrameScriptEventName, handleRunFrameScriptFromInteraction);
+    };
+  }, [currentWindow, execute, args, additionalArgs]);
+  const [dragging, setDragging] = useState(false);
+  const dragEnd = (_event, context) => {
+    setDragging(false);
+    touchFloatingFrame(id);
+    const windowWidth = window.innerWidth;
+    const windowHeight = window.innerHeight;
+    if (context.node) {
+      const rect = context.node.getBoundingClientRect();
+      const left = rect.left;
+      const top = rect.top;
+      const bottom = top + rect.height;
+      const right = left + rect.width;
+      const topDelta = top;
+      const bottomDelta = windowHeight - bottom;
+      const leftDelta = left;
+      const rightDelta = windowWidth - right;
+      const quadrant = getQuadrant(topDelta, leftDelta, bottomDelta, rightDelta);
+      const result = {
+        left,
+        right,
+        top,
+        quadrant,
+        deltas: {
+          top: topDelta,
+          bottom: bottomDelta,
+          left: leftDelta,
+          right: rightDelta
+        }
+      };
+      setWindowPosition(result);
+      maybeUpdateEmployeeConfig?.(id, minimized, windowPosition)({ position: result });
+    }
+  };
+  useEffect(() => {
+    const handleUpdate = () => {
+      if (isFixed) {
+        computeFixedPosition();
+      } else {
+        setWindowPosition(getPosition(false));
+      }
+    };
+    window.addEventListener("resize", handleUpdate);
+    return () => {
+      window.removeEventListener("resize", handleUpdate);
+    };
+  }, [isFixed, computeFixedPosition, getPosition]);
+  useManualInteraction(execute, currentWindow, scriptUIRef, pending, args);
+  useEffect(() => {
+    const handleMessageEvent = (ev) => {
+      if (ev.source !== window && messageHandlerScript && !defaultFrameIgnoreUrls.includes(ev.origin)) {
+        execute(messageHandlerScript, {
+          ...args,
+          eventData: ev.data
+        });
+      }
+    };
+    window.addEventListener("message", handleMessageEvent);
+    return () => {
+      window.removeEventListener("message", handleMessageEvent);
+    };
+  }, [execute, args, messageHandlerScript]);
+  const { outputUIRef, scopedCss, sanitizedHtml, interactableScriptRef } = usePluginCustomHTML(
+    currentWindow,
+    {}
+  );
+  const hidden = !delayedModalHide ? hiddenByScript || isHiddenByPattern : hiddenByScript || isHiddenByPattern || hiddenByModal;
+  const parentClassName = `floating-window-parent--${id}`;
+  const dragHandleClassName = `floating-drag-handle--${id}`;
+  const contentClassName = `floating-window-content--${id}`;
+  let currentSide = currentWindow.employee_config?.[id]?.position?.quadrant?.split("-")[1] === "right" ? "right" : "left";
+  if (isBottomLeftFixed) {
+    currentSide = "left";
+  } else if (isBottomRightFixed) {
+    currentSide = "right";
+  }
+  const customIconDataUrl = currentWindow.minimized_config?.customIcon;
+  let CustomIcon = null;
+  if (customIconDataUrl?.startsWith("data:image/")) {
+    CustomIcon = ({ className = "" }) => /* @__PURE__ */ jsx(
+      "img",
+      {
+        src: customIconDataUrl,
+        alt: currentWindow.title || "Open Frame",
+        className: `object-cover select-none pointer-events-none ${className}`
+      }
+    );
+  }
+  if (!windowPosition) {
+    setWindowPosition(getPosition(false));
+  }
+  return {
+    circleProps: {
+      id,
+      side: currentSide,
+      circleIcon,
+      CustomIcon,
+      circleColor,
+      onClick: () => {
+        setMinimized(!minimized);
+      },
+      // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+      hidden: Boolean(hidden || isHiddenByPattern || hideOnMinimized || triggerHidden)
+    },
+    parentProps: {
+      className: parentClassName,
+      dragging,
+      // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+      hidden: hidden || circleMinimized || isHiddenByPattern || hideOnMinimized
+    },
+    draggableProps: {
+      onStop: dragEnd,
+      onStart: () => {
+        setDragging(true);
+      },
+      bounds: `.${parentClassName}`,
+      handle: `.${dragHandleClassName}`,
+      defaultPosition: {
+        x: windowPosition?.left ?? 0,
+        y: windowPosition?.top ?? 0
+      },
+      position: {
+        x: windowPosition?.left ?? 0,
+        y: windowPosition?.top ?? 0
+      },
+      disabled: isFixed
+    },
+    floatProps: {
+      pending,
+      width,
+      dragging,
+      height,
+      isCircle: isCircle && minimized
+    },
+    contentProps: {
+      className: contentClassName,
+      dragging,
+      solid: true
+    },
+    minimized,
+    pending,
+    indicator,
+    hideHeader,
+    isFixed,
+    isCircle,
+    outputUIRef,
+    scopedCss,
+    sanitizedHtml,
+    interactableScriptRef,
+    tooltipPosition,
+    currentPluginId,
+    setMinimized,
+    dragHandleClassName,
+    height,
+    script,
+    dragging,
+    frameOffset,
+    scriptUIRef
+  };
+};
+var useLocationChange = () => {
+  useEffect(() => {
+    let previousEventHash = null;
+    const listener = (e) => {
+      if (!e.detail?.location) {
+        return;
+      }
+      const locationHash = getStableHash(e.detail.location);
+      if (locationHash === previousEventHash) {
+        return;
+      }
+      previousEventHash = locationHash;
+      const frames = document.querySelectorAll(
+        `iframe[id^=${IFRAME_PREFIX}-]`
+      );
+      frames.forEach((frame) => {
+        let targetOrigin = null;
+        try {
+          const url = new URL(frame.src, window.location.href);
+          targetOrigin = url.origin;
+        } catch (error) {
+          const isDebug = isFlagEnabled("script-runner-logging");
+          if (isDebug) {
+            console.warn(
+              "Failed to parse iframe src for location change message target origin:",
+              error
+            );
+          }
+          targetOrigin = null;
+        }
+        if (!targetOrigin) {
+          return;
+        }
+        frame.contentWindow?.postMessage(
+          {
+            action: ROUTE_CHANGE_IFRAME_EVENT,
+            location: e.detail?.location
+          },
+          targetOrigin
+        );
+      });
+    };
+    window.addEventListener(ROUTE_CHANGE_INTERNAL_EVENT, listener);
+    return () => {
+      window.removeEventListener(ROUTE_CHANGE_INTERNAL_EVENT, listener);
+    };
+  }, []);
+};
+var PluginEngineProvider = (props) => {
+  const {
+    children,
+    bootstrapPlugins = [],
+    userConfigs = [],
+    user,
+    teamMember,
+    business,
+    clientObject,
+    onNavigate,
+    modal,
+    monitoringExceptionHelper,
+    showToast,
+    clearToasts,
+    performRequest,
+    appPath,
+    hideFramesOnModal = true,
+    createFileId,
+    performFileUpload,
+    t
+  } = props;
+  useLocationChange();
+  return /* @__PURE__ */ jsx(
+    AppStateWrapper,
+    {
+      bootstrapPlugins,
+      userConfigs,
+      user,
+      teamMember,
+      business,
+      clientObject,
+      appPath,
+      children: ({ hasFinishedBootstrapping, waitingOnRouteScript }) => {
+        return /* @__PURE__ */ jsx(TranslationWrapper, { t, children: /* @__PURE__ */ jsx(RunnerStateWrapper, { children: (showLoadingIndicator) => {
+          return /* @__PURE__ */ jsx(HistoryWrapper, { onNavigate, children: /* @__PURE__ */ jsx(ModalsWrapper, { ...modal, children: (modals) => {
+            return /* @__PURE__ */ jsx(MonitoringWrapper, { monitoringExceptionHelper, children: /* @__PURE__ */ jsx(SessionDataWrapper, { children: /* @__PURE__ */ jsx(TerminatorsWrapper, { children: /* @__PURE__ */ jsx(ToastWrapper, { showToast, clearToasts, children: /* @__PURE__ */ jsx(FloatingFrameWrapper, { children: (hiddenByModal) => {
+              return /* @__PURE__ */ jsx(
+                NetworkWrapper,
+                {
+                  performRequest,
+                  createFileId,
+                  performFileUpload,
+                  children: children({
+                    ...modals,
+                    showLoadingIndicator,
+                    hasFinishedBootstrapping,
+                    waitingOnRouteScript,
+                    hiddenByModal: hideFramesOnModal ? hiddenByModal : false
+                  })
+                }
+              );
+            } }) }) }) }) });
+          } }) });
+        } }) });
+      }
+    }
+  );
+};
+var PluginBootstrapSuccess = () => {
+  const { onInitialBootstrap } = useAppState();
+  useEffect(() => {
+    onInitialBootstrap();
+  }, [onInitialBootstrap]);
+  return null;
+};
+var getRouteMatcher = (objectId, clientObjectId) => {
+  if (objectId === clientObjectId || objectId === "client") {
+    return { isClient: true, exp: new RegExp(`^/client/([a-zA-Z0-9-]+)/.*$`) };
+  }
+  return {
+    isClient: false,
+    exp: new RegExp(`^/custom-objects/${objectId}/([a-zA-Z0-9-]+).*$`)
+  };
+};
+var getPluginStateKey = (item) => {
+  return `${item.plugin_api_name}-${item.api_name}`;
+};
+var RouteScriptRunner = (props) => {
+  const { showToast } = useToast();
+  const { t } = useTranslation();
+  const { pathname, routeScripts } = props;
+  const previousPathname = useRef("");
+  const { clientObject, setRouteScriptRunState } = useAppState();
+  const clientObjectId = clientObject?.id;
+  const [executeScript] = useRecordDetailCustomScript({
+    onError: (e) => {
+      showToast({
+        message: `${t("Action could not run:")} ${e?.message ?? ""}`,
+        variant: "failure"
+      });
+    },
+    // Only route script handlers need to be able to release a blocking script, since they're the only type that
+    // can block the app rendering.
+    onReleaseBlockingScript: (executionPlugin) => {
+      if (executionPlugin) {
+        const key = getPluginStateKey(executionPlugin);
+        setRouteScriptRunState((state) => {
+          return {
+            ...state,
+            [key]: {
+              ...state[key],
+              waitingOnRouteScript: false
+            }
+          };
+        });
+      }
+    },
+    entityId: "",
+    objectId: ""
+  });
+  const getRunnerStateForScript = (checkPath, checkObjectId) => {
+    const { exp, isClient } = getRouteMatcher(checkObjectId, clientObjectId ?? "");
+    const match = exp.exec(checkPath);
+    if (match?.[1]) {
+      return {
+        canRunScript: true,
+        entityId: match[1],
+        customObjectId: isClient ? clientObjectId ?? "" : checkObjectId
+      };
+    }
+    return {
+      canRunScript: false
+    };
+  };
+  const handlePathChange = (previousPath = "", currentPath = "") => {
+    const runQueue = routeScripts.map((script) => {
+      return {
+        ...getRunnerStateForScript(currentPath, script.custom_object.id),
+        ...script
+      };
+    }).filter(
+      (q) => {
+        if (!q.canRunScript) {
+          return false;
+        }
+        if (q.routes?.length) {
+          return q.routes.some((pattern) => {
+            return new RegExp(pattern).test(currentPath);
+          });
+        }
+        return true;
+      }
+    );
+    runQueue.forEach((item) => {
+      const itemKey = getPluginStateKey(item);
+      setRouteScriptRunState((state) => {
+        return {
+          ...state,
+          [itemKey]: {
+            ...state[itemKey],
+            waitingOnRouteScript: item.blocking
+          }
+        };
+      });
+      void executeScript(
+        item.script,
+        {
+          previousRoute: previousPath,
+          currentRoute: currentPath
+        },
+        item,
+        {
+          entityId: item.entityId,
+          objectId: item.customObjectId
+        }
+      ).then(() => {
+        setRouteScriptRunState((state) => {
+          return {
+            ...state,
+            [itemKey]: {
+              ...state[itemKey],
+              waitingOnRouteScript: false
+            }
+          };
+        });
+      });
+    });
+  };
+  if (previousPathname.current !== pathname && clientObjectId) {
+    const previousValue = previousPathname.current;
+    previousPathname.current = pathname;
+    handlePathChange(previousValue, pathname);
+  }
+  return null;
+};
+var SetupAssistantContext = createContext(null);
+var SetupAssistantProvider = SetupAssistantContext.Provider;
+var getUsableValue = (type, value) => {
+  if (type === "custom_object") {
+    return value?.id;
+  }
+};
+var doesValueExist = (field, value) => {
+  if (field.type === "custom_object") {
+    if (field.allow_multiple) {
+      const consideredValue = value?.value ?? [];
+      return consideredValue.length > 0;
+    }
+    return Boolean(value?.value?.id);
+  } else if (field.type === "field") {
+    if (field.allow_multiple) {
+      const consideredValue = value?.value ?? [];
+      return consideredValue.length > 0;
+    }
+    return Boolean(value?.value?.value);
+  } else if (field.type === "text") {
+    const consideredValue = value?.value ?? "";
+    return Boolean(consideredValue.trim());
+  } else if (field.type === "number") {
+    const parsed = Number(value?.value);
+    return Boolean(value?.value) && !isNaN(parsed);
+  } else if (field.type === "select") {
+    if (field.allow_multiple) {
+      const consideredValue = value?.value ?? [];
+      return consideredValue.length > 0;
+    }
+    return Boolean(value?.value?.value);
+  } else if (field.type === "boolean") {
+    return Boolean(value?.value);
+  }
+  return false;
+};
+var getNestedObjectsFromConfig = (config) => {
+  const objects = (config.fields ?? []).filter(
+    (entry) => entry.type === "custom_object"
+  );
+  const containers = (config.fields ?? []).filter((entry) => entry.type === "container");
+  const recursiveObjects = containers.flatMap((container) => {
+    return getNestedObjectsFromConfig(container);
+  });
+  const actionObjects = config.actions?.filter((action) => action.hint_object_name) ?? [];
+  return [
+    ...objects,
+    ...recursiveObjects,
+    ...actionObjects.map((action) => {
+      return {
+        ...getFieldFromAction(action),
+        match_hint: action.hint_object_name ?? ""
+      };
+    })
+  ];
+};
+var getNestedFieldsFromConfig = (config) => {
+  const objects = (config.fields ?? []).filter((entry) => entry.type === "field");
+  const containers = (config.fields ?? []).filter((entry) => entry.type === "container");
+  const recursiveFields = containers.flatMap(
+    (container) => getNestedFieldsFromConfig(container)
+  );
+  return [...objects, ...recursiveFields];
+};
+var SetupAssistantController = ({
+  children,
+  config,
+  value,
+  onStateChange,
+  disabledKeys,
+  templateAssociationsByActionApiName,
+  getObjectByAPIName,
+  getCustomObjectDetails
+}) => {
+  const [_rawState, _setState] = useState(value ?? {});
+  const flattenedFields = useMemo(() => {
+    return getAllNestedInputsFromConfig(config);
+  }, [config]);
+  const defaultState = useMemo(() => {
+    const defaultValues = flattenedFields.reduce((acc, field) => {
+      return {
+        ...acc,
+        [field.key]: {
+          type: field.type,
+          value: field.default
+        }
+      };
+    }, {});
+    return defaultValues;
+  }, [flattenedFields]);
+  const state = useMemo(() => {
+    const actionTemplatePartialState = Object.entries(
+      templateAssociationsByActionApiName ?? {}
+    ).reduce((acc, [actionApiName, associations]) => {
+      const actionFieldKey = `action__${actionApiName}`;
+      const associatedObjects = associations.map((assoc) => {
+        return {
+          id: assoc.custom_object.id ?? "",
+          objectName: assoc.custom_object.object_name ?? "Unknown Object"
+        };
+      });
+      if (associatedObjects.length > 0 && associations.length > 0 && associations[0]) {
+        acc[actionFieldKey] = {
+          type: "custom_object",
+          value: associatedObjects,
+          config: getFieldFromAction(associations[0].browser_js_action_template)
+        };
+      }
+      return acc;
+    }, {});
+    const stateValues = {
+      ...actionTemplatePartialState,
+      ..._rawState
+    };
+    disabledKeys?.forEach((key) => {
+      if (stateValues[key]) {
+        stateValues[key] = void 0;
+      }
+    });
+    return stateValues;
+  }, [_rawState, templateAssociationsByActionApiName, disabledKeys]);
+  const hasRunInference = useRef(Boolean(value));
+  const inferenceState = useRef({});
+  const [inferencePending, setInferencePending] = useState(!value);
+  const [waitingExpressions, setWaitingExpressions] = useState({});
+  const [expressionResults, setExpressionResults] = useState({});
+  const [expressionsIdle, setExpressionsIdle] = useState(false);
+  const idleTimer = useRef(null);
+  const [errors, setErrors] = useState({});
+  const [expressionsStarted, setExpressionsStarted] = useState(false);
+  const [initialExpressionsPending, setInitialExpressionsPending] = useState(true);
+  const fieldResetterRef = useRef({});
+  const registerFieldResetter = useCallback((key, resetFn) => {
+    fieldResetterRef.current[key] = resetFn;
+  }, []);
+  const setState = useCallback(
+    (stateUpdate) => {
+      if (typeof stateUpdate === "function") {
+        _setState((prev) => {
+          const result = stateUpdate(prev);
+          inferenceState.current = result;
+          onStateChange?.(result);
+          return result;
+        });
+      } else {
+        inferenceState.current = stateUpdate;
+        _setState(stateUpdate);
+        onStateChange?.(stateUpdate);
+      }
+      setErrors({});
+    },
+    [onStateChange]
+  );
+  const interpolateValueFromState = useCallback(
+    (accessor, consideredState) => {
+      if (accessor.startsWith("{{") && accessor.endsWith("}}")) {
+        const stateKey = accessor.slice(2, -2).trim();
+        return getUsableValue(
+          consideredState[stateKey]?.type,
+          consideredState[stateKey]?.value
+        );
+      }
+      return accessor;
+    },
+    []
+  );
+  const interpolateValue = useCallback(
+    (accessor) => {
+      return interpolateValueFromState(accessor, state);
+    },
+    [state, interpolateValueFromState]
+  );
+  const { clientObject } = useAppState();
+  const getPotentialMatch = useCallback(
+    async (api_name) => {
+      if (api_name === "client_client" && clientObject) {
+        return [
+          {
+            id: clientObject.id,
+            object_name: clientObject.objectName
+          }
+        ];
+      }
+      const potentialMatch = await getObjectByAPIName(api_name);
+      return potentialMatch;
+    },
+    [clientObject, getObjectByAPIName]
+  );
+  const handleInferObjects = useCallback(async () => {
+    const objectsToInfer = getNestedObjectsFromConfig(config);
+    for (const inferrableObject of objectsToInfer) {
+      if (!inferrableObject.match_hint) {
+        continue;
+      }
+      const potentialMatch = await getPotentialMatch(inferrableObject.match_hint);
+      if (potentialMatch?.[0]) {
+        const value2 = {
+          id: potentialMatch[0].id,
+          objectName: potentialMatch[0].object_name
+        };
+        setState((prev) => {
+          const result = {
+            ...prev,
+            [inferrableObject.key]: {
+              type: "custom_object",
+              value: inferrableObject.allow_multiple ? [value2] : value2
+            }
+          };
+          return result;
+        });
+      }
+    }
+  }, [config, setState, getPotentialMatch]);
+  const getInferrableFields = useCallback(() => {
+    return getNestedFieldsFromConfig(config);
+  }, [config]);
+  const handleInferFields = useCallback(
+    async (objectIdFilter, forceObjectId) => {
+      const fieldsToInfer = getInferrableFields();
+      const objectResults = {};
+      for (const inferrableField of fieldsToInfer) {
+        if (!inferrableField.object_id) {
+          continue;
+        }
+        const objectId = forceObjectId ?? interpolateValueFromState(inferrableField.object_id, inferenceState.current);
+        if (objectIdFilter && !inferrableField.object_id.includes(objectIdFilter)) {
+          continue;
+        }
+        if (!objectResults[objectId] && objectId) {
+          try {
+            objectResults[objectId] = await getCustomObjectDetails(objectId);
+          } catch {
+          }
+        }
+        const objectDetail = objectResults[objectId];
+        if (objectDetail) {
+          const fieldMatch = objectDetail.fields.find((f) => f.name === inferrableField.match_hint);
+          if (fieldMatch) {
+            setState((prev) => {
+              const result = {
+                ...prev,
+                [inferrableField.key]: {
+                  type: "field",
+                  value: {
+                    value: fieldMatch.id,
+                    label: fieldMatch.displayName
+                  },
+                  associatedObject: {
+                    id: objectId,
+                    name: objectDetail.objectName
+                  }
+                }
+              };
+              return result;
+            });
+          }
+        }
+      }
+    },
+    [interpolateValueFromState, getInferrableFields, setState, getCustomObjectDetails]
+  );
+  const handleReinferObjectByKey = useCallback(
+    async (key) => {
+      const objectsToInfer = getNestedObjectsFromConfig(config);
+      const matchingObject = objectsToInfer.find((obj) => obj.key === key);
+      if (matchingObject?.match_hint) {
+        let matchedObjectId = "";
+        const potentialMatch = await getPotentialMatch(matchingObject.match_hint);
+        const match = potentialMatch?.[0];
+        if (match) {
+          matchedObjectId = match.id;
+          setState((prev) => {
+            const result = {
+              ...prev,
+              [key]: {
+                type: "custom_object",
+                value: {
+                  id: match.id,
+                  objectName: match.object_name
+                }
+              }
+            };
+            return result;
+          });
+          if (matchedObjectId) {
+            void handleInferFields(void 0, matchedObjectId);
+          }
+        }
+      }
+    },
+    [config, setState, handleInferFields, getPotentialMatch]
+  );
+  const handleConfigInference = useCallback(async () => {
+    await handleInferObjects();
+    await handleInferFields();
+    setInferencePending(false);
+  }, [handleInferObjects, handleInferFields]);
+  const getNestedFields = useCallback(() => {
+    return getNestedFieldsFromConfig(config);
+  }, [config]);
+  const reInferFieldsForObject = useCallback(
+    (objectKey) => {
+      return handleInferFields(objectKey);
+    },
+    [handleInferFields]
+  );
+  const resetIdleTimeout = useCallback(() => {
+    if (idleTimer.current) {
+      clearTimeout(idleTimer.current);
+      idleTimer.current = null;
+    }
+    idleTimer.current = setTimeout(() => {
+      setExpressionsIdle(true);
+    }, 500);
+  }, []);
+  const evaluateExpression = useCallback(
+    async (expression, key) => {
+      resetIdleTimeout();
+      setWaitingExpressions((prev) => ({ ...prev, [key]: true }));
+      setExpressionsStarted(true);
+      const result = await runExpression(expression, {
+        ...defaultState,
+        ...state
+      });
+      setExpressionResults((prev) => {
+        if (prev[key] === false && typeof result === "boolean" && result) {
+          if (!state[key]) {
+            void handleReinferObjectByKey(key);
+          }
+        }
+        return { ...prev, [key]: result };
+      });
+      setWaitingExpressions((prev) => ({ ...prev, [key]: false }));
+      return result;
+    },
+    [state, resetIdleTimeout, handleReinferObjectByKey, defaultState]
+  );
+  if (!hasRunInference.current) {
+    hasRunInference.current = true;
+    void handleConfigInference();
+  }
+  const shouldHideField = useCallback(
+    (key) => {
+      if (expressionResults[key] === false) {
+        return true;
+      }
+      return false;
+    },
+    [expressionResults]
+  );
+  const shouldDisableField = useCallback(
+    (key) => {
+      if (waitingExpressions[key] === true) {
+        return true;
+      }
+      return false;
+    },
+    [waitingExpressions]
+  );
+  const getFieldErrorState = useCallback(
+    (key) => {
+      if (errors[key]) {
+        return {
+          message: errors[key],
+          showMessage: true,
+          error: true
+        };
+      }
+    },
+    [errors]
+  );
+  const whenClauses = useMemo(() => {
+    const sectionClauses = (config.fields ?? []).filter((entry) => entry.type === "container").map((c) => c.when);
+    const fieldClauses = flattenedFields.map((f) => f.when);
+    return [...sectionClauses, ...fieldClauses].filter(Boolean);
+  }, [config, flattenedFields]);
+  const flattenedFieldsByKey = useMemo(() => {
+    return flattenedFields.reduce((acc, field) => {
+      acc[field.key] = field;
+      return acc;
+    }, {});
+  }, [flattenedFields]);
+  const getAdditionalDeps = useCallback(
+    (dep, results, visited) => {
+      results.add(dep);
+      const depField = flattenedFieldsByKey[dep];
+      if (depField?.dependencies?.length) {
+        depField.dependencies.forEach((d) => {
+          if (!visited.has(d)) {
+            visited.add(d);
+            getAdditionalDeps(d, results, visited);
+          }
+        });
+      }
+    },
+    [flattenedFieldsByKey]
+  );
+  const flattenedFieldsWithDependencies = useMemo(() => {
+    const fields = flattenedFields.map((field) => {
+      const depsResultSet = /* @__PURE__ */ new Set();
+      const deps = field.dependencies ?? [];
+      const visited = /* @__PURE__ */ new Set();
+      deps.forEach((dep) => {
+        getAdditionalDeps(dep, depsResultSet, visited);
+      });
+      return {
+        ...field,
+        dependencies: Array.from(depsResultSet)
+      };
+    });
+    return fields;
+  }, [flattenedFields, getAdditionalDeps]);
+  const afterFieldChange = useCallback(
+    (key) => {
+      const dependentFields = flattenedFieldsWithDependencies.filter((f) => {
+        if (f.dependencies.length === 0) {
+          return false;
+        }
+        return f.dependencies.includes(key) && f.key !== key;
+      });
+      dependentFields.forEach((field) => {
+        fieldResetterRef.current[field.key]?.();
+      });
+    },
+    [flattenedFieldsWithDependencies]
+  );
+  const validateForm = useCallback(async () => {
+    const processedFields = await Promise.all(
+      flattenedFields.map(async (field) => {
+        if (!field.when) {
+          return field;
+        }
+        const isVisible = await runExpression(field.when, {
+          ...defaultState,
+          ...state
+        });
+        return isVisible ? field : null;
+      })
+    );
+    const fieldsToCheck = processedFields.filter(Boolean);
+    let errorCount = 0;
+    for (const field of fieldsToCheck) {
+      if (field && field.required && !doesValueExist(field, state[field.key])) {
+        setErrors((prev) => ({
+          ...prev,
+          [field.key]: "This field is required"
+        }));
+        errorCount++;
+      } else if (field?.validation_pattern) {
+        const isValid = new RegExp(field.validation_pattern).test(
+          state[field.key]?.value ?? field.default ?? ""
+        );
+        if (!isValid) {
+          setErrors((prev) => ({
+            ...prev,
+            [field.key]: `Value must match the pattern ${field.validation_pattern ?? ""}`
+          }));
+          errorCount++;
+        }
+      } else {
+        if (field) {
+          setErrors((prev) => ({
+            ...prev,
+            [field.key]: void 0
+          }));
+        }
+      }
+    }
+    return {
+      isValid: errorCount === 0,
+      includedKeys: fieldsToCheck.map((f) => f?.key).filter((k) => Boolean(k))
+    };
+  }, [state, flattenedFields, defaultState]);
+  useEffect(() => {
+    resetIdleTimeout();
+  }, [resetIdleTimeout]);
+  const waitingExpressionCount = Object.values(waitingExpressions).filter(Boolean).length;
+  if (!expressionsStarted && whenClauses.length === 0) {
+    setExpressionsStarted(true);
+  }
+  if (expressionsStarted && initialExpressionsPending && waitingExpressionCount === 0) {
+    setInitialExpressionsPending(false);
+  }
+  return /* @__PURE__ */ jsx(
+    SetupAssistantProvider,
+    {
+      value: {
+        state,
+        setState,
+        interpolateValue,
+        getNestedFields,
+        reInferFieldsForObject,
+        inferencePending,
+        evaluateExpression,
+        shouldHideField,
+        shouldDisableField,
+        expressionsIdle,
+        getFieldErrorState,
+        validateForm,
+        waitingExpressionCount,
+        initialExpressionsPending,
+        flattenedFields,
+        flattenedFieldsByKey,
+        afterFieldChange,
+        registerFieldResetter,
+        disabledKeys: disabledKeys ?? []
+      },
+      children
+    }
+  );
+};
+var useSetupAssistant = () => {
+  const context = useContext(SetupAssistantContext);
+  if (!context) {
+    throw new Error("useSetupAssistant must be used within a SetupAssistantController");
+  }
+  return context;
+};
+
+export { PluginBootstrapSuccess, PluginEngineProvider, RouteScriptRunner, SetupAssistantController, TranslationWrapper, useCalendarEvents, useCalendarOptions, useCalendarSourceCustomScript, useCalendarSourceReset, useFloatingFrame, useFloatingFrameCustomScript, useGenericPluginCustomScript, useManualInteraction, usePluginCallback, usePluginCustomHTML, usePluginPage, useRecordDetailCustomScript, useSetupAssistant, useTranslation };
+//# sourceMappingURL=react.js.map
+//# sourceMappingURL=react.js.map