@cccsaurora/clue-ui 0.15.0 → 1.0.0-dev.49

package/hooks/ClueActionContext.d.ts

@@ -0,0 +1,86 @@
+import { AxiosRequestConfig } from 'axios';
+import { ActionDefinitionsResponse, ActionResult } from "../types/action";
+import { Selector } from "../types/lookup";
+import { default as WithActionData } from "../types/WithActionData";
+import { FC, PropsWithChildren } from 'react';
+
+export interface ClueActionContextType {
+    /**
+     * What actions are available to execute?
+     */
+    availableActions: ActionDefinitionsResponse;
+    /**
+     * Refresh the list of actions
+     */
+    refreshActions: () => Promise<ActionDefinitionsResponse>;
+    /**
+     * Execute an action.
+     *
+     * @param actionId The ID of the action to execute
+     * @param type The type of the selector you're executing on
+     * @param value The value of the selector
+     * @param classification The clasification of the selector
+     * @param params The additional arguments required by the action
+     */
+    executeAction: (actionId: string, values: Selector[], params?: {
+        [index: string]: any;
+    }, options?: {
+        /**
+         * Should the action form show up regardless of if the form is completed?
+         */
+        forceMenu?: boolean;
+        /**
+         * Should the function raise an exception instead of showing the menu if the form is not completed?
+         */
+        skipMenu?: boolean;
+        /**
+         * Callback for post-execution.
+         * @param result
+         * @returns The action result
+         */
+        onComplete?: (result: WithActionData<ActionResult>) => void;
+        /**
+         * how long should the action have to respond?
+         */
+        timeout?: number;
+    }) => Promise<void>;
+    /**
+     * Cancel an action pending user input.
+     */
+    cancelAction: () => void;
+    /**
+     * Get a list of the results of actions executed on a selector
+     * @param type The type of the selector you're executing on
+     * @param value The value of the selector
+     * @param classification The clasification of the selector
+     * @returns the list of results for a given selector
+     */
+    getActionResults: (type: string, value: string, classification?: string) => WithActionData<ActionResult>[];
+    /**
+     * Is there currently an action executing?
+     */
+    loading: boolean;
+}
+export declare const ClueActionContext: import('use-context-selector').Context<ClueActionContextType>;
+export interface ClueActionProps {
+    /**
+     * The base URL that refers to the clue API. leaving this empty will forward requests to the current origin.
+     */
+    baseURL?: string;
+    /**
+     * What should the default classification be when executing actions?
+     */
+    classification?: string;
+    /**
+     * Get an access token for the clue API.
+     *
+     * @returns An access token valid for use with the clue API.
+     */
+    getToken?: () => string;
+    /**
+     * Add modify the Axios request configuration before the request is sent
+     * @param config The existing axios request config
+     */
+    onNetworkCall?: (config: AxiosRequestConfig) => AxiosRequestConfig;
+}
+export declare const ClueActionProvider: FC<PropsWithChildren<ClueActionProps>>;

package/hooks/ClueActionContext.js

@@ -0,0 +1,18 @@
+import "react/jsx-runtime";
+import "@mui/material";
+import "../index-Dn2NHyXg.js";
+import "../useClueTypeConfig-D4zcy8Gr.js";
+import { a, C } from "../ActionForm-c5hLIfQ-.js";
+import "../components/actions/ResultModal.js";
+import "../components/display/icons/Iconified.js";
+import "../components/ErrorBoundary.js";
+import "../data/event.js";
+import "../utils/window.js";
+import "react";
+import "../index-BDVjGvMI.js";
+import "./ClueComponentContext.js";
+import "./useClue.js";
+export {
+  a as ClueActionContext,
+  C as ClueActionProvider
+};

package/hooks/ClueComponentContext.d.ts

@@ -0,0 +1,10 @@
+import { ReactJsonViewProps } from '@microlink/react-json-view';
+import { ComponentType, FC, PropsWithChildren } from 'react';
+import { useTranslation } from 'react-i18next';
+
+export type ClueComponentContextType = {
+    ReactJson?: ComponentType<ReactJsonViewProps>;
+    i18next?: ReturnType<typeof useTranslation>;
+};
+export declare const ClueComponentContext: import('use-context-selector').Context<ClueComponentContextType>;
+export declare const ClueComponentProvider: FC<PropsWithChildren<ClueComponentContextType>>;

