@sisense/sdk-ui-vue 1.3.0 → 1.4.1

package/dist/src/composables/use-execute-query-by-widget-id.d.ts

@@ -0,0 +1,42 @@
+import type { ExecuteQueryByWidgetIdParams, QueryByWidgetIdState } from '@sisense/sdk-ui-preact';
+import { type ToRefs } from 'vue';
+import type { MaybeWithRefs } from '../types';
+/**
+ * A Vue composable function `useExecuteQueryByWidgetId` for executing queries by widget ID using the Sisense SDK.
+ * It simplifies the process of fetching data related to a specific widget based on provided parameters and manages
+ * the query's loading, success, and error states. This composable integrates with the Sisense application context
+ * to perform queries and handle their results within Vue components.
+ *
+ * @param {ExecuteQueryByWidgetIdParams} params - Parameters for executing the query, including widget ID, filters,
+ * and other relevant query options. The `filters` parameter allows for specifying dynamic filters for the query.
+ *
+ * @example
+ * Here's how to use `useExecuteQueryByWidgetId` within a Vue component:
+ * ```vue
+ * <script setup>
+ * import { ref } from 'vue';
+ * import { useExecuteQueryByWidgetId } from './composables/useExecuteQueryByWidgetId';
+ *
+ * const widgetId = ref('your_widget_id_here');
+ * const filters = ref([...]); // Define filters if necessary
+ *
+ * const { data, isLoading, isError, isSuccess, error } = useExecuteQueryByWidgetId({
+ *   widgetId,
+ *   filters,
+ *   enabled: true, // Optional: Use to enable/disable the query execution
+ * });
+ * </script>
+ * ```
+ *
+ * This composable returns an object containing reactive state management properties for the query:
+ * - `data`: The result of the query, undefined until the query completes successfully.
+ * - `isLoading`: A boolean indicating if the query is currently loading.
+ * - `isError`: A boolean indicating if an error occurred during the query execution.
+ * - `isSuccess`: A boolean indicating if the query executed successfully.
+ * - `error`: An Error object containing the error details if an error occurred.
+ * - `query`: The query object returned by the SDK, useful for debugging or advanced handling.
+ *
+ * Utilizing this composable allows for declarative and reactive handling of widget-specific queries within Vue applications,
+ * facilitating easier data fetching and state management with the Sisense SDK.
+ */
+export declare const useExecuteQueryByWidgetId: (params: MaybeWithRefs<ExecuteQueryByWidgetIdParams>) => ToRefs<QueryByWidgetIdState>;

package/dist/src/composables/use-execute-query.d.ts

@@ -0,0 +1,44 @@
+import { type ExecuteQueryParams } from '@sisense/sdk-ui-preact';
+import type { MaybeWithRefs } from '../types';
+/**
+ * A Vue composable function `useExecuteQuery` for executing Sisense queries with flexible parameters.
+ * It handles query execution, including loading, error, and success states, and enables dynamic query configuration
+ * through reactive parameters. This composable is particularly useful for applications requiring data from Sisense
+ * analytics, offering a reactive and declarative approach to data fetching and state management.
+ *
+ * @param {MaybeWithRefs<ExecuteQueryParams>} params - The parameters for the query, supporting reactive Vue refs.
+ * Includes details such as `dataSource`, `dimensions`, `measures`, `filters`, and more, allowing for comprehensive
+ * query configuration. The `filters` parameter supports dynamic filtering based on user interaction or other application
+ * state changes.
+ *
+ * @example
+ * How to use `useExecuteQuery` within a Vue component:
+ * ```vue
+ * <script setup>
+ * import { ref } from 'vue';
+ * import { useExecuteQuery } from './composables/useExecuteQuery';
+ *
+ * const dataSource = ref('your_data_source_id');
+ * // Set up other query parameters as needed (dimensions, measures, filters, etc.)
+ *
+ * const { data, isLoading, isError, isSuccess, error } = useExecuteQuery({
+ *   dataSource,
+ *   dimensions: [...],
+ *   measures: [...],
+ *   filters: [...],
+ *   // Additional query parameters
+ * });
+ * </script>
+ * ```
+ *
+ * The composable returns an object with the following reactive properties to manage the query state:
+ * - `data`: The data returned from the query. It remains `undefined` until the query completes successfully.
+ * - `isLoading`: Indicates if the query is in progress.
+ * - `isError`: Indicates if an error occurred during query execution.
+ * - `isSuccess`: Indicates if the query executed successfully without errors.
+ * - `error`: Contains the error object if an error occurred during the query.
+ *
+ * This composable facilitates integrating Sisense data fetching into Vue applications, enabling developers
+ * to easily manage query states and dynamically adjust query parameters based on application needs.
+ */
+export declare const useExecuteQuery: (params: MaybeWithRefs<ExecuteQueryParams>) => import("vue").ToRefs<import("@sisense/sdk-ui-preact").QueryState>;

