@devtron-labs/devtron-fe-common-lib 4.0.2-beta-1 → 4.0.3-pre-0

package/dist/Shared/Hooks/useUserPreferences/service.d.ts

@@ -0,0 +1,20 @@
+import { PreferredResourceKindType, UserPreferenceResourceProps, UserPreferencesType } from './types';
+/**
+ * @returns UserPreferencesType
+ * @description This function fetches the user preferences from the server. It uses the `get` method to make a request to the server and retrieves the user preferences based on the `USER_PREFERENCES_ATTRIBUTE_KEY`. The result is parsed and returned as a `UserPreferencesType` object.
+ * @throws Will throw an error if the request fails or if the result is not in the expected format.
+ */
+export declare const getUserPreferences: (signal?: AbortSignal) => Promise<UserPreferencesType>;
+export declare const updateUserPreferences: ({ path, value, resourceKind, shouldThrowError, userPreferencesResponse, }: UserPreferenceResourceProps) => Promise<boolean>;
+/**
+ * Centralized function to update and persist user preferences
+ * Handles both local state and server updates automatically
+ * Eliminates the need for manual resource management in multiple places
+ */
+export declare const updateAndPersistUserPreferences: ({ id, name, resourceKind, shouldThrowError, updateLocalStorage, }: {
+    id?: number;
+    name?: string;
+    resourceKind?: PreferredResourceKindType;
+    shouldThrowError?: boolean;
+    updateLocalStorage?: boolean;
+}) => Promise<UserPreferencesType>;

package/dist/Shared/Hooks/useUserPreferences/types.d.ts