package/hooks/ClueComponentContext.js

@@ -0,0 +1,40 @@
+import { jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { useTranslation } from "react-i18next";
+import { c as createContext } from "../index-BDVjGvMI.js";
+const ClueComponentContext = createContext(null);
+const ClueComponentI18nProvider = ({
+  children,
+  ReactJson
+}) => {
+  const i18next = useTranslation();
+  const context = useMemo(
+    () => ({
+      ReactJson,
+      i18next
+    }),
+    [ReactJson, i18next]
+  );
+  return /* @__PURE__ */ jsx(ClueComponentContext.Provider, { value: context, children });
+};
+const ClueComponentProvider = ({
+  children,
+  ReactJson,
+  i18next = null
+}) => {
+  const context = useMemo(
+    () => ({
+      ReactJson,
+      i18next
+    }),
+    [ReactJson, i18next]
+  );
+  if (!i18next) {
+    return /* @__PURE__ */ jsx(ClueComponentI18nProvider, { ReactJson, children });
+  }
+  return /* @__PURE__ */ jsx(ClueComponentContext.Provider, { value: context, children });
+};
+export {
+  ClueComponentContext,
+  ClueComponentProvider
+};

package/hooks/ClueConfigProvider.d.ts

@@ -0,0 +1,12 @@
+import { ApiType } from "../types/config";
+import { FC, PropsWithChildren } from 'react';
+
+export type ClueConfigContextProps = {
+    config?: ApiType;
+};
+export type ClueConfigContextType = {
+    config: ApiType;
+    setConfig: (config: ApiType) => void;
+};
+export declare const ClueConfigContext: import('react').Context<ClueConfigContextType>;
+export declare const ClueConfigProvider: FC<PropsWithChildren<ClueConfigContextProps>>;

package/hooks/ClueConfigProvider.js

@@ -0,0 +1,23 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useState, useMemo } from "react";
+const ClueConfigContext = createContext(null);
+const ClueConfigProvider = ({ children, config: _config }) => {
+  const [config, setConfig] = useState(
+    _config ?? {
+      configuration: null,
+      c12nDef: null
+    }
+  );
+  const context = useMemo(
+    () => ({
+      config,
+      setConfig
+    }),
+    [config, setConfig]
+  );
+  return /* @__PURE__ */ jsx(ClueConfigContext.Provider, { value: context, children });
+};
+export {
+  ClueConfigContext,
+  ClueConfigProvider
+};

package/hooks/ClueDatabaseContext.d.ts

@@ -0,0 +1,10 @@
+import { ClueDatabase, DatabaseConfig } from "../database/types";
+import { FC, PropsWithChildren } from 'react';
+
+export interface ClueDatabaseContextProps {
+    database?: ClueDatabase;
+    databaseConfig?: DatabaseConfig;
+}
+export type ClueDatabaseContextType = ClueDatabase;
+export declare const ClueDatabaseContext: import('react').Context<ClueDatabase>;
+export declare const ClueDatabaseProvider: FC<PropsWithChildren<ClueDatabaseContextProps>>;

package/hooks/ClueDatabaseContext.js

@@ -0,0 +1,23 @@
+import { jsx } from "react/jsx-runtime";
+import { b as buildDatabase } from "../index-Dn2NHyXg.js";
+import { createContext, useState, useEffect } from "react";
+const ClueDatabaseContext = createContext(null);
+const ClueDatabaseProvider = ({
+  children,
+  database: _database,
+  databaseConfig
+}) => {
+  const [database, setDatabase] = useState();
+  useEffect(() => {
+    if (_database) {
+      setDatabase(_database);
+    } else {
+      buildDatabase(databaseConfig).then(setDatabase);
+    }
+  }, [_database, databaseConfig]);
+  return /* @__PURE__ */ jsx(ClueDatabaseContext.Provider, { value: database, children });
+};
+export {
+  ClueDatabaseContext,
+  ClueDatabaseProvider
+};

package/hooks/ClueEnrichContext.d.ts

@@ -0,0 +1,6 @@
+import { FC, PropsWithChildren } from 'react';
+import { ClueEnrichContextType } from './ClueEnrichContextType';
+import { ClueEnrichProps } from './ClueEnrichProps';
+
+export declare const ClueEnrichContext: import('use-context-selector').Context<ClueEnrichContextType>;
+export declare const ClueEnrichProvider: FC<PropsWithChildren<ClueEnrichProps>>;