package/dist/src/composables/use-get-dashboard-model.d.ts

@@ -0,0 +1,41 @@
+import type { MaybeWithRefs } from '../types';
+import type { GetDashboardModelParams } from '@sisense/sdk-ui-preact';
+/**
+ * A Vue composable function `useGetDashboardModel` for fetching a Sisense dashboard model.
+ * It simplifies the process of retrieving detailed dashboard data, including widgets if specified,
+ * by managing the loading, success, and error states of the request. This composable is especially useful
+ * for Vue applications that need to integrate Sisense dashboard analytics, providing a reactive way to fetch
+ * and display dashboard data.
+ *
+ * @param {GetDashboardModelParams} params - The parameters for fetching the dashboard model, including the
+ * dashboard OID and an option to include widgets within the dashboard. Supports dynamic parameter values through
+ * Vue refs, allowing for reactive dashboard loading based on user interactions or other application states.
+ *
+ * @example
+ * How to use `useGetDashboardModel` within a Vue component to fetch and display a Sisense dashboard:
+ * ```vue
+ * <script setup>
+ * import { ref } from 'vue';
+ * import { useGetDashboardModel } from './composables/useGetDashboardModel';
+ *
+ * const dashboardOid = ref('your_dashboard_oid');
+ * const includeWidgets = ref(true); // Decide whether to include widgets in the dashboard model
+ *
+ * const { data: dashboardModel, isLoading, isError, error } = useGetDashboardModel({
+ *   dashboardOid,
+ *   includeWidgets,
+ * });
+ * </script>
+ * ```
+ *
+ * The composable returns an object with reactive properties to manage the state of the dashboard model fetching process:
+ * - `dashboard`: The fetched dashboard model data, which is `undefined` until the fetch completes successfully.
+ * - `isLoading`: Indicates if the dashboard model is currently being fetched.
+ * - `isError`: Indicates if an error occurred during the fetch process.
+ * - `isSuccess`: Indicates if the dashboard model was successfully fetched without errors.
+ * - `error`: Contains the error object if an error occurred during the fetch.
+ *
+ * Utilizing this composable enables developers to declaratively integrate Sisense dashboard analytics into their Vue applications,
+ * managing data fetching and state with minimal boilerplate code.
+ */
+export declare const useGetDashboardModel: (params: MaybeWithRefs<GetDashboardModelParams>) => import("vue").ToRefs<import("@sisense/sdk-ui-preact").DashboardModelState>;

package/dist/src/composables/use-get-dashboard-models.d.ts