@@ -0,0 +1,127 @@
+import { USER_PREFERENCES_ATTRIBUTE_KEY } from './constants';
+import { AppThemeType, ThemeConfigType, ThemePreferenceType } from '../../Providers/ThemeProvider/types';
+import { ResourceKindType } from '../../types';
+import { NavigationItemID, NavigationSubMenuItemID } from '../../../Pages-Devtron-2.0/Navigation';
+export interface GetUserPreferencesQueryParamsType {
+    key: typeof USER_PREFERENCES_ATTRIBUTE_KEY;
+}
+export declare enum ViewIsPipelineRBACConfiguredRadioTabs {
+    ALL_ENVIRONMENTS = "All environments",
+    ACCESS_ONLY = "Access only"
+}
+export declare enum UserPreferenceResourceActions {
+    RECENTLY_VISITED = "recently-visited"
+}
+export type PreferredResourceKindType = ResourceKindType.devtronApplication | ResourceKindType.job | 'app-group' | ResourceKindType.cluster;
+export interface BaseRecentlyVisitedEntitiesTypes {
+    id: number;
+    name: string;
+}
+export interface UserPreferenceRecentlyVisitedAppsTypes extends BaseRecentlyVisitedEntitiesTypes {
+    resourceKind: PreferredResourceKindType;
+}
+export interface UserResourceKindActionType {
+    [UserPreferenceResourceActions.RECENTLY_VISITED]: BaseRecentlyVisitedEntitiesTypes[];
+}
+export type UserPreferenceResourceType = Partial<Record<PreferredResourceKindType, UserResourceKindActionType>>;
+export type CommandBarAdditionalItemsId = 'app-management-devtron-app-list' | 'app-management-helm-app-list' | 'app-management-flux-app-list' | 'app-management-argo-app-list' | `app-management-devtron-app-list-${number}` | 'search-app-list-view' | `chart-list-${number}` | 'search-chart-list-view' | `helm-app-list-${number}` | 'search-helm-app-list-view' | `cluster-list-${number}` | 'search-cluster-list-view';
+export interface GetUserPreferencesParsedDTO {
+    viewPermittedEnvOnly?: boolean;
+    /**
+     * Computed app theme for the user
+     *
+     * Could be 'light' | 'dark' | 'system-light' | 'system-dark'
+     */
+    computedAppTheme?: AppThemeType | `system-${AppThemeType}`;
+    /**
+     * @description resources object with key as resource kind and value as ResourceType
+     *
+     */
+    resources?: UserPreferenceResourceType;
+    commandBar: {
+        recentNavigationActions: {
+            id: NavigationItemID | NavigationSubMenuItemID | CommandBarAdditionalItemsId;
+        }[];
+    };
+}
+export interface UserPreferencesPayloadValueType extends GetUserPreferencesParsedDTO {
+}
+export interface UpdateUserPreferencesPayloadType extends Pick<GetUserPreferencesQueryParamsType, 'key'> {
+    value: string;
+}
+export interface UserPreferencesType extends Pick<GetUserPreferencesParsedDTO, 'commandBar'> {
+    /**
+     * Preferred theme for the user
+     * If null, would forcibly show user theme switcher dialog for user to select
+     */
+    themePreference?: ThemePreferenceType | null;
+    /**
+     * @type {ViewIsPipelineRBACConfiguredRadioTabs}
+     * @description pipelineRBACViewSelectedTab is used to store the selected tab in the pipeline RBAC view
+     * @default ViewIsPipelineRBACConfiguredRadioTabs.VIEW_PERMITTED_ENV
+     */
+    pipelineRBACViewSelectedTab?: ViewIsPipelineRBACConfiguredRadioTabs;
+    /**
+     * @description resources object
+     */
+    resources?: GetUserPreferencesParsedDTO['resources'];
+    /**
+     * @description version of the user preferences, to be used for migration purposes
+     */
+    version?: string;
+}
+export interface UpdatedUserPreferencesType extends UserPreferencesType, Pick<ThemeConfigType, 'appTheme'> {
+}
+export interface RecentlyVisitedFetchConfigType extends UserPreferenceRecentlyVisitedAppsTypes {
+    isDataAvailable?: boolean;
+}
+export interface UseUserPreferencesProps {
+    userPreferenceResourceKind?: PreferredResourceKindType;
+    migrateUserPreferences?: (userPreferencesResponse: UserPreferencesType) => Promise<UserPreferencesType>;
+    recentlyVisitedFetchConfig?: RecentlyVisitedFetchConfigType;
+}
+type UserPathValueMapType = {
+    path: 'themePreference';
+    value: Required<Pick<UpdatedUserPreferencesType, 'themePreference' | 'appTheme'>>;
+    resourceKind?: never;
+    userPreferencesResponse?: never;
+} | {
+    path: 'pipelineRBACViewSelectedTab';
+    value: Required<Pick<UserPreferencesType, 'pipelineRBACViewSelectedTab'>>;
+    resourceKind?: never;
+    userPreferencesResponse?: never;
+} | {
+    path: 'resources';
+    value: Required<BaseRecentlyVisitedEntitiesTypes[]>;
+    resourceKind: PreferredResourceKindType;
+    userPreferencesResponse?: UserPreferencesType;
+} | {
+    path: 'commandBar.recentNavigationActions';
+    value: UserPreferencesType['commandBar']['recentNavigationActions'];
+    resourceKind?: never;
+    userPreferencesResponse?: never;
+};
+export type GetUserPreferencePayloadParams = {
+    userPreferencesResponse: UserPreferencesType;
+    resourceKind?: PreferredResourceKindType;
+} & ({
+    path: 'themePreference';
+    value: Required<Pick<UpdatedUserPreferencesType, 'themePreference' | 'appTheme'>>;
+} | {
+    path: 'pipelineRBACViewSelectedTab';
+    value: Required<Pick<UserPreferencesType, 'pipelineRBACViewSelectedTab'>>;
+} | {
+    path: 'resources';
+    value: Required<BaseRecentlyVisitedEntitiesTypes[]>;
+} | {
+    path: 'commandBar.recentNavigationActions';
+    value: UserPreferencesType['commandBar']['recentNavigationActions'];
+});
+export type UserPreferenceResourceProps = UserPathValueMapType & {
+    shouldThrowError?: boolean;
+    userPreferencesResponse?: UserPreferencesType;
+};
+export interface UserPreferenceFilteredListTypes extends UserPreferenceRecentlyVisitedAppsTypes {
+    userPreferencesResponse?: UserPreferencesType;
+}
+export {};