package/hooks/ClueEnrichContext.js

@@ -0,0 +1,15 @@
+import "react/jsx-runtime";
+import "../iconify-CXMreGTg.js";
+import "../useClueTypeConfig-D4zcy8Gr.js";
+import "../utils/loggerUtil.js";
+import "react";
+import "../index-BDVjGvMI.js";
+import "./ClueDatabaseContext.js";
+import "./useClueConfig.js";
+import { C, a } from "../ClueEnrichContext-m-4vn9rz.js";
+import "../groupBy-DC2oOuBN.js";
+import "../debounce-bV0h5FC5.js";
+export {
+  C as ClueEnrichContext,
+  a as ClueEnrichProvider
+};

package/hooks/ClueEnrichContextType.d.ts

@@ -0,0 +1,113 @@
+import { StatusDocument } from "../database/types";
+import { BulkEnrichResponses, EnrichResponses, FailedRequest, Selector } from "../types/lookup";
+
+
+export interface ClueEnrichContextType {
+  /**
+   * What sources are available to query?
+   */
+  availableSources: string[];
+
+  /**
+   * The sources a user has selected to query data from. An empty array means all available sources will be used.
+   */
+  sources: string[];
+
+  /**
+   * Set the list of enrichments to enrich data with.
+   * @param enrichments The list of enrichments
+   */
+  setSources: (enrichments: string[]) => void;
+
+  /**
+   * List of all failed enrichments
+   */
+  failedEnrichments?: FailedRequest[];
+
+  /**
+   * Bulk enrich a large number of values in a single request.
+   * @param bulkData A list of bulk enrich requests, specifying the type and value
+   * @param options Set some options about how the enrichment should be enriched
+   * @returns a list of enrichment results broken down by type and value
+   */
+  bulkEnrich: (
+    bulkData: Selector[],
+    options?: {
+      classification?: string;
+      timeout?: number;
+      force?: boolean;
+      includeRaw?: boolean;
+      noCache?: boolean;
+      sources?: string[];
+    }
+  ) => Promise<BulkEnrichResponses>;
+
+  /**
+   * Enrich a single item
+   * @param type The type of the data to enrich
+   * @param value The value itself
+   * @param options Set some options about how the enrichment should be enriched
+   * @returns a list of enrichment results for the given type and value
+   */
+  enrich: (
+    type: string,
+    value: string,
+    options?: {
+      classification?: string;
+      timeout?: number;
+      force?: boolean;
+      includeRaw?: boolean;
+      noCache?: boolean;
+      sources?: string[];
+      append?: boolean;
+    }
+  ) => Promise<EnrichResponses>;
+
+  /**
+   * Enrich failed enrichments by source
+   * @returns a list of enrichment results for all failed enrichments
+   */
+  enrichFailedEnrichments: () => Promise<void>;
+
+  /**
+   * Queue a value for asynchronous enrichment. Slightly slower, but massively more efficient for your network as it
+   * uses bulkEnrich, while returning a single value.
+   * @param type The type of the data to enrich
+   * @param value The value itself
+   * @param classification An optional indicator-specific classification
+   * @returns a list of enrichment results for the given type and value
+   */
+  queueEnrich: (type: string, value: string, classification?: string) => Promise<StatusDocument>;
+
+  /**
+   * A set of regexes applications can use for detecting the clue type of a given string
+   */
+  typesDetection: { [type: string]: RegExp };
+
+  /**
+   * A helper function that automatically returns the clue type (or null if the type can't be inferred) of a given value
+   * @param value The value whose type we should infer
+   * @returns the inferred type
+   */
+  guessType: (value: string) => string | null;
+
+  /**
+   * Set the is ready state of the provider, when set to true, the provider will be able to issue http queries
+   * @param value The value whose type we should infer
+   * @returns the inferred type
+   */
+  setReady: (ready: boolean) => void;
+
+  /**
+   * Set the custom Iconify URL
+   * @param value the URL to use for iconify
+   */
+  setCustomIconify: (value: string) => void;
+
+  /**
+   * Is the clue context ready to enrich?
+   */
+  ready: boolean;
+
+  defaultClassification: string;
+}