@@ -0,0 +1,38 @@
+import type { GetDashboardModelsParams } from '@sisense/sdk-ui-preact';
+import type { MaybeWithRefs } from '../types';
+/**
+ * A Vue composable function `useGetDashboardModels` for fetching multiple Sisense dashboard models.
+ * This function abstracts the complexities of managing API calls and state management for fetching an array of
+ * dashboard models from Sisense. It provides a reactive interface to handle loading, success, and error states,
+ * making it easier to integrate Sisense analytics within Vue applications.
+ *
+ * @param {GetDashboardModelsParams} params - Parameters for fetching the dashboard models, which can include filters,
+ * sorting options, and pagination settings to customize the fetch operation. The parameters allow for precise control
+ * over which dashboards are retrieved and in what order.
+ *
+ * @example
+ * How to use `useGetDashboardModels` within a Vue component to fetch and list Sisense dashboards:
+ * ```vue
+ * <script setup>
+ * import { ref } from 'vue';
+ * import { useGetDashboardModels } from './composables/useGetDashboardModels';
+ *
+ * const params = ref({
+ *   // Define your parameters here, such as pagination settings, filters, etc.
+ * });
+ *
+ * const { data: dashboardModels, isLoading, isError, error } = useGetDashboardModels(params);
+ * </script>
+ * ```
+ *
+ * The composable returns an object with reactive properties that represent the state of the fetch operation:
+ * - `data`: An array of dashboard models returned from the fetch operation. This is `undefined` until the operation completes successfully.
+ * - `isLoading`: A boolean indicating whether the fetch operation is currently in progress.
+ * - `isError`: A boolean indicating whether an error occurred during the fetch operation.
+ * - `isSuccess`: A boolean indicating whether the fetch operation completed successfully without any errors.
+ * - `error`: An error object containing details about any errors that occurred during the fetch operation.
+ *
+ * This composable is ideal for Vue applications requiring a list of Sisense dashboards, providing a streamlined, reactive
+ * way to fetch and manage the state of multiple dashboard models.
+ */
+export declare const useGetDashboardModels: (params: MaybeWithRefs<GetDashboardModelsParams>) => import("vue").ToRefs<import("@sisense/sdk-ui-preact").DashboardModelsState>;

package/dist/src/composables/use-get-shared-formula.d.ts

@@ -0,0 +1,45 @@
+import type { UseGetSharedFormulaParams } from '@sisense/sdk-ui-preact';
+import type { MaybeWithRefs } from '../types';
+/**
+ * A Vue composable function `useGetSharedFormula` for retrieving shared formulas from Sisense.
+ * This function enables fetching a shared formula either by its unique OID or by its name and associated data source,
+ * providing flexibility in how shared formulas are accessed. It manages the fetch operation's state, including loading,
+ * success, and error states, offering a reactive way to integrate Sisense formulas into Vue applications.
+ *
+ * @param {UseGetSharedFormulaParams} params - Parameters for fetching the shared formula, including the formula's OID,
+ * or its name and the data source. This allows for precise specification of the formula to be fetched, supporting dynamic
+ * values through Vue refs for reactive fetching based on user interactions or other application states.
+ *
+ * @example
+ * How to use `useGetSharedFormula` within a Vue component to fetch a shared formula:
+ * ```vue
+ * <script setup>
+ * import { ref } from 'vue';
+ * import { useGetSharedFormula } from './composables/useGetSharedFormula';
+ *
+ * // To fetch by OID
+ * const paramsByOid = ref({
+ *   oid: 'your_formula_oid',
+ * });
+ *
+ * // Or to fetch by name and dataSource
+ * const paramsByName = ref({
+ *   name: 'your_formula_name',
+ *   dataSource: 'your_data_source_id',
+ * });
+ *
+ * const { data: formula, isLoading, isError, error } = useGetSharedFormula(paramsByOid);
+ * // Or use `paramsByName` instead of `paramsByOid` depending on the fetching method
+ * </script>
+ * ```
+ *
+ * The composable returns an object with reactive properties to manage the state of the shared formula fetching process:
+ * - `data`: The fetched shared formula, which is `undefined` until the operation completes successfully. It can be either a `CalculatedMeasure` or `DimensionalCalculatedMeasure` based on the fetch result.
+ * - `isLoading`: Indicates whether the fetch operation is currently in progress.
+ * - `isError`: Indicates whether an error occurred during the fetch operation.
+ * - `isSuccess`: Indicates whether the fetch operation completed successfully without any errors.
+ * - `error`: Contains the error object if an error occurred during the fetch.
+ *
+ * This composable provides a streamlined, reactive approach to fetching shared formulas from Sisense, facilitating their integration into Vue applications for enhanced data analytics capabilities.
+ */
+export declare const useGetSharedFormula: (params: MaybeWithRefs<UseGetSharedFormulaParams>) => import("vue").ToRefs<import("@sisense/sdk-ui-preact").SharedFormulaState>;

package/dist/src/composables/use-get-widget-model.d.ts

