@sisense/sdk-ui-angular 2.9.0 → 2.10.0

package/dist/ai/lib/services/ai.service.d.ts

@@ -59,8 +59,8 @@ export declare const AI_CONTEXT_CONFIG_TOKEN: InjectionToken<AiContextConfig>;
  */
 export declare class AiService {
     private sisenseContextService;
-    private apiPromise;
-    constructor(sisenseContextService: SisenseContextService, aiContextConfig?: AiContextConfig);
+    private aiContextConfig?;
+    constructor(sisenseContextService: SisenseContextService, aiContextConfig?: AiContextConfig | undefined);
     /** @internal */
     getApi(): Promise<ChatRestApi>;
     /**

package/dist/esm2020/ai/lib/services/ai.service.mjs

@@ -50,13 +50,13 @@ export const AI_CONTEXT_CONFIG_TOKEN = new InjectionToken('AI Context Config');
 let AiService = class AiService {
     constructor(sisenseContextService, aiContextConfig) {
         this.sisenseContextService = sisenseContextService;
-        this.apiPromise = this.sisenseContextService
-            .getApp()
-            .then((app) => new ChatRestApi(app.httpClient, aiContextConfig?.volatile));
+        this.aiContextConfig = aiContextConfig;
     }
     /** @internal */
     getApi() {
-        return this.apiPromise;
+        return this.sisenseContextService
+            .getApp()
+            .then((app) => new ChatRestApi(app.httpClient, this.aiContextConfig?.volatile));
     }
     /**
      * Fetches an analysis of the provided query using natural language generation (NLG).
@@ -131,4 +131,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                     type: Inject,
                     args: [AI_CONTEXT_CONFIG_TOKEN]
                 }] }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ai.service.js","sourceRoot":"","sources":["../../../../../src/ai/lib/services/ai.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport { SisenseContextService, TrackableService, WidgetProps } from '@sisense/sdk-ui-angular';\nimport {\n  AiContextProviderProps,\n  ChatRestApi,\n  DEFAULT_RECOMMENDATIONS_COUNT,\n  GetNlgInsightsResponse,\n  GetNlqResultParams,\n  GetQueryRecommendationsParams,\n  prepareGetNlgInsightsPayload,\n  prepareGetNlqResultPayload,\n  QueryRecommendation as QueryRecommendationPreact,\n  UseGetNlgInsightsParams,\n  widgetComposer,\n} from '@sisense/sdk-ui-preact/ai';\n\nexport interface AiContextConfig extends Omit<AiContextProviderProps, 'children'> {}\nexport interface GetNlgInsightsParams extends Omit<UseGetNlgInsightsParams, 'enabled'> {}\n\n/**\n * {@inheritDoc @sisense/sdk-ui!QueryRecommendation}\n */\nexport interface QueryRecommendation extends Omit<QueryRecommendationPreact, 'widgetProps'> {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!QueryRecommendation.widgetProps}\n   */\n  widgetProps?: WidgetProps;\n}\n\n/**\n * Token used to inject {@link AiContextConfig} into your application.\n *\n * @example\n * Example of importing {@link SdkAiModule} and injecting {@link AiContextConfig} into your application,\n * along with importing dependency {@link SdkUiModule} and injecting {@link SisenseContextConfig} to connect to a Sisense instance:\n *\n * ```ts\n * import { SdkUiModule, SisenseContextConfig } from '@sisense/sdk-ui-angular';\n * import { SdkAiModule, AI_CONTEXT_CONFIG_TOKEN, AiContextConfig } from '@sisense/sdk-ui-angular/ai';\n *\n * const AI_CONTEXT_CONFIG: AiContextConfig = {\n *   volatile: true,\n * };\n * const SISENSE_CONTEXT_CONFIG: SisenseContextConfig = {\n *   url: \"<instance url>\", // replace with the URL of your Sisense instance\n *   token: \"<api token>\", // replace with the API token of your user account\n *   defaultDataSource: DM.DataSource,\n * };\n *\n * @NgModule({\n *   imports: [\n *     BrowserModule,\n *     SdkUiModule,\n *     SdkAiModule,\n *   ],\n *   declarations: [AppComponent],\n *   providers: [\n *     { provide: AI_CONTEXT_CONFIG_TOKEN, useValue: AI_CONTEXT_CONFIG },\n *     { provide: SISENSE_CONTEXT_CONFIG_TOKEN, useValue: SISENSE_CONTEXT_CONFIG },\n *   ],\n *   bootstrap: [AppComponent],\n * })\n * ```\n * @group Generative AI\n */\nexport const AI_CONTEXT_CONFIG_TOKEN = new InjectionToken<AiContextConfig>('AI Context Config');\n\n/**\n * Service for working with Sisense Fusion Generative AI.\n *\n * @group Generative AI\n */\n@Injectable({\n  providedIn: 'root',\n})\n@TrackableService<AiService>(['getNlgInsights', 'getQueryRecommendations'])\nexport class AiService {\n  private apiPromise: Promise<ChatRestApi>;\n\n  constructor(\n    private sisenseContextService: SisenseContextService,\n    @Optional() @Inject(AI_CONTEXT_CONFIG_TOKEN) aiContextConfig?: AiContextConfig,\n  ) {\n    this.apiPromise = this.sisenseContextService\n      .getApp()\n      .then((app) => new ChatRestApi(app.httpClient, aiContextConfig?.volatile));\n  }\n\n  /** @internal */\n  getApi(): Promise<ChatRestApi> {\n    return this.apiPromise;\n  }\n\n  /**\n   * Fetches an analysis of the provided query using natural language generation (NLG).\n   * Specifying NLG parameters is similar to providing parameters to the {@link QueryService.executeQuery} service method, using dimensions, measures, and filters.\n   *\n   * @param params - Parameters for getting NLG insights\n   * @returns NLG insights text summary\n   */\n  async getNlgInsights(params: GetNlgInsightsParams): Promise<string | undefined> {\n    const api = await this.getApi();\n    const payload = prepareGetNlgInsightsPayload(params);\n    return api.ai\n      .getNlgInsights(payload)\n      .then((response?: GetNlgInsightsResponse) => response?.data?.answer);\n  }\n\n  /**\n   * Fetches recommended questions for a data model or perspective.\n   *\n   * @param params - Parameters for recommendations\n   * @returns An array of objects, each containing recommended question text and its corresponding `widgetProps`\n   * @beta\n   */\n  async getQueryRecommendations(\n    params: GetQueryRecommendationsParams,\n  ): Promise<QueryRecommendation[]> {\n    const api = await this.getApi();\n    const { contextTitle, count, enableAxisTitlesInWidgetProps, customPrompt } = params;\n    const recCount = count ?? DEFAULT_RECOMMENDATIONS_COUNT;\n\n    const rawRecommendations =\n      (await api.ai.getQueryRecommendations(contextTitle, {\n        numOfRecommendations: recCount,\n        ...(customPrompt ? { userPrompt: customPrompt } : undefined),\n      })) || [];\n\n    return rawRecommendations.map(\n      (recommendation: QueryRecommendationPreact) =>\n        ({\n          ...recommendation,\n          widgetProps: recommendation.jaql\n            ? widgetComposer.toWidgetProps(recommendation, {\n                useCustomizedStyleOptions: enableAxisTitlesInWidgetProps,\n              })\n            : undefined,\n        } as QueryRecommendation),\n    );\n  }\n\n  /**\n   * Executes a natural language query (NLQ) against a data model or perspective\n   *\n   * @param params - NLQ query parameters\n   * @returns The result as WidgetProps\n   * @beta\n   */\n  async getNlqResult(params: GetNlqResultParams): Promise<WidgetProps | undefined> {\n    const { contextTitle, request } = prepareGetNlqResultPayload(params);\n    const api = await this.getApi();\n\n    const data = await api?.ai.getNlqResult(contextTitle, request);\n\n    return data\n      ? (widgetComposer.toWidgetProps(data, {\n          useCustomizedStyleOptions: params.enableAxisTitlesInWidgetProps || false,\n        }) as WidgetProps)\n      : undefined;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ai.service.js","sourceRoot":"","sources":["../../../../../src/ai/lib/services/ai.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport { SisenseContextService, TrackableService, WidgetProps } from '@sisense/sdk-ui-angular';\nimport {\n  AiContextProviderProps,\n  ChatRestApi,\n  DEFAULT_RECOMMENDATIONS_COUNT,\n  GetNlgInsightsResponse,\n  GetNlqResultParams,\n  GetQueryRecommendationsParams,\n  prepareGetNlgInsightsPayload,\n  prepareGetNlqResultPayload,\n  QueryRecommendation as QueryRecommendationPreact,\n  UseGetNlgInsightsParams,\n  widgetComposer,\n} from '@sisense/sdk-ui-preact/ai';\n\nexport interface AiContextConfig extends Omit<AiContextProviderProps, 'children'> {}\nexport interface GetNlgInsightsParams extends Omit<UseGetNlgInsightsParams, 'enabled'> {}\n\n/**\n * {@inheritDoc @sisense/sdk-ui!QueryRecommendation}\n */\nexport interface QueryRecommendation extends Omit<QueryRecommendationPreact, 'widgetProps'> {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!QueryRecommendation.widgetProps}\n   */\n  widgetProps?: WidgetProps;\n}\n\n/**\n * Token used to inject {@link AiContextConfig} into your application.\n *\n * @example\n * Example of importing {@link SdkAiModule} and injecting {@link AiContextConfig} into your application,\n * along with importing dependency {@link SdkUiModule} and injecting {@link SisenseContextConfig} to connect to a Sisense instance:\n *\n * ```ts\n * import { SdkUiModule, SisenseContextConfig } from '@sisense/sdk-ui-angular';\n * import { SdkAiModule, AI_CONTEXT_CONFIG_TOKEN, AiContextConfig } from '@sisense/sdk-ui-angular/ai';\n *\n * const AI_CONTEXT_CONFIG: AiContextConfig = {\n *   volatile: true,\n * };\n * const SISENSE_CONTEXT_CONFIG: SisenseContextConfig = {\n *   url: \"<instance url>\", // replace with the URL of your Sisense instance\n *   token: \"<api token>\", // replace with the API token of your user account\n *   defaultDataSource: DM.DataSource,\n * };\n *\n * @NgModule({\n *   imports: [\n *     BrowserModule,\n *     SdkUiModule,\n *     SdkAiModule,\n *   ],\n *   declarations: [AppComponent],\n *   providers: [\n *     { provide: AI_CONTEXT_CONFIG_TOKEN, useValue: AI_CONTEXT_CONFIG },\n *     { provide: SISENSE_CONTEXT_CONFIG_TOKEN, useValue: SISENSE_CONTEXT_CONFIG },\n *   ],\n *   bootstrap: [AppComponent],\n * })\n * ```\n * @group Generative AI\n */\nexport const AI_CONTEXT_CONFIG_TOKEN = new InjectionToken<AiContextConfig>('AI Context Config');\n\n/**\n * Service for working with Sisense Fusion Generative AI.\n *\n * @group Generative AI\n */\n@Injectable({\n  providedIn: 'root',\n})\n@TrackableService<AiService>(['getNlgInsights', 'getQueryRecommendations'])\nexport class AiService {\n  constructor(\n    private sisenseContextService: SisenseContextService,\n    @Optional() @Inject(AI_CONTEXT_CONFIG_TOKEN) private aiContextConfig?: AiContextConfig,\n  ) {}\n\n  /** @internal */\n  getApi(): Promise<ChatRestApi> {\n    return this.sisenseContextService\n      .getApp()\n      .then((app) => new ChatRestApi(app.httpClient, this.aiContextConfig?.volatile));\n  }\n\n  /**\n   * Fetches an analysis of the provided query using natural language generation (NLG).\n   * Specifying NLG parameters is similar to providing parameters to the {@link QueryService.executeQuery} service method, using dimensions, measures, and filters.\n   *\n   * @param params - Parameters for getting NLG insights\n   * @returns NLG insights text summary\n   */\n  async getNlgInsights(params: GetNlgInsightsParams): Promise<string | undefined> {\n    const api = await this.getApi();\n    const payload = prepareGetNlgInsightsPayload(params);\n    return api.ai\n      .getNlgInsights(payload)\n      .then((response?: GetNlgInsightsResponse) => response?.data?.answer);\n  }\n\n  /**\n   * Fetches recommended questions for a data model or perspective.\n   *\n   * @param params - Parameters for recommendations\n   * @returns An array of objects, each containing recommended question text and its corresponding `widgetProps`\n   * @beta\n   */\n  async getQueryRecommendations(\n    params: GetQueryRecommendationsParams,\n  ): Promise<QueryRecommendation[]> {\n    const api = await this.getApi();\n    const { contextTitle, count, enableAxisTitlesInWidgetProps, customPrompt } = params;\n    const recCount = count ?? DEFAULT_RECOMMENDATIONS_COUNT;\n\n    const rawRecommendations =\n      (await api.ai.getQueryRecommendations(contextTitle, {\n        numOfRecommendations: recCount,\n        ...(customPrompt ? { userPrompt: customPrompt } : undefined),\n      })) || [];\n\n    return rawRecommendations.map(\n      (recommendation: QueryRecommendationPreact) =>\n        ({\n          ...recommendation,\n          widgetProps: recommendation.jaql\n            ? widgetComposer.toWidgetProps(recommendation, {\n                useCustomizedStyleOptions: enableAxisTitlesInWidgetProps,\n              })\n            : undefined,\n        } as QueryRecommendation),\n    );\n  }\n\n  /**\n   * Executes a natural language query (NLQ) against a data model or perspective\n   *\n   * @param params - NLQ query parameters\n   * @returns The result as WidgetProps\n   * @beta\n   */\n  async getNlqResult(params: GetNlqResultParams): Promise<WidgetProps | undefined> {\n    const { contextTitle, request } = prepareGetNlqResultPayload(params);\n    const api = await this.getApi();\n\n    const data = await api?.ai.getNlqResult(contextTitle, request);\n\n    return data\n      ? (widgetComposer.toWidgetProps(data, {\n          useCustomizedStyleOptions: params.enableAxisTitlesInWidgetProps || false,\n        }) as WidgetProps)\n      : undefined;\n  }\n}\n"]}

package/dist/esm2020/lib/component-wrapper-helpers/context-connectors.mjs

@@ -28,16 +28,10 @@ export const createThemeContextConnector = (themeService) => {
         providerComponent: CustomThemeProvider,
     };
 };