package/hooks/ClueEnrichProps.d.ts

@@ -0,0 +1,81 @@
+import { AxiosRequestConfig } from 'axios';
+import { Selector } from "../types/lookup";
+
+
+export interface ClueEnrichProps {
+  /**
+   * The base URL that refers to the clue API. leaving this empty will forward requests to the current origin.
+   */
+  baseURL?: string;
+
+  /**
+   * How many IOCs should be sent in each network request? Defaults to 20.
+   */
+  chunkSize?: number;
+
+  /**
+   * How many requests should clue dispatch at once?
+   */
+  maxRequestCount?: number;
+
+  /**
+   * What should the default timeout be, if no timeout is supplied in an enrichment call?
+   */
+  defaultTimeout?: number;
+
+  /**
+   * Should enrichment be enabled? If set to false, enrichment will only be used when explicitly called.
+   */
+  enabled?: boolean;
+
+  /**
+   * What should the default classification be for indicators?
+   */
+  classification?: string;
+
+  /**
+   * Is the clue provider ready to do queries?
+   */
+  ready?: boolean;
+
+  /**
+   * Get an access token for the clue API.
+   *
+   * @returns An access token valid for use with the clue API.
+   */
+  getToken?: () => string;
+
+  /**
+   * Should we use custom deployment or public deployment of Iconify
+   */
+  publicIconify?: boolean;
+
+  /**
+   * Add modify the Axios request configuration before the request is sent
+   * @param config The existing axios request config
+   */
+  onNetworkCall?: (config: AxiosRequestConfig) => AxiosRequestConfig;
+
+  /**
+   * Modify the list of sources enrichments are requested from before the
+   * @param configuredSources The list of sources configured globally to execute
+   * @param availableSources The full list of available sources in clue
+   * @param selectors The list of selectors about to be enriched
+   */
+  pickSources?: (configuredSources: string[], availableSources: string[], selectors: Selector[]) => string[] | null;
+
+  /**
+   * Should we skip making the clue config call? Only set this if you'll manually make the call. Likely only for internal use.
+   */
+  skipConfigCall?: boolean;
+
+  /**
+   * A hostname for the custom Iconify domain to use. Only used if publicIconify is set to false.
+   */
+  customIconify?: string;
+
+  /**
+   * Flag for enabled/disabling Debug logging. Default is true.
+   */
+  debugLogging?: boolean;
+}

package/hooks/ClueFetcherContext.d.ts

@@ -0,0 +1,35 @@
+import { AxiosRequestConfig } from 'axios';
+import { FetcherDefinition, FetcherResult } from "../types/fetcher";
+import { Selector } from "../types/lookup";
+import { FC, PropsWithChildren } from 'react';
+
+export interface ClueFetcherContextProps {
+    /**
+     * The base URL that refers to the clue API. leaving this empty will forward requests to the current origin.
+     */
+    baseURL?: string;
+    /**
+     * What should the default classification be for indicators?
+     */
+    classification?: string;
+    /**
+     * Get an access token for the clue API.
+     *
+     * @returns An access token valid for use with the clue API.
+     */
+    getToken?: () => string;
+    /**
+     * Add modify the Axios request configuration before the request is sent
+     * @param config The existing axios request config
+     */
+    onNetworkCall?: (config: AxiosRequestConfig) => AxiosRequestConfig;
+}
+export type ClueFetcherContextType = {
+    fetchSelector: (fetcherId: string, selector: Selector) => Promise<FetcherResult>;
+    fetchers: {
+        [index: string]: FetcherDefinition;
+    };
+    fetchCompleted: boolean;
+};
+export declare const ClueFetcherContext: import('use-context-selector').Context<ClueFetcherContextType>;
+export declare const ClueFetcherProvider: FC<PropsWithChildren<ClueFetcherContextProps>>;

package/hooks/ClueFetcherContext.js

