@sisense/sdk-ui-vue 1.2.0 → 1.4.0

package/dist/src/components/drilldown-breadcrumbs.d.ts

@@ -1,4 +1,45 @@
 import type { PropType } from 'vue';
+/**
+ * `DrilldownBreadcrumbs` component from the `@sisense/sdk-ui-vue` package.
+ * This component provides a way to display and interact with the drilldown path in data visualization components,
+ * allowing users to navigate through different levels of data drilldowns. It includes functionalities to clear selections
+ * or slice through the drilldown selections for a more intuitive data exploration experience.
+ *
+ * @example
+ * Here's how to use the `DrilldownBreadcrumbs` component:
+ * ```vue
+ * <template>
+ *   <DrilldownBreadcrumbs
+ *     :clearDrilldownSelections="clearSelections"
+ *     :currentDimension="currentDimension"
+ *     :sliceDrilldownSelections="sliceSelections"
+ *     :filtersDisplayValues="filtersDisplayValues"
+ *   />
+ * </template>
+ *
+ * <script>
+ * import { ref } from 'vue';
+ * import DrilldownBreadcrumbs from './DrilldownBreadcrumbs.vue';
+ *
+ * export default {
+ *   components: { DrilldownBreadcrumbs },
+ *   setup() {
+ *     const clearSelections = () => {};
+ *     const currentDimension = ref({<current dimension object>});
+ *     const sliceSelections = (index) => { <logic to slice selections up to index> };
+ *     const filtersDisplayValues = ref({<object mapping filter values to display values>});
+ *
+ *     return { clearSelections, currentDimension, sliceSelections, filtersDisplayValues };
+ *   }
+ * };
+ * </script>
+ * ```
+ *
+ * @prop {Function} clearDrilldownSelections - Function to clear all drilldown selections made by the user.
+ * @prop {Object} currentDimension - Object representing the current dimension in the drilldown path.
+ * @prop {Function} sliceDrilldownSelections - Function to slice the drilldown selections up to a certain index, allowing the user to navigate back in the drilldown path.
+ * @prop {Object} filtersDisplayValues - Object mapping the internal filter values to human-readable display values, enhancing the usability of the breadcrumbs.
+ */
 export declare const DrilldownBreadcrumbs: import("vue").DefineComponent<{
     clearDrilldownSelections: PropType<() => void>;
     currentDimension: PropType<import("@sisense/sdk-data").Attribute>;

package/dist/src/components/drilldown-widget.d.ts

@@ -0,0 +1,44 @@
+import type { Component, PropType } from 'vue';
+import type { ContextMenuProps } from '@sisense/sdk-ui-preact';
+export type DrilldownWidgetConfig = {
+    isBreadcrumbsDetached?: boolean;
+    breadcrumbsComponent?: Component;
+    contextMenuComponent?: (props: ContextMenuProps) => Component;
+};
+export declare const DrilldownWidgetTs: import("vue").DefineComponent<{
+    config: {
+        type: PropType<DrilldownWidgetConfig>;
+        required: false;
+        default: () => {};
+    };
+    drilldownDimensions: {
+        type: PropType<import("@sisense/sdk-data").Attribute[]>;
+        required: false;
+        default: () => never[];
+    };
+    initialDimension: {
+        type: PropType<import("@sisense/sdk-data").Attribute>;
+        required: false;
+        default: () => {};
+    };
+}, void, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    config: {
+        type: PropType<DrilldownWidgetConfig>;
+        required: false;
+        default: () => {};
+    };
+    drilldownDimensions: {
+        type: PropType<import("@sisense/sdk-data").Attribute[]>;
+        required: false;
+        default: () => never[];
+    };
+    initialDimension: {
+        type: PropType<import("@sisense/sdk-data").Attribute>;
+        required: false;
+        default: () => {};
+    };
+}>>, {
+    drilldownDimensions: import("@sisense/sdk-data").Attribute[];
+    initialDimension: import("@sisense/sdk-data").Attribute;
+    config: DrilldownWidgetConfig;
+}, {}>;

package/dist/src/components/drilldown-widget.vue.d.ts