@@ -0,0 +1,41 @@
+import type { GetWidgetModelParams, WidgetModel } from '@sisense/sdk-ui-preact';
+import type { MaybeWithRefs } from '../types';
+/**
+ * A Vue composable function `useGetWidgetModel` for retrieving widget models from a Sisense dashboard.
+ * It is designed to fetch a specific widget model based on the provided dashboard and widget OIDs, handling the loading,
+ * success, and error states of the fetch operation. This composable is particularly useful for Vue applications that
+ * require detailed information about a Sisense widget for data visualization or analytics purposes.
+ *
+ * @param {GetWidgetModelParams} params - The parameters for fetching the widget model, including the `dashboardOid`
+ * (the OID of the dashboard containing the widget) and the `widgetOid` (the OID of the widget to fetch). This allows for
+ * precise and dynamic fetching of widget models based on application needs.
+ *
+ * @example
+ * How to use `useGetWidgetModel` within a Vue component to fetch and display widget information:
+ * ```vue
+ * <script setup>
+ * import { ref } from 'vue';
+ * import { useGetWidgetModel } from './composables/useGetWidgetModel';
+ *
+ * const dashboardOid = ref('your_dashboard_oid');
+ * const widgetOid = ref('your_widget_oid');
+ *
+ * const { data: widgetModel, isLoading, isError, error } = useGetWidgetModel({
+ *   dashboardOid,
+ *   widgetOid,
+ * });
+ * </script>
+ * ```
+ *
+ * The composable returns an object with reactive properties that represent the state of the widget model fetch operation:
+ * - `data`: The fetched widget model, which is `undefined` until the operation is successfully completed. The widget model
+ *   contains detailed information about the widget, such as its configuration, data, and settings.
+ * - `isLoading`: A boolean indicating whether the fetch operation is currently in progress.
+ * - `isError`: A boolean indicating whether an error occurred during the fetch operation.
+ * - `isSuccess`: A boolean indicating whether the fetch operation was successfully completed without any errors.
+ * - `error`: An error object containing details about any errors that occurred during the fetch operation.
+ *
+ * This composable streamlines the process of fetching and managing Sisense widget models within Vue applications, providing
+ * developers with a reactive and efficient way to integrate Sisense data visualizations and analytics.
+ */
+export declare const useGetWidgetModel: (params: MaybeWithRefs<GetWidgetModelParams>) => import("vue").ToRefs<import("@sisense/sdk-ui-preact").DataState<WidgetModel>>;

package/dist/src/composables/use-tracking.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @internal
+ * A Vue composable function `useTracking` designed to track the usage of hooks within Vue applications
+ * using the Sisense SDK. It sends tracking information to the server whenever a specified hook is used,
+ * helping in the analysis and optimization of application performance and usage patterns. This composable
+ * is intended for internal use and aids in monitoring the integration and efficiency of Sisense SDK hooks.
+ *
+ * @param {string} hookName - The name of the hook being tracked. This identifier is used to log the hook
+ * event uniquely, facilitating the collection of usage data for specific hooks within the application.
+ *
+ * @example
+ * How to use `useTracking` to track the usage of a custom hook:
+ * ```javascript
+ * import { useTracking } from './composables/useTracking';
+ *
+ * // Example hook that utilizes useTracking for monitoring its usage
+ * export const useCustomHook = () => {
+ *   const { hasTrackedRef } = useTracking('useCustomHook');
+ *
+ *   // Hook implementation...
+ *
+ *   return {
+ *     // Return values of your custom hook
+ *   };
+ * };
+ * ```
+ *
+ * The composable returns an object containing:
+ * - `hasTrackedRef`: A Vue ref that indicates whether the tracking for the hook has been successfully
+ *   sent to the server. It starts as `false` and is set to `true` once tracking is completed, preventing
+ *   duplicate tracking events.
+ *
+ * This internal utility composable is essential for maintaining insights into the usage of custom hooks
+ * within applications leveraging the Sisense SDK, enabling developers and analysts to understand and optimize
+ * hook interactions and performance.
+ */
+export declare const useTracking: (hookName: string) => {
+    hasTrackedRef: import("vue").Ref<boolean>;
+};