@@ -0,0 +1,88 @@
+import { jsx } from "react/jsx-runtime";
+import { a as api } from "../useClueTypeConfig-D4zcy8Gr.js";
+import { useState, useRef, useCallback, useEffect, useMemo } from "react";
+import { c as createContext } from "../index-BDVjGvMI.js";
+import useClue from "./useClue.js";
+import useClueConfig from "./useClueConfig.js";
+const ClueFetcherContext = createContext(null);
+const ClueFetcherProvider = ({
+  baseURL,
+  children,
+  classification: _defaultClassification,
+  getToken,
+  onNetworkCall
+}) => {
+  var _a, _b;
+  const clueConfig = useClueConfig();
+  const { ready } = useClue();
+  const [defaultClassification, setDefaultClasification] = useState(_defaultClassification);
+  const [fetchCompleted, setFetchCompleted] = useState(false);
+  const [fetchers, setFetchers] = useState({});
+  const fetchRequests = useRef({});
+  const getHashKey = useCallback(
+    ({ type, value, classification }) => JSON.stringify({ type, value, classification: classification ?? defaultClassification }),
+    [defaultClassification]
+  );
+  const fetchSelector = useCallback(
+    async (fetcherId, selector) => {
+      var _a2;
+      if ((_a2 = fetchRequests.current[fetcherId]) == null ? void 0 : _a2[getHashKey(selector)]) {
+        return fetchRequests.current[fetcherId][getHashKey(selector)];
+      }
+      try {
+        const headers = {};
+        const token = getToken == null ? void 0 : getToken();
+        if (token) {
+          headers.Authorization = `Bearer ${token}`;
+        }
+        let requestConfig = { baseURL, headers };
+        if (onNetworkCall) {
+          requestConfig = onNetworkCall(requestConfig);
+        }
+        const result = api.fetchers.post(fetcherId, selector, requestConfig);
+        if (!fetchRequests.current[fetcherId]) {
+          fetchRequests.current[fetcherId] = {};
+        }
+        fetchRequests.current[fetcherId][getHashKey(selector)] = result;
+        return await result;
+      } catch {
+        return null;
+      }
+    },
+    [baseURL, getHashKey, getToken, onNetworkCall]
+  );
+  useEffect(() => {
+    var _a2, _b2, _c, _d;
+    if (!defaultClassification && ((_b2 = (_a2 = clueConfig.config) == null ? void 0 : _a2.c12nDef) == null ? void 0 : _b2.UNRESTRICTED)) {
+      setDefaultClasification((_d = (_c = clueConfig.config) == null ? void 0 : _c.c12nDef) == null ? void 0 : _d.UNRESTRICTED);
+    }
+  }, [(_b = (_a = clueConfig.config) == null ? void 0 : _a.c12nDef) == null ? void 0 : _b.UNRESTRICTED, defaultClassification]);
+  useEffect(() => {
+    if (!ready) {
+      return;
+    }
+    const headers = {};
+    const token = getToken == null ? void 0 : getToken();
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    let requestConfig = { baseURL, headers };
+    if (onNetworkCall) {
+      requestConfig = onNetworkCall(requestConfig);
+    }
+    api.fetchers.get(requestConfig).then(setFetchers).finally(() => setFetchCompleted(true));
+  }, [baseURL, ready]);
+  const context = useMemo(
+    () => ({
+      fetchSelector,
+      fetchers,
+      fetchCompleted
+    }),
+    [fetchCompleted, fetchSelector, fetchers]
+  );
+  return /* @__PURE__ */ jsx(ClueFetcherContext.Provider, { value: context, children });
+};
+export {
+  ClueFetcherContext,
+  ClueFetcherProvider
+};

package/hooks/ClueGroupContext.d.ts

@@ -0,0 +1,14 @@
+import { Dispatch, FC, PropsWithChildren, SetStateAction } from 'react';
+
+export type ClueGroupContextProps = {
+    type: string;
+    classification?: string;
+};
+export type ClueGroupContextType = {
+    type: string;
+    classification: string;
+    values: any[];
+    setValues: Dispatch<SetStateAction<any[]>>;
+};
+export declare const ClueGroupContext: import('use-context-selector').Context<ClueGroupContextType>;
+export declare const ClueGroupProvider: FC<PropsWithChildren<ClueGroupContextProps>>;

package/hooks/ClueGroupContext.js