@@ -1,46 +1,4 @@
-import type { Component, PropType } from 'vue';
-import type { ContextMenuProps } from '@sisense/sdk-ui-preact';
-import type { Attribute } from '@sisense/sdk-data';
-type DrilldownWidgetConfig = {
-    isBreadcrumbsDetached?: boolean;
-    breadcrumbsComponent?: Component;
-    contextMenuComponent?: (props: ContextMenuProps) => Component;
-};
-declare const _sfc_main: import("vue").DefineComponent<{
-    config: {
-        type: PropType<DrilldownWidgetConfig>;
-        required: false;
-        default: () => {};
-    };
-    drilldownDimensions: {
-        type: PropType<Attribute[]>;
-        required: false;
-        default: () => never[];
-    };
-    initialDimension: {
-        type: PropType<Attribute>;
-        required: false;
-        default: () => {};
-    };
-}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    config: {
-        type: PropType<DrilldownWidgetConfig>;
-        required: false;
-        default: () => {};
-    };
-    drilldownDimensions: {
-        type: PropType<Attribute[]>;
-        required: false;
-        default: () => never[];
-    };
-    initialDimension: {
-        type: PropType<Attribute>;
-        required: false;
-        default: () => {};
-    };
-}>>, {
-    drilldownDimensions: Attribute[];
-    initialDimension: Attribute;
-    config: DrilldownWidgetConfig;
+declare const _sfc_main: import("vue").DefineComponent<any, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<any>, {} | {
+    [x: string]: any;
 }, {}>;
 export default _sfc_main;

package/dist/src/components/filters/basic-member-filter-tile.d.ts

@@ -19,6 +19,7 @@ import type { PropType } from 'vue';
  * });
  * </script>
  * ```
+ * @internal
  */
 export declare const BasicMemberFilterTile: import("vue").DefineComponent<{
     allMembers: PropType<import("@sisense/sdk-ui-preact").Member[]>;

package/dist/src/components/filters/criteria-filter-tile.d.ts

@@ -1,24 +1,39 @@
 import type { PropType } from 'vue';
 /**
- * A Vue component that wraps the CriteriaFilterTile Preact component for use in Vue applications.
- * It maintains compatibility with Vue's reactivity system while preserving the functionality of the CriteriaFilterTile.
+ * UI component that allows the user to filter numeric or text attributes according to
+ * a number of built-in operations defined in the {@link NumericFilter}, {@link TextFilter}, or {@link RankingFilter}.
+ *
+ * The arrangement prop determines whether the filter is rendered vertically or horizontally, with the latter intended for toolbar use and omitting title, enable/disable, and collapse/expand functionality.
  *
  * @example
  * Here's how you can use the CriteriaFilterTile component in a Vue application:
  * ```vue
  * <template>
- *   <CriteriaFilterTile :props="criteriaFilterTileProps" />
+ *   <CriteriaFilterTile
+ *     :title="criteriaFilterTileProps.title"
+ *     :filter="criteriaFilterTileProps.filter"
+ *     :onUpdate="onUpdate"
+ *   />
  * </template>
  *
  * <script setup lang="ts">
  * import { ref } from 'vue';
  * import {CriteriaFilterTile} from '@sisense/sdk-ui-vue';
+ * import { filterFactory } from '@sisense/sdk-data';
  *
  * const criteriaFilterTileProps = ref({
- *   // Configure your CriteriaFilterTileProps here
+ *  title: 'Revenue',
+ *  filter: filterFactory.greaterThanOrEqual(DM.Commerce.Revenue, 10000)
  * });
+ *
+ * const onUpdate = (filter: Filter | null) => {
+ *  ...
+ * }
  * </script>
  * ```
+ * <img src="media://criteria-filter-tile-example-1.png" width="300px" />
+ * @param props - Criteria filter tile props
+ * @returns Criteria filter tile component
  */
 export declare const CriteriaFilterTile: import("vue").DefineComponent<{
     arrangement: PropType<import("@sisense/sdk-ui-preact").FilterVariant | undefined>;

package/dist/src/components/filters/date-range-filter-tile.d.ts

@@ -1,13 +1,16 @@
 import type { PropType } from 'vue';
 /**
- * A Vue component that wraps the DateRangeFilterTile Preact component for use in Vue applications.
- * It maintains compatibility with Vue's reactivity system while preserving the functionality of the DateRangeFilterTile.
+ * Date Range Filter Tile component for filtering data by date range.
  *
  * @example
- * Here's how you can use the DateRangeFilterTile component in a Vue application:
+ * Vue example of configuring the date min max values and handling onChange event.
  * ```vue
  * <template>