package/dist/src/lib.d.ts

@@ -1,14 +1,8 @@
-/**
- * @packageDocumentation
- * @alpha
- */
 export { DrilldownBreadcrumbs } from './components/drilldown-breadcrumbs';
 export * from './components/charts';
 export * from './components/filters';
 export * from './providers';
-export * from './hooks';
+export * from './composables';
 export * from './components/context-menu';
 export { default as DrilldownWidget } from './components/drilldown-widget.vue';
-import type { ContextMenuProps as ContextMenuPropsPreact } from '@sisense/sdk-ui-preact';
-export type ContextMenuProps = Omit<ContextMenuPropsPreact, 'children'>;
-export type { AreaChartProps, BarChartProps, ChartProps, LineChartProps, ColumnChartProps, FunnelChartProps, PolarChartProps, ScatterChartProps, PieChartProps, TreemapChartProps, SunburstChartProps, IndicatorChartProps, MemberFilterTileProps, CriteriaFilterTileProps, DateRangeFilterTileProps, ChartWidgetProps, TableWidgetProps, TableProps, CustomSisenseContextProviderProps, ExecuteQueryByWidgetIdParams, ExecuteQueryParams, GetWidgetModelParams, ExecuteCsvQueryParams, GetSharedFormulaParams, GetDashboardModelParams, UseGetSharedFormulaParams, GetDashboardModelsParams, DrilldownBreadcrumbsProps, BoxplotChartProps, AreamapChartProps, SisenseContextProviderProps, ThemeProviderProps, ScattermapChartProps, } from '@sisense/sdk-ui-preact';
+export * from './sdk-ui-core-exports';

package/dist/src/providers/index.d.ts

@@ -1,2 +1,2 @@
-export { SisenseContextProvider, createSisenseContextConnector } from './sisense-context-provider';
+export { SisenseContextProvider, createSisenseContextConnector, getApp, } from './sisense-context-provider';
 export { ThemeProvider, createThemeContextConnector } from './theme-provider';

package/dist/src/providers/sisense-context-provider.d.ts

@@ -1,13 +1,15 @@
-import type { PropType } from 'vue';
+import type { PropType, Ref } from 'vue';
 import { ClientApplication } from '@sisense/sdk-ui-preact';
 /**
  * Gets Sisense application
+ * @internal
  */
-export declare const getApp: () => Promise<ClientApplication>;
+export declare const getApp: () => Ref<ClientApplication | undefined>;
 /**
  * Creates Sisense context connector
+ * @internal
  */
