impact-chatbot 2.3.59 → 2.3.61

package/dist/components/message-template/components/message-content/utils/crossFilterAdapter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Adapter function that bridges the generic useCrossFilterCascading hook
+ * with the existing cross-filter API used by the chatbot.
+ *
+ * This is the `fetchOptionsFn` passed to the CrossFilterProvider.
+ *
+ * @param {Object} filterConfig - The filter config for which to fetch options
+ * @param {Array} existingSelections - Upstream filter selections
+ *   Each item: { filterName, attributeName, values, checkAll }
+ * @param {Array} allFilters - Full array of all filter configs
+ * @returns {Promise<Array<{label, value}>>} - Formatted options
+ */
+export declare const fetchCrossFilterOptions: (filterConfig: any, existingSelections?: any[], allFilters?: any[]) => Promise<{
+    label: any;
+    value: string;
+}[]>;

package/dist/hooks/crossFilterCascading/CrossFilterContext.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Context for cross-filter cascading.
+ * Provides cascading state and actions to child select components.
+ *
+ * Shape:
+ * {
+ *   optionsMap: { paramName: Array<{label, value}> },
+ *   loadingMap: { paramName: boolean },
+ *   selectionsMap: { paramName: value[] },
+ *   onFilterChange: (paramName, selectedValues) => void,
+ *   resetAll: () => void,
+ *   resetFilter: (paramName) => void,
+ *   fetchOptions: (paramName) => void,
+ *   getParamName: (filterConfig) => string,
+ *   isEnabled: boolean,  // flag to know if cascading is active
+ * }
+ */
+declare const CrossFilterContext: import("react").Context<any>;
+/**
+ * Hook to consume cross-filter cascading context.
+ * Returns null if not inside a CrossFilterProvider (graceful fallback).
+ */
+export declare const useCrossFilterContext: () => any;
+export default CrossFilterContext;

package/dist/hooks/crossFilterCascading/CrossFilterProvider.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Provider component that wraps a group of select components to enable
+ * cross-filter cascading between them.
+ *
+ * @param {Object} props
+ * @param {Array} props.filters - Array of filter configs (ordered by hierarchy)
+ * @param {Function} props.fetchOptionsFn - Async function to fetch options for a filter
+ * @param {Object} props.initialSelections - Optional preloaded selections { paramName: values[] }
+ * @param {boolean} props.fetchOnMount - Whether to fetch initial options on mount (default: true)
+ * @param {Function} props.onSelectionChange - Optional callback on any filter change
+ * @param {React.ReactNode} props.children - Child components (selects) that will consume the context
+ */
+declare const CrossFilterProvider: ({ filters, fetchOptionsFn, initialSelections, fetchOnMount, onSelectionChange, children, }: {
+    filters: any;
+    fetchOptionsFn: any;
+    initialSelections?: {};
+    fetchOnMount?: boolean;
+    onSelectionChange?: any;
+    children: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export default CrossFilterProvider;

package/dist/hooks/crossFilterCascading/index.d.ts

@@ -0,0 +1,3 @@
+export { default as useCrossFilterCascading } from "./useCrossFilterCascading";
+export { default as CrossFilterContext, useCrossFilterContext } from "./CrossFilterContext";
+export { default as CrossFilterProvider } from "./CrossFilterProvider";

package/dist/hooks/crossFilterCascading/useCrossFilterCascading.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Generic hook for cross-filter cascading functionality.
+ * When a filter's value changes, downstream filters' options are re-fetched
+ * with the current selections of upstream filters included in the payload.
+ *
+ * @param {Object} config
+ * @param {Array} config.filters - Array of filter configs. Each must have at minimum:
+ *   { paramName, dimension?, column_name?, attribute_name?, display_type?, ... }
+ *   The order in this array determines the cascading hierarchy (index 0 = most upstream).
+ * @param {Function} config.fetchOptionsFn - Async function to fetch options for a filter.
+ *   Signature: (filterConfig, existingSelections, allFilters) => Promise<Array<{label, value}>>
+ *   - filterConfig: the config of the filter whose options we're fetching
+ *   - existingSelections: array of { attributeName, filterName, values, checkAll } for upstream filters
+ *   - allFilters: the full filters array (for reference/lookup)
+ * @param {Object} config.initialSelections - Optional. { paramName: value[] } to preload selections.
+ * @param {boolean} config.fetchOnMount - Whether to fetch initial options for all filters on mount. Default: true.
+ * @param {Function} config.onSelectionChange - Optional callback fired after any filter value changes.
+ *   Signature: (paramName, selectedValues, allSelections) => void
+ *
+ * @returns {Object}
+ *   - optionsMap: { paramName: Array<{label, value}> } — current available options per filter
+ *   - loadingMap: { paramName: boolean } — loading state per filter
+ *   - selectionsMap: { paramName: value[] } — current selections per filter
+ *   - onFilterChange: (paramName, selectedValues) => void — call when user changes a filter
+ *   - resetAll: () => void — reset all selections and re-fetch initial options
+ *   - resetFilter: (paramName) => void — reset a single filter and its downstream filters
+ */
+declare const useCrossFilterCascading: ({ filters, fetchOptionsFn, initialSelections, fetchOnMount, onSelectionChange, }: {
+    filters?: any[];
+    fetchOptionsFn: any;
+    initialSelections?: {};
+    fetchOnMount?: boolean;
+    onSelectionChange: any;
+}) => {
+    optionsMap: {};
+    loadingMap: {};
+    selectionsMap: {};
+    onFilterChange: (paramName: any, selectedValues: any) => void;
+    resetAll: () => void;
+    resetFilter: (paramName: any) => void;
+    fetchOptions: (paramName: any) => void;
+    fetchDownstreamOptions: (paramName: any) => void;
+    fetchUpstreamOptions: (paramName: any) => void;
+    getParamName: (filter: any) => any;
+};
+export default useCrossFilterCascading;