- *   <DateRangeFilterTile :props="dateRangeFilterTileProps" />
+ *   <DateRangeFilterTile
+ *     :title="dateRangeFilterTileProps.title"
+ *     :attribute="dateRangeFilterTileProps.attribute"
+ *     :filter="dateRangeFilterTileProps.filter"
+ *     :onChange="onChange" />
  * </template>
  *
  * <script setup lang="ts">
@@ -15,8 +18,14 @@ import type { PropType } from 'vue';
  * import {CriteriaFilterTile} from '@sisense/sdk-ui-vue';
  *
  * const dateRangeFilterTileProps = ref({
- *   // Configure your dateRangeFilterTileProps
+ *   title: 'Date Range',
+ *   attribute: DM.Commerce.Date.Years,
+ *   filter: filterFactory.dateRange(DM.Commerce.Date.Years),
  * });
+ *
+ * const onChange = (filter: Filter) => {
+ *  ...
+ * }
  * </script>
  * ```
  */

package/dist/src/components/filters/member-filter-tile.d.ts

@@ -1,13 +1,19 @@
 import type { PropType } from 'vue';
 /**
- * A Vue component that wraps the MemberFilterTile Preact component for use in Vue applications.
- * It maintains compatibility with Vue's reactivity system while preserving the functionality of the MemberFilterTile.
+ * UI component that allows the user to select members to include/exclude in a
+ * filter. A query is executed against the provided data source to fetch
+ * all members that are selectable.
  *
  * @example
- * Here's how you can use the MemberFilterTile component in a Vue application:
+ * Below is an example for filtering countries in the `Country` dimension of the `Sample ECommerce` data model.
  * ```vue
  * <template>
- *   <MemberFilterTile :props="memberFilterTileProps" />
+ * <MemberFilterTile
+ *   :title="memberFilterTileProps.title"
+ *   :attribute="memberFilterTileProps.attribute"
+ *   :filter="memberFilterTileProps.filter"
+ *   :onChange={setCountryFilter}
+ * />
  * </template>
  *
  * <script setup lang="ts">
@@ -15,8 +21,13 @@ import type { PropType } from 'vue';
  * import MemberFilterTile from '@sisense/sdk-ui-vue/MemberFilterTile';
  *
  * const memberFilterTileProps = ref({
- *   // Configure your MemberFilterTileProps here
+ *   title: 'Country',
+ *   attribute: DM.Country.Country,
+ *   filter: countryFilter,
  * });
+ *
+ * const setCountryFilter = (filter: Filter | null) => {...}
+ *
  * </script>
  * ```
  */

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

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

package/dist/src/{hooks → composables}/use-custom-drilldown.d.ts

@@ -12,12 +12,31 @@ export declare const useCustomDrilldown: ({ drilldownDimensions, initialDimensio
     sliceDrilldownSelections: (i: number) => void;
     clearDrilldownSelections: () => void;
     drilldownSelections: Ref<{
-        points: {
+        points: ({
             value?: string | number | undefined;
             categoryValue?: string | number | undefined;
             categoryDisplayValue?: string | undefined;
             seriesValue?: string | number | undefined;
-        }[];
+        } | {
+            x?: string | number | undefined;
+            y?: string | number | undefined;
+            size?: number | undefined;
+            breakByPoint?: string | undefined;
+            breakByColor?: string | undefined;
+        } | {
+            boxMin: number;
+            boxMedian: number;
+            boxMax: number;
+            whiskerMin: number;
+            whiskerMax: number;
+            categoryValue?: string | number | undefined;
+            categoryDisplayValue?: string | undefined;
+        } | {
+            geoName: string;
+            originalValue: number;
+            formattedOriginalValue: string;
+            color?: import("@sisense/sdk-ui-preact").Color | undefined;
+        })[];
         nextDimension: {
             readonly expression: string;
             getSort: () => import("@sisense/sdk-data").Sort;

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/helpers/use-reducer.d.ts

@@ -0,0 +1,10 @@
+import { type Ref } from 'vue';
+type State = Record<string, unknown>;
+type Action = {
+    type: string;
+};
+type Dispatch<A extends Action> = (action: A) => void;
+type Reducer<S extends State, A extends Action> = (state: S, action: A) => S;
+type ReturnValue<S extends State, A extends Action> = [Ref<S>, Dispatch<A>];
+export declare function useReducer<S extends State, A extends Action>(reducer: Reducer<S, A>, initialState: S): ReturnValue<S, A>;
+export {};

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';