-export declare const createSisenseContextConnector: () => {
+export declare const createSisenseContextConnector: (app: ClientApplication) => {
     prepareContext(): Promise<{
         app: ClientApplication;
         isInitialized: boolean;
@@ -15,8 +17,51 @@ export declare const createSisenseContextConnector: () => {
     renderContextProvider: (contextData: import("@sisense/sdk-ui-preact").CustomSisenseContext | undefined, children: import("preact").VNode<{}>, error?: Error | undefined) => import("preact").VNode<{}>;
 };
 /**
- * Sisense Context Provider
+ * Sisense Context Provider Component allowing you to connect to
+ * a Sisense instance and provide that context
+ * to all Compose SDK components in your application.
  *
+ * @example
+ * Here's how to use the `SisenseContextProvider` component to wrap your Sisense-enabled application:
+ * Add SisenseContextProvider to the main component of your app as below and then wrap
+ * other SDK components inside this component.
+ * ```vue
+ * <template>
+ *   <SisenseContextProvider
+ *     :url="sisenseUrl"
+ *     :defaultDataSource="defaultDataSource"
+ *     :ssoEnabled="true"
+ *     :token="authToken"
+ *     :wat="watToken"
+ *     :appConfig="appConfigurations"
+ *     :showRuntimeErrors="true"
+ *     :enableTracking="false"
+ *   >
+ *     <!-- Your application components here -->
+ *   </SisenseContextProvider>
+ * </template>
+ *
+ * <script>
+ * import { ref } from 'vue';
+ * import SisenseContextProvider from './SisenseContextProvider.vue';
+ *
+ * export default {
+ *   components: { SisenseContextProvider },
+ *   setup() {
+ *     const sisenseUrl = ref('https://your-sisense-instance.com');
+ *     const defaultDataSource = ref('default_datasource_id');
+ *     const authToken = ref('your_auth_token');
+ *     const watToken = ref('your_wat_token');
+ *     const appConfigurations = ref({});
+ *
+ *     return { sisenseUrl, defaultDataSource, authToken, watToken, appConfigurations };
+ *   }
+ * };
+ * </script>
+ * ```
+ *
+ * @param props - Sisense context provider props
+ * @returns A Sisense Context Provider Component
  */
 export declare const SisenseContextProvider: import("vue").DefineComponent<{
     defaultDataSource: PropType<string | undefined>;
@@ -35,7 +80,7 @@ export declare const SisenseContextProvider: import("vue").DefineComponent<{
     enableTracking: PropType<boolean | undefined>;
 }, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
     [key: string]: any;
-}>[] | null | undefined, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+}>[] | undefined, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     defaultDataSource: PropType<string | undefined>;
     url: PropType<string>;
     ssoEnabled: PropType<boolean | undefined>;

package/dist/src/providers/theme-provider.d.ts

@@ -1,8 +1,9 @@
-import type { PropType } from 'vue';
+import type { PropType, Ref } from 'vue';
+import type { CompleteThemeSettings } from '@sisense/sdk-ui-preact';
 /**
  * Gets Theme context
  */
-export declare const getThemeContext: () => {
+export declare const getThemeContext: () => Ref<{
     chart: {
         textColor: string;
         secondaryTextColor: string;
@@ -23,11 +24,11 @@ export declare const getThemeContext: () => {
         primaryButtonTextColor: string;
         primaryButtonHoverColor: string;
     };
-};
+}> | undefined;
 /**
  * Creates theme context connector
  */
-export declare const createThemeContextConnector: () => {
+export declare const createThemeContextConnector: (themeSettings?: CompleteThemeSettings) => {
     prepareContext(): Promise<{
         themeSettings: {
             chart: {
@@ -80,7 +81,61 @@ export declare const createThemeContextConnector: () => {
     }, children: import("preact").VNode<{}>, error?: Error | undefined) => import("preact").VNode<{}>;
 };
 /**
- * Theme Provider
+ * Theme provider, which allows you to adjust the look and feel of child components.
+ *
+ * @example
+ * Example of a theme provider, which changes the colors and font of the nested indicator chart:
+ * ```vue
+ * <template>
+ *   <ThemeProvider :theme="customTheme">
+ *     <IndicatorChart .... />
+ *   </ThemeProvider>
+ * </template>
+ *
+ * <script>
+ * import { ref } from 'vue';
+ * import ThemeProvider from './ThemeProvider.vue';
+ *
+ * export default {
+ *   components: { ThemeProvider },
+ *   setup() {
+ *     const customTheme = ref({
+         chart: {
+           backgroundColor: '#333333',
+           textColor: 'orange',
+           secondaryTextColor: 'purple',
+         },
+         typography: {
+           fontFamily: 'impact',
+         },
+ *     });
+ *
+ *     return { customTheme };
+ *   }
+ * };
+ * </script>
+ * ```
+ *
+ * Alternatively, to fetch theme settings based on a theme ID:
+ * ```vue
+ * <template>
+ *   <ThemeProvider :theme="'theme_id_string'">
+ *     <!-- Components that will use the fetched theme settings -->
+ *   </ThemeProvider>
+ * </template>
+ * ```
+ *
+ * Indicator chart with custom theme settings:
+ * <img src="media://indicator-chart-example-2.png" width="400px" />
+ *
+ *
+ * For comparison, indicator chart with default theme settings:
+ *
+ * <img src="media://indicator-chart-example-1.png" width="400px" />
+ * @see {@link ThemeSettings} and {@link IndicatorChart}
+ * @param props - Theme provider props
+ * @returns A Theme Provider component * @prop {Object | String} theme - Theme settings object for custom themes or a string identifier to fetch theme settings. When provided as an object, it merges with the default theme settings. When provided as a string, it attempts to fetch theme settings using the provided ID.
+ * @prop {Boolean} skipTracking [internal] - Specifies whether to skip tracking of theme usage. Intended for internal use and debugging purposes.
  */
 export declare const ThemeProvider: import("vue").DefineComponent<{
     theme: PropType<string | import("@sisense/sdk-ui-preact").ThemeSettings | undefined>;
@@ -90,7 +145,7 @@ export declare const ThemeProvider: import("vue").DefineComponent<{
     skipTracking: PropType<boolean | undefined>;
 }, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
     [key: string]: any;
-}>[] | null | undefined, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+}>[] | undefined, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     theme: PropType<string | import("@sisense/sdk-ui-preact").ThemeSettings | undefined>;
     /**
      * @internal

package/dist/src/sdk-ui-core-exports.d.ts

@@ -0,0 +1,5 @@
+export { boxWhiskerProcessResult } from '@sisense/sdk-ui-preact';
+export type { ChartType, CartesianChartType, CategoricalChartType, ScatterChartType, IndicatorChartType, BoxplotChartType, ScattermapChartType, AreamapChartType, TableType, AreaSubtype, LineSubtype, PieSubtype, PolarSubtype, StackableSubtype, BoxplotSubtype, WidgetType, CartesianWidgetType, CategoricalWidgetType, TabularWidgetType, AreaChartProps, BarChartProps, ChartProps, LineChartProps, ColumnChartProps, FunnelChartProps, PolarChartProps, ScatterChartProps, PieChartProps, TreemapChartProps, SunburstChartProps, IndicatorChartProps, MemberFilterTileProps, CriteriaFilterTileProps, DateRangeFilterTileProps, ChartWidgetProps, TableWidgetProps, TableProps, PivotTableProps, DrilldownBreadcrumbsProps, BoxplotChartProps, AreamapChartProps, ScattermapChartProps, SisenseContextProviderProps, ExecuteQueryByWidgetIdParams, ExecuteQueryParams, GetWidgetModelParams, ExecuteCsvQueryParams, GetSharedFormulaParams, GetDashboardModelParams, UseGetSharedFormulaParams, GetDashboardModelsParams, ChartDataOptions, CartesianChartDataOptions, CategoricalChartDataOptions, ScatterChartDataOptions, IndicatorChartDataOptions, BoxplotChartDataOptions, BoxplotChartCustomDataOptions, ScattermapChartDataOptions, AreamapChartDataOptions, TableDataOptions, PivotTableDataOptions, WidgetDataOptions, NumberFormatConfig, DecimalScale, DataColorCondition, ConditionalDataColorOptions, DataColorOptions, RangeDataColorOptions, UniformDataColorOptions, ValueToColorMap, MultiColumnValueToColorMap, SortDirection, BoxWhiskerType, ScattermapLocationLevel, StyledColumn, StyledMeasureColumn, ChartStyleOptions, LineStyleOptions, AreaStyleOptions, StackableStyleOptions, PieStyleOptions, FunnelStyleOptions, PolarStyleOptions, IndicatorStyleOptions, NumericSimpleIndicatorStyleOptions, NumericBarIndicatorStyleOptions, GaugeIndicatorStyleOptions, ScatterStyleOptions, TreemapStyleOptions, SunburstStyleOptions, BoxplotStyleOptions, ScattermapStyleOptions, AreamapStyleOptions, ChartWidgetStyleOptions, WidgetStyleOptions, DashboardWidgetStyleOptions, TableStyleOptions, PivotTableStyleOptions, DataLimits, Legend, Markers, Labels, IndicatorComponents, ScatterMarkerSize, LineWidth, AxisLabel, Convolution, SeriesLabels, X2Title, ScattermapMarkers, WidgetModel, DashboardModel, BeforeRenderHandler, DataPoint, ScatterDataPoint, HighchartsOptions, BoxplotDataPoint, AppConfig, DateConfig, MenuItemSection, MonthOfYear, DayOfWeek, DateLevel, ThemeOid, GetDashboardModelOptions, GetDashboardModelsOptions, SeriesChartType, MenuPosition, ThemeSettings, Color, ColorPaletteTheme, Navigator, DrilldownOptions, DrilldownSelection, CriteriaFilterType, Member, FilterVariant, } from '@sisense/sdk-ui-preact';
+import type { ContextMenuProps as ContextMenuPropsPreact, ThemeProviderProps as ThemeProviderPropsPreact } from '@sisense/sdk-ui-preact';
+export type ContextMenuProps = Omit<ContextMenuPropsPreact, 'children'>;
+export type ThemeProviderProps = Omit<ThemeProviderPropsPreact, 'children'>;

package/dist/src/utils.d.ts

@@ -1,3 +1,6 @@
 import type { MaybeRef, MaybeWithRefs } from './types';
 export declare function toPlainValue<T>(value: MaybeRef<T>): T;
+export declare function toPlainValues<T extends object>(refObj: T): {
+    [K in keyof T]: T[K] extends MaybeRef<infer R> ? R : T[K];
+};
 export declare function collectRefs<T extends {}>(objectWithRefs: MaybeWithRefs<T>): unknown[];

package/package.json

@@ -11,7 +11,7 @@
     "Sisense",
     "Compose SDK"
   ],
-  "version": "1.3.0",
+  "version": "1.4.1",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

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

@@ -1,6 +0,0 @@
-export { useExecuteQuery } from './use-execute-query';
-export { useExecuteQueryByWidgetId } from './use-execute-query-by-widget-id';
-export { useGetDashboardModel } from './use-get-dashboard-model';
-export { useGetDashboardModels } from './use-get-dashboard-models';
-export { useGetSharedFormula } from './use-get-shared-formula';
-export { useGetWidgetModel } from './use-get-widget-model';

package/dist/src/hooks/use-execute-query-by-widget-id.d.ts

@@ -1,7 +0,0 @@
-import type { ExecuteQueryByWidgetIdParams } from '@sisense/sdk-ui-preact';
-export declare const useExecuteQueryByWidgetId: (params: ExecuteQueryByWidgetIdParams) => Promise<{
-    data: {
-        data: import("@sisense/sdk-data").QueryResultData;
-        query: import("@sisense/sdk-ui/dist/query/execute-query").QueryDescription;
-    };
-}>;

package/dist/src/hooks/use-execute-query.d.ts

@@ -1,11 +0,0 @@
-import { type ToRefs } from 'vue';
-import { type ExecuteQueryParams, type QueryState } from '@sisense/sdk-ui-preact';
-import type { MaybeWithRefs } from '../types';
-/**
- * A hook function that executes a data query.
- * TODO Document
- *
- *
- * @returns TODO
- */
-export declare const useExecuteQuery: (params: MaybeWithRefs<ExecuteQueryParams>) => ToRefs<QueryState>;

package/dist/src/hooks/use-get-dashboard-model.d.ts

@@ -1,4 +0,0 @@
-import type { GetDashboardModelParams } from '@sisense/sdk-ui-preact';
-export declare const useGetDashboardModel: (params: GetDashboardModelParams) => Promise<{
-    data: import("@sisense/sdk-ui-preact").DashboardModelState;
-}>;

package/dist/src/hooks/use-get-dashboard-models.d.ts

@@ -1,4 +0,0 @@
-import type { GetDashboardModelsParams } from '@sisense/sdk-ui-preact';
-export declare const useGetDashboardModels: (params: GetDashboardModelsParams) => Promise<{
-    data: import("@sisense/sdk-ui-preact").DashboardModelsState;
-}>;

package/dist/src/hooks/use-get-shared-formula.d.ts

@@ -1,4 +0,0 @@
-import type { GetSharedFormulaParams } from '@sisense/sdk-ui-preact';
-export declare const useGetSharedFormula: (params: GetSharedFormulaParams) => Promise<{
-    data: import("@sisense/sdk-ui-preact").SharedFormulaState;
-}>;

package/dist/src/hooks/use-get-widget-model.d.ts

@@ -1,4 +0,0 @@
-import type { GetWidgetModelParams } from '@sisense/sdk-ui-preact';
-export declare const useGetWidgetModel: (params: GetWidgetModelParams) => Promise<{
-    data: import("@sisense/sdk-ui-preact").WidgetModelState;
-}>;