package/dist/Shared/Hooks/useUserPreferences/useUserPrefrences.d.ts

@@ -0,0 +1,12 @@
+import { ServerErrors } from '../../../Common/ServerError';
+import { BaseRecentlyVisitedEntitiesTypes, UserPreferencesType, UseUserPreferencesProps, ViewIsPipelineRBACConfiguredRadioTabs } from './types';
+export declare const useUserPreferences: ({ migrateUserPreferences, recentlyVisitedFetchConfig }: UseUserPreferencesProps) => {
+    userPreferences: UserPreferencesType;
+    userPreferencesError: ServerErrors;
+    handleFetchUserPreferences: () => Promise<void>;
+    handleUpdatePipelineRBACViewSelectedTab: (selectedTab: ViewIsPipelineRBACConfiguredRadioTabs) => void;
+    handleUpdateUserThemePreference: (themePreference: UserPreferencesType["themePreference"]) => void;
+    fetchRecentlyVisitedParsedEntities: () => Promise<UserPreferencesType>;
+    recentlyVisitedResources: BaseRecentlyVisitedEntitiesTypes[];
+    recentResourcesLoading: boolean;
+};

package/dist/Shared/Hooks/useUserPreferences/utils.d.ts

@@ -0,0 +1,3 @@
+import { GetUserPreferencesParsedDTO, UserPreferenceFilteredListTypes, UserPreferencesType } from './types';
+export declare const getFilteredUniqueAppList: ({ userPreferencesResponse, id, name, resourceKind, }: UserPreferenceFilteredListTypes) => import('./types').BaseRecentlyVisitedEntitiesTypes[];
+export declare const getParsedResourcesMap: (resources: GetUserPreferencesParsedDTO["resources"]) => UserPreferencesType["resources"];

package/dist/Shared/Providers/ImageSelectionUtility/ImageSelectionUtility.d.ts

@@ -1,4 +1,4 @@
 import { ImageSelectionUtilityContextType, ImageSelectionUtilityProviderProps } from './types';
 export declare const ImageSelectionUtilityContext: import('react').Context<ImageSelectionUtilityContextType>;
 export declare const useImageSelectionUtilityContext: () => ImageSelectionUtilityContextType;