@@ -0,0 +1,23 @@
+import { jsx } from "react/jsx-runtime";
+import { useState, useMemo } from "react";
+import { c as createContext } from "../index-BDVjGvMI.js";
+import { useClueEnrichSelector } from "./selectors.js";
+const ClueGroupContext = createContext(null);
+const ClueGroupProvider = ({ children, type, classification }) => {
+  const defaultClassification = useClueEnrichSelector((ctx) => ctx.defaultClassification);
+  const [values, setValues] = useState([]);
+  const context = useMemo(
+    () => ({
+      type,
+      values,
+      setValues,
+      classification: classification ?? defaultClassification
+    }),
+    [classification, defaultClassification, type, values]
+  );
+  return /* @__PURE__ */ jsx(ClueGroupContext.Provider, { value: context, children });
+};
+export {
+  ClueGroupContext,
+  ClueGroupProvider
+};

package/hooks/CluePopupContext.d.ts

@@ -0,0 +1,24 @@
+import { PopoverProps } from '@mui/material';
+import { Annotation, Selector } from "../types/lookup";
+import { FC, PropsWithChildren, default as React } from 'react';
+
+type PopupType = 'details' | 'actionResults' | Annotation['type'];
+export interface ShowInfoOptions {
+    content?: React.ReactNode;
+    onClose?: () => void;
+    popoverProps?: Omit<PopoverProps, 'open'>;
+}
+export interface CluePopupContextType {
+    showInfo: (type: PopupType, anchorEl: HTMLElement, value: Selector, options?: ShowInfoOptions) => void;
+    closeInfo: (type: PopupType, value: Selector) => void;
+    __detailsContent: React.ReactNode | null;
+}
+export interface PopupEventType {
+    type: PopupType;
+    value: Selector;
+    anchorEl: HTMLElement;
+    options?: ShowInfoOptions;
+}
+export declare const CluePopupContext: import('use-context-selector').Context<CluePopupContextType>;
+export declare const CluePopupProvider: FC<PropsWithChildren>;
+export {};

package/hooks/CluePopupContext.js

@@ -0,0 +1,12 @@
+import "react/jsx-runtime";
+import "../components/AnnotationDetailPopover.js";
+import { C, a } from "../AnnotationPreview-BvNpZOP0.js";
+import "../data/event.js";
+import "../utils/window.js";
+import "react";
+import "../index-BDVjGvMI.js";
+import "../isUndefined-CE8h73dH.js";
+export {
+  C as CluePopupContext,
+  a as CluePopupProvider
+};

package/hooks/ClueProvider.d.ts

@@ -0,0 +1,9 @@
+import { FC, PropsWithChildren } from 'react';
+import { ClueActionProps } from './ClueActionContext';
+import { ClueComponentContextType } from './ClueComponentContext';
+import { ClueConfigContextProps } from './ClueConfigProvider';
+import { ClueDatabaseContextProps } from './ClueDatabaseContext';
+import { ClueEnrichProps } from './ClueEnrichProps';
+
+declare const ClueProvider: FC<PropsWithChildren<ClueEnrichProps & ClueActionProps & ClueComponentContextType & ClueDatabaseContextProps & ClueConfigContextProps>>;
+export { ClueProvider };

package/hooks/ClueProvider.js

@@ -0,0 +1,14 @@
+import { jsx } from "react/jsx-runtime";
+import { C as ClueActionProvider } from "../ActionForm-c5hLIfQ-.js";
+import { ClueComponentProvider } from "./ClueComponentContext.js";
+import { ClueConfigProvider } from "./ClueConfigProvider.js";
+import { ClueDatabaseProvider } from "./ClueDatabaseContext.js";
+import { a as ClueEnrichProvider } from "../ClueEnrichContext-m-4vn9rz.js";
+import { ClueFetcherProvider } from "./ClueFetcherContext.js";
+import { a as CluePopupProvider } from "../AnnotationPreview-BvNpZOP0.js";
+const ClueProvider = ({ children, ...props }) => {
+  return /* @__PURE__ */ jsx(ClueComponentProvider, { ...props, children: /* @__PURE__ */ jsx(ClueConfigProvider, { config: props.config, children: /* @__PURE__ */ jsx(ClueDatabaseProvider, { ...props, children: /* @__PURE__ */ jsx(ClueEnrichProvider, { ...props, children: /* @__PURE__ */ jsx(ClueFetcherProvider, { ...props, children: /* @__PURE__ */ jsx(ClueActionProvider, { ...props, children: /* @__PURE__ */ jsx(CluePopupProvider, { children }) }) }) }) }) }) });
+};
+export {
+  ClueProvider
+};