-/**
- * Creates Sisense context connector
- *
- * @param sisenseContextService - The Sisense context service
- * @internal
- */
-export const createSisenseContextConnector = (sisenseContextService) => {
-    const { showRuntimeErrors, appConfig } = sisenseContextService.getConfig();
-    const defaultSisenseContext = {
-        isInitialized: true,
+function getBaseSisenseContext(sisenseContextService) {
+    const { showRuntimeErrors, appConfig } = sisenseContextService.getConfig() ?? {};
+    return {
+        isInitialized: sisenseContextService.isInitialized,
         tracking: {
             // if tracking is configured in appConfig, use it
             // if none is set, default to true
@@ -48,20 +42,38 @@ export const createSisenseContextConnector = (sisenseContextService) => {
             showErrorBox: showRuntimeErrors ?? true,
         },
     };
+}
+/**
+ * Creates Sisense context connector
+ *
+ * @param sisenseContextService - The Sisense context service
+ * @internal
+ */
+export const createSisenseContextConnector = (sisenseContextService) => {
     const propsObserver = new DataObserver({
-        context: defaultSisenseContext,
+        context: getBaseSisenseContext(sisenseContextService),
     });
-    sisenseContextService
-        .getApp()
-        .then((app) => propsObserver.setValue({
-        context: {
-            ...defaultSisenseContext,
-            app,
+    sisenseContextService.getApp$().subscribe({
+        next: ({ app, error }) => {
+            if (error) {
+                propsObserver.setValue({
+                    error,
+                });
+                return;
+            }
+            propsObserver.setValue({
+                context: {
+                    ...getBaseSisenseContext(sisenseContextService),
+                    app,
+                },
+            });
         },
-    }))
-        .catch((error) => propsObserver.setValue({
-        error,
-    }));
+        error: (error) => {
+            propsObserver.setValue({
+                error,
+            });
+        },
+    });
     return {
         propsObserver,
         providerComponent: CustomSisenseContextProvider,
@@ -95,4 +107,4 @@ export const createCustomWidgetsContextConnector = (customWidgetsService) => {
         providerComponent: CustomWidgetsProviderAdapter,
     };
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/lib/components/widgets/widget-by-id.component.mjs

@@ -9,7 +9,7 @@ import * as i2 from "../../services/theme.service";
  * is used to render a widget created in a Sisense Fusion instance.
  *
  * To learn more about using Sisense Fusion Widgets in Compose SDK, see
- * [Sisense Fusion Widgets](https://sisense.dev/guides/sdk/guides/charts/guide-fusion-widgets.html).
+ * [Sisense Fusion Widgets](https://developer.sisense.com/guides/sdk/guides/charts/guide-fusion-widgets.html).
  *
  * @example
  * ```html
@@ -109,4 +109,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
             }], dataReady: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-by-id.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/widgets/widget-by-id.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EAET,KAAK,EAGL,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,gBAAgB,EAChB,UAAU,IAAI,gBAAgB,GAE/B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,6BAA6B,EAC7B,2BAA2B,EAC3B,MAAM,EACN,MAAM,EACN,QAAQ,GACT,MAAM,iCAAiC,CAAC;;;;AAYzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAMH,MAAM,OAAO,mBAAmB;IAmG9B,YACU,qBAA4C,EAC5C,YAA0B;QAD1B,0BAAqB,GAArB,qBAAqB,CAAuB;QAC5C,iBAAY,GAAZ,YAAY,CAAc;QAElC,IAAI,CAAC,gBAAgB,GAAG,IAAI,gBAAgB,CAAC,gBAAgB,EAAE;YAC7D,6BAA6B,CAAC,IAAI,CAAC,qBAAqB,CAAC;YACzD,2BAA2B,CAAC,IAAI,CAAC,YAAY,CAAC;SAC/C,CAAC,CAAC;IACL,CAAC;IAED,gBAAgB;IAChB,eAAe;QACb,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,IAAI,CAAC,uBAAuB,EAAE,CAAC,CAAC;IAC7F,CAAC;IAED,gBAAgB;IAChB,WAAW;QACT,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,IAAI,CAAC,uBAAuB,EAAE,CAAC,CAAC;SAC5F;IACH,CAAC;IAED,gBAAgB;IACR,uBAAuB;QAC7B,OAAO;YACL,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,uBAAuB,EAAE,IAAI,CAAC,uBAAuB;YACrD,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,0BAA0B,EAAE,IAAI,CAAC,0BAA0B;YAC3D,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;YACvC,WAAW,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC;SACxC,CAAC;IACJ,CAAC;IAED,gBAAgB;IAChB,WAAW;QACT,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC;IAClC,CAAC;;iHA9IU,mBAAmB;qGAAnB,mBAAmB;4FAAnB,mBAAmB;kBAL/B,SAAS;+BACE,mBAAmB,YAC7B,QAAQ;uIAMR,SAAS;sBADR,SAAS;uBAAC,MAAM;gBASjB,SAAS;sBADR,KAAK;gBASN,YAAY;sBADX,KAAK;gBASN,OAAO;sBADN,KAAK;gBASN,UAAU;sBADT,KAAK;gBASN,oBAAoB;sBADnB,KAAK;gBASN,uBAAuB;sBADtB,KAAK;gBASN,KAAK;sBADJ,KAAK;gBASN,WAAW;sBADV,KAAK;gBASN,YAAY;sBADX,KAAK;gBASN,0BAA0B;sBADzB,KAAK;gBAKN,gBAAgB;sBADf,KAAK;gBASN,SAAS;sBADR,KAAK","sourcesContent":["import {\n  AfterViewInit,\n  Component,\n  ElementRef,\n  Input,\n  OnChanges,\n  OnDestroy,\n  ViewChild,\n} from '@angular/core';\nimport {\n  ComponentAdapter,\n  WidgetById as WidgetByIdPreact,\n  type WidgetByIdProps as WidgetByIdPropsPreact,\n} from '@sisense/sdk-ui-preact';\n\nimport {\n  createSisenseContextConnector,\n  createThemeContextConnector,\n  rootId,\n  styles,\n  template,\n} from '../../component-wrapper-helpers';\nimport { SisenseContextService } from '../../services/sisense-context.service';\nimport { ThemeService } from '../../services/theme.service';\nimport { BaseChartEventProps, WithoutPreactChartEventProps } from '../../types';\n\n/**\n * Props of the {@link WidgetByIdComponent}.\n */\nexport interface WidgetByIdProps\n  extends WithoutPreactChartEventProps<WidgetByIdPropsPreact>,\n    BaseChartEventProps {}\n\n/**\n * The `WidgetById` component, which is a thin wrapper on {@link ChartWidgetComponent},\n * is used to render a widget created in a Sisense Fusion instance.\n *\n * To learn more about using Sisense Fusion Widgets in Compose SDK, see\n * [Sisense Fusion Widgets](https://sisense.dev/guides/sdk/guides/charts/guide-fusion-widgets.html).\n *\n * @example\n * ```html\n * <csdk-widget-by-id\n *    [widgetOid]=\"widgetOid\"\n *    [dashboardOid]=\"dashboardOid\"\n *    [includeDashboardFilters]=\"true\"\n * />\n * ```\n * ```ts\n * import { Component } from '@angular/core';\n *\n * @Component({\n *  selector: 'app-widgets',\n *  templateUrl: './widgets.component.html',\n *  styleUrls: ['./widgets.component.scss'],\n * })\n * export class WidgetsComponent {\n *  widgetOid: string = '60f3e3e3e4b0e3e3e4b0e3e3';\n *  dashboardOid: string = '60f3e3e3e4b0e3e3e4b0e3e3';\n * }\n * ```\n * @group Fusion Assets\n * @fusionEmbed\n */\n@Component({\n  selector: 'csdk-widget-by-id',\n  template,\n  styles,\n})\nexport class WidgetByIdComponent implements AfterViewInit, OnChanges, OnDestroy {\n  /** @internal */\n  @ViewChild(rootId)\n  preactRef!: ElementRef<HTMLDivElement>;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.widgetOid}\n   *\n   * @category Widget\n   */\n  @Input()\n  widgetOid!: WidgetByIdProps['widgetOid'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.dashboardOid}\n   *\n   * @category Widget\n   */\n  @Input()\n  dashboardOid!: WidgetByIdProps['dashboardOid'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.filters}\n   *\n   * @category Data\n   */\n  @Input()\n  filters: WidgetByIdProps['filters'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.highlights}\n   *\n   * @category Data\n   */\n  @Input()\n  highlights: WidgetByIdProps['highlights'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.filtersMergeStrategy}\n   *\n   * @category Data\n   */\n  @Input()\n  filtersMergeStrategy: WidgetByIdProps['filtersMergeStrategy'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.includeDashboardFilters}\n   *\n   * @category Data\n   */\n  @Input()\n  includeDashboardFilters: WidgetByIdProps['includeDashboardFilters'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.title}\n   *\n   * @category Widget\n   */\n  @Input()\n  title: WidgetByIdProps['title'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.description}\n   *\n   * @category Widget\n   */\n  @Input()\n  description: WidgetByIdProps['description'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.styleOptions}\n   *\n   * @category Widget\n   */\n  @Input()\n  styleOptions: WidgetByIdProps['styleOptions'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.highlightSelectionDisabled}\n   *\n   * @category Widget\n   */\n  @Input()\n  highlightSelectionDisabled: WidgetByIdProps['highlightSelectionDisabled'];\n\n  /** @internal */\n  @Input()\n  drilldownOptions: WidgetByIdProps['drilldownOptions'];\n\n  /**\n   * {@inheritDoc  @sisense/sdk-ui!WidgetByIdProps.onDataReady}\n   *\n   * @category Callbacks\n   */\n  @Input()\n  dataReady: WidgetByIdProps['dataReady'];\n\n  private componentAdapter: ComponentAdapter<typeof WidgetByIdPreact>;\n\n  constructor(\n    private sisenseContextService: SisenseContextService,\n    private themeService: ThemeService,\n  ) {\n    this.componentAdapter = new ComponentAdapter(WidgetByIdPreact, [\n      createSisenseContextConnector(this.sisenseContextService),\n      createThemeContextConnector(this.themeService),\n    ]);\n  }\n\n  /** @internal */\n  ngAfterViewInit() {\n    this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());\n  }\n\n  /** @internal */\n  ngOnChanges() {\n    if (this.preactRef) {\n      this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());\n    }\n  }\n\n  /** @internal */\n  private getPreactComponentProps(): WidgetByIdPropsPreact {\n    return {\n      widgetOid: this.widgetOid,\n      dashboardOid: this.dashboardOid,\n      filters: this.filters,\n      highlights: this.highlights,\n      filtersMergeStrategy: this.filtersMergeStrategy,\n      includeDashboardFilters: this.includeDashboardFilters,\n      title: this.title,\n      description: this.description,\n      styleOptions: this.styleOptions,\n      highlightSelectionDisabled: this.highlightSelectionDisabled,\n      drilldownOptions: this.drilldownOptions,\n      onDataReady: this.dataReady?.bind(this),\n    };\n  }\n\n  /** @internal */\n  ngOnDestroy() {\n    this.componentAdapter.destroy();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-by-id.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/widgets/widget-by-id.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EAET,KAAK,EAGL,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,gBAAgB,EAChB,UAAU,IAAI,gBAAgB,GAE/B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,6BAA6B,EAC7B,2BAA2B,EAC3B,MAAM,EACN,MAAM,EACN,QAAQ,GACT,MAAM,iCAAiC,CAAC;;;;AAYzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAMH,MAAM,OAAO,mBAAmB;IAmG9B,YACU,qBAA4C,EAC5C,YAA0B;QAD1B,0BAAqB,GAArB,qBAAqB,CAAuB;QAC5C,iBAAY,GAAZ,YAAY,CAAc;QAElC,IAAI,CAAC,gBAAgB,GAAG,IAAI,gBAAgB,CAAC,gBAAgB,EAAE;YAC7D,6BAA6B,CAAC,IAAI,CAAC,qBAAqB,CAAC;YACzD,2BAA2B,CAAC,IAAI,CAAC,YAAY,CAAC;SAC/C,CAAC,CAAC;IACL,CAAC;IAED,gBAAgB;IAChB,eAAe;QACb,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,IAAI,CAAC,uBAAuB,EAAE,CAAC,CAAC;IAC7F,CAAC;IAED,gBAAgB;IAChB,WAAW;QACT,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,IAAI,CAAC,uBAAuB,EAAE,CAAC,CAAC;SAC5F;IACH,CAAC;IAED,gBAAgB;IACR,uBAAuB;QAC7B,OAAO;YACL,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,uBAAuB,EAAE,IAAI,CAAC,uBAAuB;YACrD,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,0BAA0B,EAAE,IAAI,CAAC,0BAA0B;YAC3D,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;YACvC,WAAW,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC;SACxC,CAAC;IACJ,CAAC;IAED,gBAAgB;IAChB,WAAW;QACT,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC;IAClC,CAAC;;iHA9IU,mBAAmB;qGAAnB,mBAAmB;4FAAnB,mBAAmB;kBAL/B,SAAS;+BACE,mBAAmB,YAC7B,QAAQ;uIAMR,SAAS;sBADR,SAAS;uBAAC,MAAM;gBASjB,SAAS;sBADR,KAAK;gBASN,YAAY;sBADX,KAAK;gBASN,OAAO;sBADN,KAAK;gBASN,UAAU;sBADT,KAAK;gBASN,oBAAoB;sBADnB,KAAK;gBASN,uBAAuB;sBADtB,KAAK;gBASN,KAAK;sBADJ,KAAK;gBASN,WAAW;sBADV,KAAK;gBASN,YAAY;sBADX,KAAK;gBASN,0BAA0B;sBADzB,KAAK;gBAKN,gBAAgB;sBADf,KAAK;gBASN,SAAS;sBADR,KAAK","sourcesContent":["import {\n  AfterViewInit,\n  Component,\n  ElementRef,\n  Input,\n  OnChanges,\n  OnDestroy,\n  ViewChild,\n} from '@angular/core';\nimport {\n  ComponentAdapter,\n  WidgetById as WidgetByIdPreact,\n  type WidgetByIdProps as WidgetByIdPropsPreact,\n} from '@sisense/sdk-ui-preact';\n\nimport {\n  createSisenseContextConnector,\n  createThemeContextConnector,\n  rootId,\n  styles,\n  template,\n} from '../../component-wrapper-helpers';\nimport { SisenseContextService } from '../../services/sisense-context.service';\nimport { ThemeService } from '../../services/theme.service';\nimport { BaseChartEventProps, WithoutPreactChartEventProps } from '../../types';\n\n/**\n * Props of the {@link WidgetByIdComponent}.\n */\nexport interface WidgetByIdProps\n  extends WithoutPreactChartEventProps<WidgetByIdPropsPreact>,\n    BaseChartEventProps {}\n\n/**\n * The `WidgetById` component, which is a thin wrapper on {@link ChartWidgetComponent},\n * is used to render a widget created in a Sisense Fusion instance.\n *\n * To learn more about using Sisense Fusion Widgets in Compose SDK, see\n * [Sisense Fusion Widgets](https://developer.sisense.com/guides/sdk/guides/charts/guide-fusion-widgets.html).\n *\n * @example\n * ```html\n * <csdk-widget-by-id\n *    [widgetOid]=\"widgetOid\"\n *    [dashboardOid]=\"dashboardOid\"\n *    [includeDashboardFilters]=\"true\"\n * />\n * ```\n * ```ts\n * import { Component } from '@angular/core';\n *\n * @Component({\n *  selector: 'app-widgets',\n *  templateUrl: './widgets.component.html',\n *  styleUrls: ['./widgets.component.scss'],\n * })\n * export class WidgetsComponent {\n *  widgetOid: string = '60f3e3e3e4b0e3e3e4b0e3e3';\n *  dashboardOid: string = '60f3e3e3e4b0e3e3e4b0e3e3';\n * }\n * ```\n * @group Fusion Assets\n * @fusionEmbed\n */\n@Component({\n  selector: 'csdk-widget-by-id',\n  template,\n  styles,\n})\nexport class WidgetByIdComponent implements AfterViewInit, OnChanges, OnDestroy {\n  /** @internal */\n  @ViewChild(rootId)\n  preactRef!: ElementRef<HTMLDivElement>;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.widgetOid}\n   *\n   * @category Widget\n   */\n  @Input()\n  widgetOid!: WidgetByIdProps['widgetOid'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.dashboardOid}\n   *\n   * @category Widget\n   */\n  @Input()\n  dashboardOid!: WidgetByIdProps['dashboardOid'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.filters}\n   *\n   * @category Data\n   */\n  @Input()\n  filters: WidgetByIdProps['filters'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.highlights}\n   *\n   * @category Data\n   */\n  @Input()\n  highlights: WidgetByIdProps['highlights'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.filtersMergeStrategy}\n   *\n   * @category Data\n   */\n  @Input()\n  filtersMergeStrategy: WidgetByIdProps['filtersMergeStrategy'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.includeDashboardFilters}\n   *\n   * @category Data\n   */\n  @Input()\n  includeDashboardFilters: WidgetByIdProps['includeDashboardFilters'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.title}\n   *\n   * @category Widget\n   */\n  @Input()\n  title: WidgetByIdProps['title'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.description}\n   *\n   * @category Widget\n   */\n  @Input()\n  description: WidgetByIdProps['description'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.styleOptions}\n   *\n   * @category Widget\n   */\n  @Input()\n  styleOptions: WidgetByIdProps['styleOptions'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.highlightSelectionDisabled}\n   *\n   * @category Widget\n   */\n  @Input()\n  highlightSelectionDisabled: WidgetByIdProps['highlightSelectionDisabled'];\n\n  /** @internal */\n  @Input()\n  drilldownOptions: WidgetByIdProps['drilldownOptions'];\n\n  /**\n   * {@inheritDoc  @sisense/sdk-ui!WidgetByIdProps.onDataReady}\n   *\n   * @category Callbacks\n   */\n  @Input()\n  dataReady: WidgetByIdProps['dataReady'];\n\n  private componentAdapter: ComponentAdapter<typeof WidgetByIdPreact>;\n\n  constructor(\n    private sisenseContextService: SisenseContextService,\n    private themeService: ThemeService,\n  ) {\n    this.componentAdapter = new ComponentAdapter(WidgetByIdPreact, [\n      createSisenseContextConnector(this.sisenseContextService),\n      createThemeContextConnector(this.themeService),\n    ]);\n  }\n\n  /** @internal */\n  ngAfterViewInit() {\n    this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());\n  }\n\n  /** @internal */\n  ngOnChanges() {\n    if (this.preactRef) {\n      this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());\n    }\n  }\n\n  /** @internal */\n  private getPreactComponentProps(): WidgetByIdPropsPreact {\n    return {\n      widgetOid: this.widgetOid,\n      dashboardOid: this.dashboardOid,\n      filters: this.filters,\n      highlights: this.highlights,\n      filtersMergeStrategy: this.filtersMergeStrategy,\n      includeDashboardFilters: this.includeDashboardFilters,\n      title: this.title,\n      description: this.description,\n      styleOptions: this.styleOptions,\n      highlightSelectionDisabled: this.highlightSelectionDisabled,\n      drilldownOptions: this.drilldownOptions,\n      onDataReady: this.dataReady?.bind(this),\n    };\n  }\n\n  /** @internal */\n  ngOnDestroy() {\n    this.componentAdapter.destroy();\n  }\n}\n"]}

package/dist/esm2020/lib/sdk-ui-core-exports.mjs

@@ -1,4 +1,4 @@
 // This file re-exports common types/utils from @sisense/sdk-ui-preact
 // Re-exports utils from @sisense/sdk-ui-preact
 export { boxWhiskerProcessResult, extractDimensionsAndMeasures } from '@sisense/sdk-ui-preact';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/lib/services/sisense-context.service.mjs

@@ -1,5 +1,6 @@
-import { Inject, Injectable, InjectionToken } from '@angular/core';
+import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
 import { createClientApplication } from '@sisense/sdk-ui-preact';
+import { concat, firstValueFrom, of, ReplaySubject } from 'rxjs';
 import * as i0 from "@angular/core";
 /**
  * Token used to inject {@link SisenseContextConfig} into your application
@@ -30,28 +31,112 @@ import * as i0 from "@angular/core";
  */
 export const SISENSE_CONTEXT_CONFIG_TOKEN = new InjectionToken('Props for connecting to Sisense instance');
 /**
- * Service for working with Sisense Fusion context.
+ * Service for managing Sisense Fusion context and client application lifecycle.
+ *
+ * This service provides a centralized way to configure and manage the connection to a Sisense instance within Angular applications.
  *
  * @group Contexts
  */
 export class SisenseContextService {
     constructor(sisenseContextConfig) {
-        this.appPromise = createClientApplication(sisenseContextConfig);
-        const { showRuntimeErrors } = sisenseContextConfig;
-        this.config = {
-            ...sisenseContextConfig,
-            showRuntimeErrors: showRuntimeErrors ?? true,
-        };
+        /**
+         * Flag indicating whether the service has been initialized with configuration.
+         *
+         * @internal
+         */
+        this.isInitialized = false;
+        // The buffer size of 1 ensures only the most recent state is cached.
+        this.app$ = new ReplaySubject(1);
+        if (sisenseContextConfig) {
+            // Auto-configure if config is provided via DI
+            void this.setConfig(sisenseContextConfig);
+        }
+    }
+    /**
+     * Retrieves the initialized Sisense client application.
+     *
+     * This method provides access to the client application instance.
+     * It waits for the latest state from the reactive stream and either returns
+     * the application or throws the error if initialization failed.
+     *
+     * @returns Promise that resolves to the ClientApplication instance
+     * @throws {Error} When the service is not initialized or when application creation failed
+     *
+     * @internal
+     */
+    async getApp() {
+        if (!this.isInitialized) {
+            throw new Error('Sisense context is not initialized');
+        }
+        const { app, error } = await firstValueFrom(this.app$);
+        if (error) {
+            throw error;
+        }
+        return app;
     }
-    /** @internal */
-    getApp() {
-        return this.appPromise;
+    /**
+     * Provides reactive access to the Sisense application state.
+     *
+     * This method returns an Observable that emits the current application state
+     * and all subsequent state changes. It's the preferred way to reactively
+     * handle application lifecycle events in Angular components.
+     *
+     * If the service is not initialized, it immediately emits an error state
+     * followed by any future state changes once initialization occurs.
+     *
+     * @returns Observable stream of AppState changes
+     *
+     * @internal
+     */
+    getApp$() {
+        if (!this.isInitialized) {
+            return concat(of({ error: new Error('Sisense context is not initialized') }), this.app$);
+        }
+        return this.app$;
     }
+    /**
+     * Retrieves the current {@link SisenseContextConfig} configuration object.
+     *
+     * @returns The current configuration object, or undefined if not yet configured
+     */
     getConfig() {
         return this.config;
     }
+    /**
+     * Configures and initializes the Sisense context with the provided settings.
+     *
+     * This method allows to establish a connection to a Sisense instance.
+     * It could be used as runtime alternative to {@link SISENSE_CONTEXT_CONFIG_TOKEN} based configuration.
+     *
+     * @param config - Configuration object
+     * @returns Promise that resolves when configuration is complete (success or failure)
+     *
+     * @example
+     * Basic configuration:
+     * ```ts
+     * await SisenseContextService.setConfig({
+     *   url: 'https://your-sisense-instance.com',
+     *   token: 'your-api-token',
+     *   defaultDataSource: 'Sample ECommerce'
+     * });
+     * ```
+     */
+    async setConfig(config) {
+        this.config = {
+            ...config,
+            showRuntimeErrors: config.showRuntimeErrors ?? true,
+        };
+        this.isInitialized = true;
+        try {
+            const app = await createClientApplication(this.config);
+            this.app$.next({ app });
+        }
+        catch (error) {
+            this.app$.next({ error: error });
+        }
+    }
 }
-SisenseContextService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SisenseContextService, deps: [{ token: SISENSE_CONTEXT_CONFIG_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable });
+SisenseContextService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SisenseContextService, deps: [{ token: SISENSE_CONTEXT_CONFIG_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
 SisenseContextService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SisenseContextService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SisenseContextService, decorators: [{
             type: Injectable,
@@ -59,7 +144,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
                     type: Inject,
                     args: [SISENSE_CONTEXT_CONFIG_TOKEN]
                 }] }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sisense-context.service.js","sourceRoot":"","sources":["../../../../src/lib/services/sisense-context.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE7E,OAAO,EAAqB,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACpF,OAAO,EAAE,MAAM,EAAE,cAAc,EAAc,EAAE,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;;AAmB7E;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,IAAI,cAAc,CAC5D,0CAA0C,CAC3C,CAAC;AAEF;;;;;;GAMG;AAIH,MAAM,OAAO,qBAAqB;IAuBhC,YACoD,oBAA2C;QAR/F;;;;WAIG;QACH,kBAAa,GAAG,KAAK,CAAC;QAKpB,qEAAqE;QACrE,IAAI,CAAC,IAAI,GAAG,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC;QAEjC,IAAI,oBAAoB,EAAE;YACxB,8CAA8C;YAC9C,KAAK,IAAI,CAAC,SAAS,CAAC,oBAAoB,CAAC,CAAC;SAC3C;IACH,CAAC;IAED;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,MAAM;QACV,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YACvB,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;SACvD;QAED,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,MAAM,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEvD,IAAI,KAAK,EAAE;YACT,MAAM,KAAK,CAAC;SACb;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,OAAO;QACL,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YACvB,OAAO,MAAM,CACX,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,KAAK,CAAC,oCAAoC,CAAC,EAAW,CAAC,EACvE,IAAI,CAAC,IAAI,CACV,CAAC;SACH;QAED,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED;;;;OAIG;IACH,SAAS;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,KAAK,CAAC,SAAS,CAAC,MAA4B;QAC1C,IAAI,CAAC,MAAM,GAAG;YACZ,GAAG,MAAM;YACT,iBAAiB,EAAE,MAAM,CAAC,iBAAiB,IAAI,IAAI;SACpD,CAAC;QACF,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAE1B,IAAI;YACF,MAAM,GAAG,GAAG,MAAM,uBAAuB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACvD,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,EAAW,CAAC,CAAC;SAClC;QAAC,OAAO,KAAK,EAAE;YACd,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,KAAc,EAAW,CAAC,CAAC;SACpD;IACH,CAAC;;mHA9HU,qBAAqB,kBAwBV,4BAA4B;uHAxBvC,qBAAqB,cAFpB,MAAM;4FAEP,qBAAqB;kBAHjC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAyBI,QAAQ;;0BAAI,MAAM;2BAAC,4BAA4B","sourcesContent":["import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';\nimport type { SisenseContextProviderProps as SisenseContextConfig } from '@sisense/sdk-ui-preact';\nimport { ClientApplication, createClientApplication } from '@sisense/sdk-ui-preact';\nimport { concat, firstValueFrom, Observable, of, ReplaySubject } from 'rxjs';\n\nexport { type SisenseContextConfig };\n\n/**\n * Represents the state of the Sisense client application.\n */\ntype AppState =\n  | {\n      /** Successfully initialized client application */\n      readonly app: ClientApplication;\n      readonly error?: never;\n    }\n  | {\n      /** Error that occurred during initialization or connection */\n      readonly error: Error;\n      readonly app?: never;\n    };\n\n/**\n * Token used to inject {@link SisenseContextConfig} into your application\n *\n * @example\n * Example of importing {@link SdkUiModule} and injecting {@link SisenseContextConfig} into your application:\n *\n * ```ts\n * export const SISENSE_CONTEXT_CONFIG: SisenseContextConfig = {\n *   url: \"<instance url>\", // replace with the URL of your Sisense instance\n *   token: \"<api token>\", // replace with the API token of your user account\n *   defaultDataSource: DM.DataSource,\n * };\n *\n * @NgModule({\n *   imports: [\n *     BrowserModule,\n *     SdkUiModule,\n *   ],\n *   declarations: [AppComponent],\n *   providers: [\n *     { provide: SISENSE_CONTEXT_CONFIG_TOKEN, useValue: SISENSE_CONTEXT_CONFIG },\n *   ],\n *   bootstrap: [AppComponent],\n * })\n * ```\n * @group Contexts\n */\nexport const SISENSE_CONTEXT_CONFIG_TOKEN = new InjectionToken<SisenseContextConfig>(\n  'Props for connecting to Sisense instance',\n);\n\n/**\n * Service for managing Sisense Fusion context and client application lifecycle.\n *\n * This service provides a centralized way to configure and manage the connection to a Sisense instance within Angular applications.\n *\n * @group Contexts\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class SisenseContextService {\n  /**\n   * Reactive stream of application state changes.\n   *\n   * Uses ReplaySubject to ensure late subscribers receive the latest state.\n   */\n  private readonly app$: ReplaySubject<AppState>;\n\n  /**\n   * Configuration object for the Sisense connection.\n   *\n   * This is set once during initialization and remains readonly thereafter\n   * to prevent accidental mutations that could lead to inconsistent state.\n   */\n  private config?: SisenseContextConfig;\n\n  /**\n   * Flag indicating whether the service has been initialized with configuration.\n   *\n   * @internal\n   */\n  isInitialized = false;\n\n  constructor(\n    @Optional() @Inject(SISENSE_CONTEXT_CONFIG_TOKEN) sisenseContextConfig?: SisenseContextConfig,\n  ) {\n    // The buffer size of 1 ensures only the most recent state is cached.\n    this.app$ = new ReplaySubject(1);\n\n    if (sisenseContextConfig) {\n      // Auto-configure if config is provided via DI\n      void this.setConfig(sisenseContextConfig);\n    }\n  }\n\n  /**\n   * Retrieves the initialized Sisense client application.\n   *\n   * This method provides access to the client application instance.\n   * It waits for the latest state from the reactive stream and either returns\n   * the application or throws the error if initialization failed.\n   *\n   * @returns Promise that resolves to the ClientApplication instance\n   * @throws {Error} When the service is not initialized or when application creation failed\n   *\n   * @internal\n   */\n  async getApp(): Promise<ClientApplication> {\n    if (!this.isInitialized) {\n      throw new Error('Sisense context is not initialized');\n    }\n\n    const { app, error } = await firstValueFrom(this.app$);\n\n    if (error) {\n      throw error;\n    }\n    return app;\n  }\n\n  /**\n   * Provides reactive access to the Sisense application state.\n   *\n   * This method returns an Observable that emits the current application state\n   * and all subsequent state changes. It's the preferred way to reactively\n   * handle application lifecycle events in Angular components.\n   *\n   * If the service is not initialized, it immediately emits an error state\n   * followed by any future state changes once initialization occurs.\n   *\n   * @returns Observable stream of AppState changes\n   *\n   * @internal\n   */\n  getApp$(): Observable<AppState> {\n    if (!this.isInitialized) {\n      return concat(\n        of({ error: new Error('Sisense context is not initialized') } as const),\n        this.app$,\n      );\n    }\n\n    return this.app$;\n  }\n\n  /**\n   * Retrieves the current {@link SisenseContextConfig} configuration object.\n   *\n   * @returns The current configuration object, or undefined if not yet configured\n   */\n  getConfig(): SisenseContextConfig | undefined {\n    return this.config;\n  }\n\n  /**\n   * Configures and initializes the Sisense context with the provided settings.\n   *\n   * This method allows to establish a connection to a Sisense instance.\n   * It could be used as runtime alternative to {@link SISENSE_CONTEXT_CONFIG_TOKEN} based configuration.\n   *\n   * @param config - Configuration object\n   * @returns Promise that resolves when configuration is complete (success or failure)\n   *\n   * @example\n   * Basic configuration:\n   * ```ts\n   * await SisenseContextService.setConfig({\n   *   url: 'https://your-sisense-instance.com',\n   *   token: 'your-api-token',\n   *   defaultDataSource: 'Sample ECommerce'\n   * });\n   * ```\n   */\n  async setConfig(config: SisenseContextConfig): Promise<void> {\n    this.config = {\n      ...config,\n      showRuntimeErrors: config.showRuntimeErrors ?? true,\n    };\n    this.isInitialized = true;\n\n    try {\n      const app = await createClientApplication(this.config);\n      this.app$.next({ app } as const);\n    } catch (error) {\n      this.app$.next({ error: error as Error } as const);\n    }\n  }\n}\n"]}

package/dist/esm2020/lib/services/theme.service.mjs

@@ -1,7 +1,7 @@
 import { __decorate } from "tslib";
 import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
 import { getDefaultThemeSettings, getThemeSettingsByOid, } from '@sisense/sdk-ui-preact';
-import { BehaviorSubject } from 'rxjs';
+import { BehaviorSubject, skip } from 'rxjs';
 import merge from 'ts-deepmerge';
 import { track, TrackableService } from '../decorators/trackable.decorator';
 import * as i0 from "@angular/core";
@@ -54,6 +54,18 @@ let ThemeService = class ThemeService {
         this.initializationPromise = Promise.resolve();
         this.themeSettings$ = new BehaviorSubject(getDefaultThemeSettings());
         this.initializationPromise = this.initThemeSettings(themeConfig?.theme);
+        this.sisenseContextService
+            .getApp$()
+            // Skip current app value
+            .pipe(skip(1))
+            // Subscribe to new app values
+            .subscribe({
+            next: ({ app }) => {
+                if (app) {
+                    this.initializationPromise = this.applyThemeSettings(app.settings.serverThemeSettings);
+                }
+            },
+        });
     }
     async initThemeSettings(theme) {
         const app = await this.sisenseContextService.getApp();
@@ -106,4 +118,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                     type: Inject,
                     args: [THEME_CONFIG_TOKEN]
                 }] }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"theme.service.js","sourceRoot":"","sources":["../../../../src/lib/services/theme.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';\nimport {\n  type CompleteThemeSettings,\n  getDefaultThemeSettings,\n  getThemeSettingsByOid,\n  type ThemeProviderProps as ThemeConfig,\n} from '@sisense/sdk-ui-preact';\nimport { BehaviorSubject, skip } from 'rxjs';\nimport merge from 'ts-deepmerge';\n\nimport { track, TrackableService } from '../decorators/trackable.decorator';\nimport { type ThemeSettings } from '../sdk-ui-core-exports';\nimport { SisenseContextService } from './sisense-context.service';\n\nexport { type ThemeConfig };\n\n/**\n * Token used to inject {@link ThemeConfig} into your application\n *\n * @example\n *\n * Example of injecting both {@link SisenseContextConfig} and {@link ThemeConfig} into your application:\n *\n * ```ts\n * export const SISENSE_CONTEXT_CONFIG: SisenseContextConfig = {\n *   url: \"<instance url>\", // replace with the URL of your Sisense instance\n *   token: \"<api token>\", // replace with the API token of your user account\n *   defaultDataSource: DM.DataSource,\n * };\n *\n * @NgModule({\n *   imports: [\n *     BrowserModule,\n *     SdkUiModule,\n *   ],\n *   declarations: [AppComponent],\n *   providers: [\n *     { provide: SISENSE_CONTEXT_CONFIG_TOKEN, useValue: SISENSE_CONTEXT_CONFIG },\n *     {\n *       provide: THEME_CONFIG_TOKEN,\n *       useValue: {\n *         // initial theme settings\n *       } as ThemeConfig,\n *     },\n *   ],\n *   bootstrap: [AppComponent],\n * })\n * ```\n * @group Contexts\n */\nexport const THEME_CONFIG_TOKEN = new InjectionToken<ThemeConfig>('theme configuration');\n\n/**\n * Service for working with Sisense Fusion themes.\n *\n * If no theme service is used, the current Fusion theme is applied by default.\n *\n * @group Contexts\n */\n@Injectable({\n  providedIn: 'root',\n})\n@TrackableService<ThemeService>(['updateThemeSettings'])\nexport class ThemeService {\n  private themeSettings$: BehaviorSubject<CompleteThemeSettings>;\n\n  private initializationPromise: Promise<void> = Promise.resolve();\n\n  constructor(\n    private sisenseContextService: SisenseContextService,\n    @Optional() @Inject(THEME_CONFIG_TOKEN) themeConfig?: ThemeConfig,\n  ) {\n    this.themeSettings$ = new BehaviorSubject<CompleteThemeSettings>(getDefaultThemeSettings());\n    this.initializationPromise = this.initThemeSettings(themeConfig?.theme);\n    this.sisenseContextService\n      .getApp$()\n      // Skip current app value\n      .pipe(skip(1))\n      // Subscribe to new app values\n      .subscribe({\n        next: ({ app }) => {\n          if (app) {\n            this.initializationPromise = this.applyThemeSettings(app.settings.serverThemeSettings);\n          }\n        },\n      });\n  }\n\n  private async initThemeSettings(theme: ThemeConfig['theme']) {\n    const app = await this.sisenseContextService.getApp();\n\n    // apply system theme settings first\n    await this.applyThemeSettings(app.settings.serverThemeSettings);\n\n    if (theme) {\n      // Manually tracks theme update during initialization as execution of updateThemeSettings for consistency.\n      track('sdkAngularServiceMethodExecuted', 'ThemeService.updateThemeSettings');\n      await this.applyThemeSettings(theme);\n    }\n  }\n\n  private async applyThemeSettings(theme: string | ThemeSettings) {\n    try {\n      const app = await this.sisenseContextService.getApp();\n      const isThemeOid = typeof theme === 'string';\n      let userThemeSettings = theme as ThemeSettings;\n\n      if (isThemeOid) {\n        userThemeSettings = await getThemeSettingsByOid(theme, app.httpClient);\n      }\n\n      const mergedThemeSettings = merge.withOptions(\n        { mergeArrays: false },\n        this.themeSettings$.value,\n        userThemeSettings,\n      ) as CompleteThemeSettings;\n\n      this.themeSettings$.next(mergedThemeSettings);\n    } catch (error) {\n      this.themeSettings$.error(error);\n    }\n  }\n\n  /** @internal */\n  getThemeSettings() {\n    return this.themeSettings$.asObservable();\n  }\n\n  async updateThemeSettings(theme: string | ThemeSettings) {\n    await this.initializationPromise;\n    await this.applyThemeSettings(theme);\n  }\n}\n"]}

package/dist/esm2020/version.mjs

@@ -1,2 +1,2 @@
-export default '2.9.0';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsT0FBTyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlZmF1bHQgJzIuOS4wJyJdfQ==
+export default '2.10.0';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsUUFBUSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlZmF1bHQgJzIuMTAuMCciXX0=

package/dist/fesm2015/sisense-sdk-ui-angular-ai.mjs

@@ -87,13 +87,13 @@ const AI_CONTEXT_CONFIG_TOKEN = new InjectionToken('AI Context Config');
 let AiService = class AiService {
     constructor(sisenseContextService, aiContextConfig) {
         this.sisenseContextService = sisenseContextService;
-        this.apiPromise = this.sisenseContextService
-            .getApp()
-            .then((app) => new ChatRestApi(app.httpClient, aiContextConfig === null || aiContextConfig === void 0 ? void 0 : aiContextConfig.volatile));
+        this.aiContextConfig = aiContextConfig;
     }
     /** @internal */
     getApi() {
-        return this.apiPromise;
+        return this.sisenseContextService
+            .getApp()
+            .then((app) => { var _a; return new ChatRestApi(app.httpClient, (_a = this.aiContextConfig) === null || _a === void 0 ? void 0 : _a.volatile); });
     }
     /**
      * Fetches an analysis of the provided query using natural language generation (NLG).