-export declare const ImageSelectionUtilityProvider: ({ children, value }: ImageSelectionUtilityProviderProps) => JSX.Element;
+export declare const ImageSelectionUtilityProvider: ({ children, value }: ImageSelectionUtilityProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/Shared/Providers/{MainContextProvider.d.ts → MainContextProvider/MainContextProvider.d.ts}

@@ -1,3 +1,3 @@
 import { MainContext, MainContextProviderProps } from './types';
 export declare const useMainContext: () => MainContext;
-export declare const MainContextProvider: ({ children, value }: MainContextProviderProps) => JSX.Element;
+export declare const MainContextProvider: ({ children, value }: MainContextProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/Shared/Providers/MainContextProvider/index.d.ts

@@ -0,0 +1,3 @@
+export * from './MainContextProvider';
+export type { MainContext, ReloadVersionConfigTypes, SidePanelConfig, TempAppWindowConfig } from './types';
+export { AIAgentContextSourceType, type AIAgentContextType, SidePanelTab } from './types';

package/dist/Shared/Providers/MainContextProvider/types.d.ts

@@ -0,0 +1,185 @@
+import { Dispatch, FunctionComponent, JSX, MutableRefObject, ReactNode, SetStateAction } from 'react';
+import { SERVER_MODE } from '../../../Common';
+import { DevtronLicenseInfo, EnvironmentDataValuesDTO, IntelligenceConfig, LicenseInfoDialogType, ToastManager } from '../..';
+import { ServerInfo } from '../../Components/Header/types';
+export interface ReloadVersionConfigTypes {
+    bgUpdated: boolean;
+    handleAppUpdate: () => void;
+    doesNeedRefresh: boolean;
+    updateServiceWorker: () => Promise<void>;
+    handleControllerChange: () => void;
+    updateToastRef: MutableRefObject<ReturnType<typeof ToastManager.showToast>> | null;
+    isRefreshing: boolean;
+}
+export declare enum SidePanelTab {
+    DOCUMENTATION = "documentation",
+    ASK_DEVTRON = "ask-devtron"
+}
+export interface SidePanelConfig {
+    state: SidePanelTab | 'closed';
+    /** Optional flag to reset/reinitialize the side panel state */
+    reinitialize?: boolean;
+    /** URL to documentation that should be displayed in the panel */
+    docLink: string | null;
+    aiSessionId?: string;
+    isExpandedView?: boolean;
+}
+export declare enum AIAgentContextSourceType {
+    APP_DETAILS = "app-details",
+    RESOURCE_BROWSER_CLUSTER = "resource-browser-cluster"
+}
+export type AIAgentAppType = 'devtronApp' | 'devtronHelmChart' | 'externalHelmChart' | 'externalArgoApp' | 'externalFluxApp';
+type AIAgentAppDataMasterType = {
+    appId: number | string;
+    appName: string;
+    envId: number;
+    envName: string;
+    clusterId: number;
+    namespace: string;
+    appType: AIAgentAppType;
+    fluxAppDeploymentType: string;
+};
+type AIAgentAppDataType<TAppType extends AIAgentAppType, TRequiredFields extends keyof AIAgentAppDataMasterType> = Pick<AIAgentAppDataMasterType, TRequiredFields> & {
+    [K in Exclude<keyof AIAgentAppDataMasterType, TRequiredFields | 'appType'>]?: never;
+} & {
+    appType: TAppType;
+};
+type CommonContextDataType = Record<string, unknown> & {
+    uiMarkup?: string;
+};
+export type AIAgentContextType = {
+    source: AIAgentContextSourceType.APP_DETAILS;
+    data: AIAgentAppDataType<'devtronApp' | 'devtronHelmChart', 'appId' | 'appName' | 'envId' | 'envName' | 'clusterId'> | AIAgentAppDataType<'externalHelmChart', 'appId' | 'appName' | 'clusterId' | 'namespace'> | AIAgentAppDataType<'externalArgoApp', 'appName' | 'clusterId' | 'namespace'> | (AIAgentAppDataType<'externalFluxApp', 'appName' | 'clusterId' | 'namespace' | 'fluxAppDeploymentType'> & CommonContextDataType);
+} | {
+    source: AIAgentContextSourceType.RESOURCE_BROWSER_CLUSTER;
+    data: {
+        clusterId: number;
+        clusterName: string;
+    } & CommonContextDataType;
+};
+export type DebugAgentContextType = AIAgentContextType & {
+    prompt?: string;
+};
+export interface TempAppWindowConfig {
+    /** Whether the temporary window is open */
+    open: boolean;
+    /** Title of the temporary window */
+    title: string;
+    /** URL to load in iframe in the window */
+    url?: string;
+    /** Image URL to display in the window header */
+    image?: string;
+    /** Whether to show an "Open in new tab" button */
+    showOpenInNewTab?: boolean;
+    /** React component to render in the window */
+    component?: JSX.Element;
+    customCloseConfig?: {
+        /**
+         * Provide this method if you want to do something before temp window closes
+         * Provide noop if not relevant
+         * */
+        beforeClose: () => void;
+        icon: JSX.Element;
+    };
+}
+type CommonMainContextProps = {
+    setServerMode: (serverMode: SERVER_MODE) => void;
+    isHelpGettingStartedClicked: boolean;
+    showCloseButtonAfterGettingStartedClicked: () => void;
+    setLoginCount: (loginCount: number) => void;
+    showGettingStartedCard: boolean;
+    setShowGettingStartedCard: (showGettingStartedCard: boolean) => void;
+    isGettingStartedClicked: boolean;
+    setGettingStartedClicked: (isGettingStartedClicked: boolean) => void;
+    moduleInInstallingState: string;
+    setModuleInInstallingState: (moduleInInstallingState: string) => void;
+    currentServerInfo: {
+        serverInfo: ServerInfo | null;
+        fetchingServerInfo: boolean;
+    };
+    isAirgapped: boolean;
+    isSuperAdmin: boolean;
+    featureGitOpsFlags: {
+        /**
+         * Would define whether gitops (Global config tab) feature is enabled or not
+         */
+        isFeatureGitOpsEnabled: boolean;
+        /**
+         * Would define whether user can select allow custom repo in gitops global config
+         */
+        isFeatureUserDefinedGitOpsEnabled: boolean;
+        /**
+         * Feature flag for Migrate to devtron from argo cd
+         */
+        isFeatureArgoCdMigrationEnabled: boolean;
+    };
+    isManifestScanningEnabled: boolean;
+    canOnlyViewPermittedEnvOrgLevel: boolean;
+    viewIsPipelineRBACConfiguredNode: ReactNode;
+    handleOpenLicenseInfoDialog: (initialDialogType?: LicenseInfoDialogType.ABOUT | LicenseInfoDialogType.LICENSE) => void;
+    setLicenseData: Dispatch<SetStateAction<DevtronLicenseInfo>>;
+    canFetchHelmAppStatus: boolean;
+    setIntelligenceConfig: Dispatch<SetStateAction<IntelligenceConfig>>;
+    debugAgentContext: DebugAgentContextType | null;
+    setDebugAgentContext: (aiAgentContext: DebugAgentContextType | null) => void;
+    setAIAgentContext: (aiAgentContext: AIAgentContextType) => void;
+    setSidePanelConfig: Dispatch<SetStateAction<SidePanelConfig>>;
+} & Pick<EnvironmentDataValuesDTO, 'isResourceRecommendationEnabled' | 'forceDockerfileScan'>;
+export type MainContext = CommonMainContextProps & ({
+    isLicenseDashboard?: never;
+    serverMode: SERVER_MODE;
+    loginCount: number | null;
+    installedModuleMap: MutableRefObject<Record<string, boolean>>;
+    /**
+     * Data is set only if showLicenseData is received as true
+     */
+    licenseData: DevtronLicenseInfo;
+    reloadVersionConfig: ReloadVersionConfigTypes;
+    intelligenceConfig: IntelligenceConfig;
+    sidePanelConfig: SidePanelConfig;
+    /**
+     * Indicates whether the current Devtron instance is running as an Enterprise edition. \
+     * This flag is determined based on server-side configuration.
+     */
+    isEnterprise: boolean;
+    /**
+     * Indicates whether the fe-lib modules are available in the current instance. \
+     * Used to conditionally render or enable features that depend on fe-lib
+     */
+    isFELibAvailable: boolean;
+    aiAgentContext: AIAgentContextType;
+    tempAppWindowConfig: TempAppWindowConfig;
+    setTempAppWindowConfig: Dispatch<SetStateAction<TempAppWindowConfig>>;
+    AIRecommendations?: FunctionComponent;
+    featureAskDevtronExpert: EnvironmentDataValuesDTO['featureAskDevtronExpert'];
+    AskDevtronButton?: FunctionComponent;
+    showUpgradeToOSSPlusDialog: boolean;
+    setShowUpgradeToOSSPlusDialog: (show: boolean) => void;
+} | {
+    isLicenseDashboard: true;
+    serverMode: null;
+    loginCount: null;
+    installedModuleMap: null;
+    /**
+     * Data is set only if showLicenseData is received as true
+     */
+    licenseData: null;
+    reloadVersionConfig: null;
+    intelligenceConfig: null;
+    sidePanelConfig: null;
+    isEnterprise: false;
+    isFELibAvailable: false;
+    aiAgentContext: null;
+    tempAppWindowConfig: null;
+    setTempAppWindowConfig: null;
+    AIRecommendations?: null;
+    featureAskDevtronExpert?: null;
+    AskDevtronButton?: null;
+    showUpgradeToOSSPlusDialog?: null;
+    setShowUpgradeToOSSPlusDialog?: null;
+});
+export interface MainContextProviderProps {
+    children: ReactNode;
+    value: MainContext;
+}
+export {};

package/dist/Shared/Providers/ThemeProvider/ThemeProvider.d.ts

@@ -0,0 +1,3 @@
+import { ThemeContextType, ThemeProviderProps } from './types';
+export declare const ThemeProvider: ({ children }: ThemeProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useTheme: () => ThemeContextType;

package/dist/Shared/Providers/ThemeProvider/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const THEME_PREFERENCE_STORAGE_KEY = "themePreference__v1";
+export declare const DARK_COLOR_SCHEME_MATCH_QUERY = "(prefers-color-scheme: dark)";

package/dist/Shared/Providers/ThemeProvider/index.d.ts

@@ -0,0 +1,4 @@
+export { THEME_PREFERENCE_STORAGE_KEY } from './constants';
+export * from './ThemeProvider';
+export { AppThemeType } from './types';
+export { getComponentSpecificThemeClass, getThemePreferenceText } from './utils';

package/dist/Shared/Providers/ThemeProvider/types.d.ts

@@ -0,0 +1,41 @@
+import { ReactNode } from 'react';
+export declare enum AppThemeType {
+    light = "light",
+    dark = "dark"
+}
+export declare const THEME_PREFERENCE_MAP: {
+    readonly auto: "auto";
+    readonly light: AppThemeType.light;
+    readonly dark: AppThemeType.dark;
+};
+export type ThemePreferenceType = (typeof THEME_PREFERENCE_MAP)[keyof typeof THEME_PREFERENCE_MAP];
+export interface ThemeConfigType {
+    /**
+     * Current application theme
+     *
+     * @default AppThemeType.light
+     */
+    appTheme: AppThemeType;
+    /**
+     * Preferred theme for the user (if any)
+     *
+     * @default THEME_PREFERENCE_MAP.auto
+     *
+     * Note: This shouldn't be consumed other than in ThemeSwitcherDialog component
+     */
+    themePreference: ThemePreferenceType;
+}
+export interface ThemeContextType extends ThemeConfigType {
+    showSwitchThemeLocationTippy: boolean;
+    handleShowSwitchThemeLocationTippyChange: (isVisible: boolean) => void;
+    showThemeSwitcherDialog: boolean;
+    handleThemeSwitcherDialogVisibilityChange: (isVisible: boolean) => void;
+    handleThemePreferenceChange: (updatedThemePreference: ThemePreferenceType, 
+    /**
+     * @description If update is local we won't update local storage and analytics
+     * */
+    isLocalUpdate?: boolean) => void;
+}
+export interface ThemeProviderProps {
+    children: ReactNode;
+}

package/dist/Shared/Providers/ThemeProvider/utils.d.ts

@@ -0,0 +1,8 @@
+import { AppThemeType, ThemeConfigType, ThemePreferenceType } from './types';
+export declare const getAppThemeForAutoPreference: () => AppThemeType;
+export declare const setThemePreferenceInLocalStorage: (themePreference: ThemePreferenceType) => void;
+export declare const logThemeToAnalytics: ({ appTheme, themePreference }: ThemeConfigType) => void;
+export declare const getThemeConfigFromLocalStorage: () => ThemeConfigType;
+export declare const getComponentSpecificThemeClass: (appTheme: AppThemeType) => string;
+export declare const getThemeOppositeThemeClass: (appTheme: AppThemeType) => "component-specific-theme__light" | "component-specific-theme__dark";
+export declare const getThemePreferenceText: (themePreference: ThemePreferenceType) => string;

package/dist/Shared/Providers/UserEmailProvider/UserEmailProvider.d.ts

@@ -1,5 +1,5 @@
-import { default as React } from 'react';
+import { default as React, PropsWithChildren } from 'react';
 import { UseUserEmailContextType } from './types';
 export declare const useUserEmail: () => UseUserEmailContextType;
-export declare const UserEmailProvider: React.FC<{}>;
-export declare const withUserEmail: (Component: React.ComponentClass) => (props: object) => JSX.Element;
+export declare const UserEmailProvider: React.FC<PropsWithChildren<{}>>;
+export declare const withUserEmail: (Component: React.ComponentClass) => (props: object) => import("react/jsx-runtime").JSX.Element;

package/dist/Shared/Providers/UserEmailProvider/index.d.ts

@@ -1,2 +1,2 @@
-export * from './UserEmailProvider';
 export * from './types';
+export * from './UserEmailProvider';

package/dist/Shared/Providers/index.d.ts

@@ -1,3 +1,4 @@
-export * from './MainContextProvider';
 export * from './ImageSelectionUtility';
+export * from './MainContextProvider';
+export * from './ThemeProvider';
 export * from './UserEmailProvider';

package/dist/Shared/Services/ToastManager/ToastContent.d.ts

@@ -1,2 +1,3 @@
-import { ToastProps } from './types';
-export declare const ToastContent: ({ title, description, buttonProps, }: Pick<ToastProps, "title" | "description" | "buttonProps">) => JSX.Element;
+import { ShortcutToastContentProps, ToastProps } from './types';
+export declare const ToastContent: ({ title, description, buttonProps, }: Pick<ToastProps, "title" | "description" | "buttonProps">) => import("react/jsx-runtime").JSX.Element;
+export declare const ShortcutToastContent: ({ shortcuts, text }: ShortcutToastContentProps) => import("react/jsx-runtime").JSX.Element;

package/dist/Shared/Services/ToastManager/constants.d.ts

@@ -1,4 +1,4 @@
-import { ToastOptions, ToastContainerProps } from 'react-toastify';
-import { ToastProps, ToastVariantType } from './types';
+import { ToastContainerProps, ToastOptions } from 'react-toastify';
+import { BaseToastProps, ToastProps } from './types';
 export declare const TOAST_BASE_CONFIG: ToastContainerProps;
-export declare const TOAST_VARIANT_TO_CONFIG_MAP: Record<ToastVariantType, Required<Pick<ToastProps, 'icon' | 'title' | 'progressBarBg'>> & Pick<ToastOptions, 'type'>>;
+export declare const TOAST_VARIANT_TO_CONFIG_MAP: Record<BaseToastProps['variant'], Required<Pick<ToastProps, 'icon' | 'title' | 'progressBarBg'>> & Pick<ToastOptions, 'type'>>;

package/dist/Shared/Services/ToastManager/index.d.ts

@@ -1,3 +1,3 @@
 export { default as ToastManager, ToastManagerContainer } from './toastManager.service';
-export { ToastVariantType } from './types';
 export type { ToastProps } from './types';
+export { ToastVariantType } from './types';

package/dist/Shared/Services/ToastManager/types.d.ts

@@ -1,13 +1,28 @@
-import { ButtonProps } from '../../Components';
 import { ReactElement } from 'react';
+import { SupportedKeyboardKeysType } from '../../../Common/Hooks';
+import { ButtonComponentType, ButtonProps } from '../../Components';
 export declare enum ToastVariantType {
     info = "info",
     success = "success",
     error = "error",
     warn = "warn",
-    notAuthorized = "notAuthorized"
+    notAuthorized = "notAuthorized",
+    shortcut = "shortcut"
 }
-export interface ToastProps {
+export interface ShortcutToastProps {
+    variant: ToastVariantType.shortcut;
+    /**
+     * Text to display along the shortcuts in the toast
+     * Example: "Press [S] to switch context"
+     */
+    text: string;
+    /**
+     * The shortcuts to be displayed in the toast
+     * Note: The shortcuts should be in the format of `['Ctrl', 'A']
+     */
+    shortcuts: SupportedKeyboardKeysType[];
+}
+export interface BaseToastProps {
     /**
      * Title for the toast
      * If not provided, defaults to a value based on the selected variant
@@ -26,15 +41,20 @@ export interface ToastProps {
      *
      * @default ToastVariantType.info
      */
-    variant?: ToastVariantType;
+    variant?: Exclude<ToastVariantType, ToastVariantType.shortcut>;
     /**
      * Props for the action button to be displayed in the toast
      *
-     * Note: Size, variant and style are hard-coded and cannot be overriden
+     * Note: Size, variant and style are hard-coded and cannot be overridden
      */
-    buttonProps?: ButtonProps;
+    buttonProps?: ButtonProps<ButtonComponentType>;
     /**
      * Custom progress bar color
      */
     progressBarBg?: string;
 }
+export type ToastProps = (BaseToastProps & Partial<Record<Exclude<keyof ShortcutToastProps, 'variant'>, never>>) | (ShortcutToastProps & Partial<Record<Exclude<keyof BaseToastProps, 'variant'>, never>>);
+export interface ShortcutToastContentProps {
+    text: string;
+    shortcuts: SupportedKeyboardKeysType[];
+}

package/dist/Shared/Services/app.service.d.ts

@@ -1,8 +1,15 @@
+import { AppConfigProps } from '../../Pages/index';
 import { ResponseType } from '../../Common';
-import { CIMaterialInfoType, GetCITriggerInfoParamsType, AppEnvDeploymentConfigDTO, AppEnvDeploymentConfigPayloadType } from './app.types';
-export declare const getCITriggerInfo: (params: GetCITriggerInfoParamsType) => Promise<CIMaterialInfoType>;
+import { AppEnvDeploymentConfigDTO, AppEnvDeploymentConfigPayloadType, CIMaterialInfoDTO, GetCITriggerInfoParamsType } from './app.types';
+export declare const getCITriggerInfo: (params: GetCITriggerInfoParamsType) => Promise<ResponseType<CIMaterialInfoDTO>>;
 /**
  * The only difference between this and getCITriggerInfo is it doesn't have env and trigger related meta info
  */
-export declare const getArtifactInfo: (params: Pick<GetCITriggerInfoParamsType, "ciArtifactId">) => Promise<CIMaterialInfoType>;
-export declare const getAppEnvDeploymentConfig: (params: AppEnvDeploymentConfigPayloadType, signal?: AbortSignal) => Promise<ResponseType<AppEnvDeploymentConfigDTO>>;
+export declare const getArtifactInfo: (params: Pick<GetCITriggerInfoParamsType, "ciArtifactId">) => Promise<ResponseType<CIMaterialInfoDTO>>;
+export declare const getAppEnvDeploymentConfig: ({ params, signal, isTemplateView, appId, }: {
+    params: AppEnvDeploymentConfigPayloadType;
+    signal?: AbortSignal;
+    isTemplateView: AppConfigProps["isTemplateView"];
+    appId: string | number | null;
+}) => Promise<ResponseType<AppEnvDeploymentConfigDTO>>;
+export declare const getCompareSecretsData: (params: AppEnvDeploymentConfigPayloadType[]) => Promise<AppEnvDeploymentConfigDTO[]>;