@ssa-ui-kit/infra-dash 0.0.2

package/dist/shared/dashboard.d.ts

@@ -0,0 +1,22 @@
+import { Panel } from './panel';
+/**
+ * Represents the configuration data for a dashboard.
+ */
+export type DashboardDefinition = {
+    version: 1;
+};
+/**
+ * Represents a complete dashboard with its metadata and associated panels.
+ * Combines dashboard identity, display information, configuration, and
+ * the collection of panels that make up the dashboard content.
+ */
+export type Dashboard = {
+    /** Unique numeric identifier for the dashboard */
+    id: number;
+    /** Display title of the dashboard shown in the UI */
+    title: string;
+    /** Dashboard-specific configuration and settings */
+    dashboardDefinition: DashboardDefinition;
+    /** Array of panels that belong to this dashboard */
+    panels: Panel[];
+};

package/dist/shared/dataAdapter.d.ts

@@ -0,0 +1,14 @@
+import { Panel, PanelData } from './panel';
+/**
+ * Configuration options for data adapters that transform panel data.
+ * Data adapters are responsible for converting raw panel data into formats
+ * suitable for specific visualization components.
+ *
+ * @template T - The type of panel data, constrained to extend PanelData['data']
+ */
+export type DataAdapterOptions<T extends PanelData['data']> = {
+    /** The panel configuration and metadata */
+    panel: Panel;
+    /** The panel data to be adapted/transformed */
+    data: T;
+};

package/dist/shared/exception.d.ts

@@ -0,0 +1 @@
+export declare const tryCatch: <T, E = Error>(promise: T | Promise<T>) => Promise<readonly [null, Awaited<T>] | readonly [E, null]>;

package/dist/shared/grafana.d.ts

@@ -0,0 +1,50 @@
+import type { Panel as PanelSchema } from '@grafana/schema';
+import type { DataFrameJSON } from '@grafana/data';
+/**
+ * Represents a Grafana dashboard with its basic metadata.
+ * Contains the essential information needed to identify and display a dashboard.
+ */
+export type GrafanaDashboard = {
+    /** Unique string identifier for the dashboard */
+    id: string;
+    /** Display title of the dashboard */
+    title: string;
+};
+/**
+ * Represents a Grafana panel with its configuration and potential sub-panels.
+ */
+export type GrafanaPanel = {
+    /** Unique numeric identifier for the panel */
+    id: number;
+    /** Display title of the panel */
+    title: string;
+    /** Grafana panel schema configuration, null if not available */
+    panelSchema: PanelSchema | null;
+    /** Array of nested panels, null if the panel has no sub-panels */
+    subPanels: GrafanaPanel[] | null;
+};
+/**
+ * Represents Grafana panel data with query results and metadata.
+ * Contains the actual data returned from Grafana queries along with
+ * information about the panel type and structure.
+ */
+export type GrafanaPanelData = {
+    source: 'grafana';
+    data: {
+        /**
+         * Query results indexed by query reference ID.
+         * Each result contains status information and data frames.
+         */
+        results: Record<string, {
+            status: number;
+            /** Array of data frames containing the actual query results */
+            frames: DataFrameJSON[];
+        }>;
+    };
+};
+/**
+ * Type alias for Grafana panel schema.
+ * Re-exports the Panel schema from @grafana/schema for convenience
+ * and to maintain consistent naming conventions in the codebase.
+ */
+export type GrafanaPanelSchema = PanelSchema;

package/dist/shared/icons/DashboardIcon.d.ts

@@ -0,0 +1,2 @@
+import { SVGProps } from '@ssa-ui-kit/core';
+export declare const DashboardIcon: ({ fill, size, tooltip, ...props }: SVGProps) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/shared/icons/ErrorIcon.d.ts

@@ -0,0 +1 @@
+export declare const ErrorIcon: () => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/shared/icons/SidebarIcon.d.ts

@@ -0,0 +1,2 @@
+import { SVGProps } from '@ssa-ui-kit/core';
+export declare const SidebarIcon: ({ fill, size, tooltip, ...props }: SVGProps) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/shared/icons/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ErrorIcon';
+export * from './DashboardIcon';
+export * from './SidebarIcon';

package/dist/shared/panel.d.ts

@@ -0,0 +1,96 @@
+import { RJSFSchema, UiSchema } from '@rjsf/utils';
+import { GrafanaPanelData, GrafanaPanelSchema } from './grafana';
+/**
+ * Defines the configuration and positioning information for a dashboard panel.
+ * Contains both the component configuration and grid layout positioning.
+ */
+export type PanelDefinition = {
+    source: {
+        type: typeof PANEL_DATA_SOURCE.GRAFANA;
+        /** Unique identifier for the Grafana dashboard */
+        dashboardUid: string;
+        /** Unique identifier for the Grafana panel within the dashboard */
+        panelId: number;
+    };
+    component: {
+        /** Unique identifier for the component type */
+        id: string;
+        /** Dynamic properties passed to the component instance */
+        props: Record<string, unknown>;
+    };
+    /** Grid positioning and sizing information */
+    gridPos: Record<'h' | 'w' | 'x' | 'y', number>;
+    /** Version of the panel definition schema */
+    version: 1;
+};
+/**
+ * Represents a complete dashboard panel with its metadata, schema, and definition.
+ * Combines panel identity, display information, data schema, and component configuration.
+ */
+export type Panel = {
+    /** Unique numeric identifier for the panel */
+    id: number;
+    /** Display title shown in the panel header */
+    title: string;
+    /** Grafana-specific panel schema configuration */
+    panelSchema: GrafanaPanelSchema;
+    /** Component and layout definition for the panel */
+    panelDefinition: PanelDefinition;
+};
+/**
+ * Optional schema defining the structure of props this component expects.
+ * Used for validation and form generation in configuration UIs.
+ */
+type PanelConfigProps<T> = object extends T ? {
+    defaultProps?: T;
+    propsSchema?: RJSFSchema;
+} : {
+    defaultProps: T;
+    propsSchema: RJSFSchema;
+};
+/**
+ * Configuration object for registering a panel component type.
+ * Defines how a specific component should be rendered and what panel types it supports.
+ */
+export type PanelConfig<T extends Record<string, unknown> | undefined> = {
+    /** Unique identifier for this component type */
+    componentId: string;
+    /** React component that will render the panel */
+    Component: React.ComponentType<{
+        panel: Panel;
+    }>;
+    /** Human-readable name for this panel type */
+    name: string;
+    /** Array of Grafana panel types this component can handle */
+    supportedTypes: string[];
+    uiSchema?: UiSchema;
+} & PanelConfigProps<Omit<T, 'panel' | 'panelData'>>;
+/**
+ * Constant object defining available panel data sources.
+ * Currently only supports Grafana as a data source.
+ */
+export declare const PANEL_DATA_SOURCE: {
+    readonly GRAFANA: "grafana";
+};
+export type PanelDataSource = (typeof PANEL_DATA_SOURCE)[keyof typeof PANEL_DATA_SOURCE];
+/**
+ * Pattern matching utility function for handling different panel data sources.
+ * Provides type-safe way to handle operations based on the data source type.
+ *
+ * @param source - The panel data source to match against
+ * @param handlers - Object containing handler functions for each data source type
+ */
+export declare const matchPanelDataSource: <Grafana>(source: PanelDataSource, handlers: {
+    grafana: () => Grafana;
+}) => Grafana;
+/**
+ * Represents panel data with its source and associated data.
+ * Currently only supports Grafana as a data source.
+ */
+export type PanelData = {
+    /** The data source type identifier */
+    source: typeof PANEL_DATA_SOURCE.GRAFANA;
+    /** The actual panel data from Grafana */
+    data: GrafanaPanelData;
+};
+export {};

package/dist/shared/panelRegistry.d.ts

@@ -0,0 +1,9 @@
+import { PanelConfig } from './panel';
+type AnyProps = Record<string, unknown> | undefined;
+export declare class PanelRegistry {
+    private panels;
+    registerPanel(panelConfig: PanelConfig<AnyProps>): void;
+    getPanelConfig(componentId: string): PanelConfig<AnyProps>;
+    findPanelConfigsByType(type: string): PanelConfig<AnyProps>[];
+}
+export {};

package/dist/shared/query/index.d.ts

@@ -0,0 +1,4 @@
+export * from './query';
+export * from './useQuery';
+export * from './mutation';
+export * from './useMutation';

package/dist/shared/query/key.d.ts

@@ -0,0 +1,4 @@
+export type MutationKey = unknown[];
+export type QueryKey = unknown[];
+export declare const hashKey: (queryKey: QueryKey | MutationKey) => string;
+export declare function partialMatchKey(a: QueryKey, b: QueryKey): boolean;

package/dist/shared/query/mutation.d.ts

@@ -0,0 +1,35 @@
+import { MutationKey } from './key';
+export type MutationState<T> = {
+    data?: T;
+    error?: unknown;
+    isLoading: boolean;
+};
+type Subscriber<T> = (state: MutationState<T>) => void;
+export type MutationFn<T, V> = (variables: V, signal: AbortSignal) => Promise<T>;
+export type MutationOptions<T, V> = {
+    onSuccess?: (data: T, variables: V) => void;
+    onError?: (error: unknown, variables: V) => void;
+    onSettled?: (error: unknown | undefined, data: T | undefined, variables: V) => void;
+};
+export declare class MutationEntry<T, V> {
+    key: MutationKey;
+    mutationFn: MutationFn<T, V>;
+    options: MutationOptions<T, V> | undefined;
+    state: MutationState<T>;
+    promise: Promise<T | undefined> | null;
+    subscribers: Set<Subscriber<T>>;
+    private controller;
+    constructor(key: MutationKey, mutationFn: MutationFn<T, V>, options?: MutationOptions<T, V>);
+    private notify;
+    updateEntity(mutationFn: MutationFn<T, V>, options?: MutationOptions<T, V>): void;
+    mutate(...args: V extends undefined ? [] : [V]): Promise<T | undefined>;
+    subscribe(sub: Subscriber<T>): () => void;
+    cancel(): void;
+    reset(): void;
+}
+export declare class MutationClient {
+    private cache;
+    fetchMutation<T, V>(key: MutationKey, mutationFn: MutationFn<T, V>, options?: MutationOptions<T, V>): MutationEntry<T, V>;
+}
+export declare const mutationClient: MutationClient;
+export {};

package/dist/shared/query/query.d.ts

@@ -0,0 +1,52 @@
+import { QueryKey } from './key';
+export type QueryState<T> = {
+    isLoaded: false;
+    isFetching: boolean;
+    data: undefined;
+    error: null;
+} | {
+    isLoaded: true;
+    isFetching: boolean;
+    data: T;
+    error: null;
+} | {
+    isLoaded: true;
+    isFetching: boolean;
+    data: undefined;
+    error: Error;
+};
+type Subscriber<T> = (state: QueryState<T>) => void;
+export type Fetcher<T> = (signal: AbortSignal) => Promise<T>;
+export type QueryOptions = {
+    enabled?: boolean;
+};
+export declare class QueryEntry<T> {
+    key: QueryKey;
+    fetcher: Fetcher<T>;
+    options: QueryOptions;
+    state: QueryState<T>;
+    promise: Promise<T | undefined> | null;
+    subscribers: Set<Subscriber<T>>;
+    private controller;
+    constructor(key: QueryKey, fetcher: Fetcher<T>, options?: QueryOptions);
+    private notify;
+    updateEntity(fetcher: Fetcher<T>, options?: QueryOptions): QueryEntry<T>;
+    fetch(): Promise<T | undefined>;
+    subscribe(sub: Subscriber<T>): () => void;
+    setData(data: T): void;
+    invalidate(reset?: boolean): void;
+    cancel(): void;
+}
+export declare class QueryClient {
+    private cache;
+    get<T>(key: QueryKey): QueryEntry<T> | undefined;
+    fetchQuery<T>(key: QueryKey, fetcher: Fetcher<T>, options?: QueryOptions): QueryEntry<T>;
+    invalidateQueries({ key, exact, reset, }: {
+        key: QueryKey;
+        exact?: boolean;
+        reset?: boolean;
+    }): void;
+    setQueryData<T>(key: QueryKey, data: T): void;
+}
+export declare const queryClient: QueryClient;
+export {};

package/dist/shared/query/useMutation.d.ts

@@ -0,0 +1,11 @@
+import { MutationFn, MutationOptions } from './mutation';
+import { MutationKey } from './key';
+export declare const useMutationClient: () => import("./mutation").MutationClient;
+export declare const useMutation: <T, V = unknown>(key: MutationKey, mutationFn: MutationFn<T, V>, options?: MutationOptions<T, V>) => {
+    mutate: (...args: Parameters<(...args: V extends undefined ? [] : [V]) => Promise<T | undefined>>) => Promise<T | undefined>;
+    data: T | undefined;
+    error: unknown;
+    isLoading: boolean;
+    reset: () => void;
+    cancel: () => void;
+};

package/dist/shared/query/useQuery.d.ts

@@ -0,0 +1,22 @@
+import { Fetcher, QueryOptions } from './query';
+import { QueryKey } from './key';
+export declare const useQueryClient: () => import("./query").QueryClient;
+export declare const useQuery: <T>(key: QueryKey, fetcher: Fetcher<T>, options?: QueryOptions) => {
+    refetch: () => void;
+    isLoaded: false;
+    isFetching: boolean;
+    data: undefined;
+    error: null;
+} | {
+    refetch: () => void;
+    isLoaded: true;
+    isFetching: boolean;
+    data: undefined;
+    error: Error;
+} | {
+    refetch: () => void;
+    isLoaded: true;
+    isFetching: boolean;
+    data: T;
+    error: null;
+};

package/dist/shared/transport/baseTransport.d.ts

@@ -0,0 +1,35 @@
+import { Dashboard, DashboardDefinition } from '../dashboard';
+import { GrafanaDashboard, GrafanaPanel, GrafanaPanelData } from '../grafana';
+import { PanelDefinition } from '../panel';
+export type CreateDashboardPayload = {
+    title: string;
+    dashboardUid: string;
+    dashboardDefinition: DashboardDefinition;
+    panels: {
+        id: number;
+        panelDefinition: PanelDefinition;
+    }[];
+};
+export type UpdateDashboardPayload = {
+    dashboardId: number;
+    title: string;
+    dashboardDefinition: DashboardDefinition;
+    panels: {
+        id: number;
+        panelDefinition: PanelDefinition;
+    }[];
+};
+export interface InfraDashTransport {
+    getGrafanaDashboards: (signal?: AbortSignal) => Promise<GrafanaDashboard[]>;
+    getGrafanaPanels: (grafanaDashboardUid: string, signal?: AbortSignal) => Promise<GrafanaPanel[]>;
+    getGrafanaPanelData: ({ dashboardUid, panelId, }: {
+        dashboardUid: string;
+        panelId: number;
+    }, signal?: AbortSignal) => Promise<GrafanaPanelData>;
+    getPanelData: (panelId: number, signal?: AbortSignal) => Promise<GrafanaPanelData>;
+    getDashboards: (signal?: AbortSignal) => Promise<Pick<Dashboard, 'id' | 'title'>[]>;
+    getDashboard: (dashboardUid: number, signal?: AbortSignal) => Promise<Dashboard>;
+    createDashboard: (payload: CreateDashboardPayload, signal?: AbortSignal) => Promise<unknown>;
+    updateDashboard: (payload: UpdateDashboardPayload, signal?: AbortSignal) => Promise<unknown>;
+    deleteDashboard: (dashboardId: number, signal?: AbortSignal) => Promise<unknown>;
+}

package/dist/shared/transport/index.d.ts

@@ -0,0 +1,3 @@
+export * from './baseTransport';
+export * from './restTransport';
+export * from './useTransport';

package/dist/shared/transport/restTransport.d.ts

@@ -0,0 +1,29 @@
+import { Dashboard } from '../dashboard';
+import { GrafanaDashboard, GrafanaPanel, GrafanaPanelData } from '../grafana';
+import { CreateDashboardPayload, InfraDashTransport, UpdateDashboardPayload } from './baseTransport';
+export type RestInfraDashTransportConfig = {
+    baseUrl: string;
+    authMiddleware?: (request: Request) => Promise<Request> | Request;
+    unwrapResponse?: <T>(response: unknown) => Promise<T> | T;
+};
+export declare class RestInfraDashTransport implements InfraDashTransport {
+    protected baseUrl: string;
+    protected authMiddleware?: (request: Request) => Promise<Request> | Request;
+    protected unwrapResponse?: <T>(response: unknown) => Promise<T> | T;
+    constructor({ baseUrl, authMiddleware, unwrapResponse, }: RestInfraDashTransportConfig);
+    getUrl(path: string): string;
+    applyMiddlewares(request: Request): Promise<Request>;
+    protected makeRequest<T = unknown>(request: Request, parseResponse?: boolean): Promise<T>;
+    getGrafanaDashboards(signal?: AbortSignal): Promise<GrafanaDashboard[]>;
+    getGrafanaPanels(grafanaDashboardUid: string, signal?: AbortSignal): Promise<GrafanaPanel[]>;
+    getGrafanaPanelData({ dashboardUid, panelId, }: {
+        dashboardUid: string;
+        panelId: number;
+    }, signal?: AbortSignal): Promise<GrafanaPanelData>;
+    getPanelData(panelId: number, signal?: AbortSignal): Promise<GrafanaPanelData>;
+    getDashboards(signal?: AbortSignal): Promise<Pick<Dashboard, "title" | "id">[]>;
+    getDashboard(dashboardUid: number, signal?: AbortSignal): Promise<Dashboard>;
+    createDashboard(payload: CreateDashboardPayload, signal?: AbortSignal): Promise<unknown>;
+    updateDashboard(payload: UpdateDashboardPayload, signal?: AbortSignal): Promise<unknown>;
+    deleteDashboard(dashboardId: number, signal?: AbortSignal): Promise<unknown>;
+}

package/dist/shared/transport/useTransport.d.ts

@@ -0,0 +1,2 @@
+import { InfraDashTransport } from './baseTransport';
+export declare const useTransport: (transport?: InfraDashTransport) => InfraDashTransport;

package/dist/widgets/DashboardEditor/DashboardEditor.d.ts

@@ -0,0 +1,15 @@
+import { DashboardPanelGridProps } from '../../features/DashboardPanelGrid';
+import { Dashboard } from '../../shared/dashboard';
+export type DashboardEditorProps = {
+    dashboard?: Dashboard;
+    defaultDashboard?: Dashboard;
+    gridProps?: DashboardPanelGridProps;
+    onChange?: (dashboard: Dashboard) => void;
+    onSaved?: (dashboard: Dashboard) => void;
+    onCreate?: () => void;
+    onError?: (error: Error) => void;
+} & Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'onError'>;
+export declare const DashboardEditorInternal: ({ dashboard: controlledDashboard, defaultDashboard, gridProps, onChange, onSaved, onCreate, onError, ...divProps }: DashboardEditorProps) => import("@emotion/react/jsx-runtime").JSX.Element;
+export declare const DashboardEditor: ({ dashboardId, ...props }: DashboardEditorProps & {
+    dashboardId?: number;
+}) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/widgets/DashboardEditor/__mock__/index.d.ts

@@ -0,0 +1,20 @@
+import { Dashboard } from '../../../shared/dashboard';
+import { GrafanaDashboard, GrafanaPanel, GrafanaPanelData } from '../../../shared/grafana';
+import { CreateDashboardPayload, RestInfraDashTransport, UpdateDashboardPayload } from '../../../shared/transport';
+export declare const timeseriesData: GrafanaPanelData;
+export declare const bargaugeData: GrafanaPanelData;
+export declare const gaugeData: GrafanaPanelData;
+export declare const dashboard: Dashboard;
+export declare class MockTransport extends RestInfraDashTransport {
+    constructor();
+    protected makeRequest<T = unknown>(request: Request): Promise<T>;
+    getDashboard(): Promise<Dashboard>;
+    getGrafanaDashboards(): Promise<GrafanaDashboard[]>;
+    getGrafanaPanels(grafanaDashboardUid: string): Promise<GrafanaPanel[]>;
+    getGrafanaPanelData({ dashboardUid, panelId, }: {
+        dashboardUid: string;
+        panelId: number;
+    }): Promise<GrafanaPanelData>;
+    createDashboard(payload: CreateDashboardPayload): Promise<unknown>;
+    updateDashboard(payload: UpdateDashboardPayload): Promise<unknown>;
+}

package/dist/widgets/DashboardEditor/components/DashboardSelectorDrawer.d.ts

@@ -0,0 +1,6 @@
+import { useDrawer } from '@ssa-ui-kit/core';
+export type DashboardSelectorDrawerProps = {
+    drawer: ReturnType<typeof useDrawer>;
+    children?: React.ReactNode;
+};
+export declare const DashboardSelectorDrawer: ({ drawer, children, }: DashboardSelectorDrawerProps) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/widgets/DashboardEditor/components/ExternalDashboardsList.d.ts

@@ -0,0 +1,5 @@
+import { GrafanaDashboard, GrafanaPanel } from '../../../shared/grafana';
+export type ExternalDashboardsListProps = {
+    onPanelClick?: (dashboard: GrafanaDashboard, panel: GrafanaPanel) => void;
+} & React.HTMLAttributes<HTMLDivElement>;
+export declare const ExternalDashboardsList: ({ onPanelClick, ...divProps }: ExternalDashboardsListProps) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/widgets/DashboardEditor/components/PanelControl.d.ts

@@ -0,0 +1,8 @@
+import { Panel } from '../../../shared/panel';
+export type PanelControlProps = {
+    panel: Panel;
+    onRemove?: (panel: Panel) => void;
+    onEdit?: (panel: Panel) => void;
+};
+export declare const PanelControlContent: ({ panel, onEdit, onRemove, }: PanelControlProps) => import("@emotion/react/jsx-runtime").JSX.Element;
+export declare const PanelControl: (props: PanelControlProps) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/widgets/DashboardEditor/components/PanelSettings.d.ts

@@ -0,0 +1,7 @@
+import { Panel } from '../../../shared/panel';
+export type PanelSettingsProps = {
+    panel: Panel;
+    onChange?: (panel: Panel) => void;
+    onSave?: () => void;
+};
+export declare const PanelSettings: ({ panel, onChange, onSave, }: PanelSettingsProps) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/widgets/DashboardEditor/components/PanelSettingsDrawer.d.ts

@@ -0,0 +1,6 @@
+import { useDrawer } from '@ssa-ui-kit/core';
+export type PanelSettingsDrawerProps = {
+    drawer: ReturnType<typeof useDrawer>;
+    children?: React.ReactNode;
+};
+export declare const PanelSettingsDrawer: ({ drawer, children, }: PanelSettingsDrawerProps) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/widgets/DashboardEditor/helpers.d.ts

@@ -0,0 +1,39 @@
+import { Dashboard } from '../../shared/dashboard';
+import { GrafanaDashboard, GrafanaPanel } from '../../shared/grafana';
+import { Panel } from '../../shared/panel';
+import { PanelRegistry } from '../../shared/panelRegistry';
+export type AppendPanelParams = {
+    dashboard: Dashboard;
+    panelRegistry: PanelRegistry;
+    source: {
+        type: 'grafana';
+        grafanaDashboard: GrafanaDashboard;
+        grafanaPanel: GrafanaPanel;
+    };
+};
+export declare const appendPanel: (params: AppendPanelParams) => Dashboard;
+export type UpdatePanelParams = {
+    dashboard: Dashboard;
+    panel: Panel;
+};
+export declare const updatePanel: ({ dashboard, panel }: UpdatePanelParams) => {
+    panels: Panel[];
+    id: number;
+    title: string;
+    dashboardDefinition: import("../../shared/dashboard").DashboardDefinition;
+};
+export type RemovePanelParams = {
+    dashboard: Dashboard;
+    panel: Panel;
+};
+export declare const removePanel: ({ dashboard, panel }: RemovePanelParams) => {
+    panels: Panel[];
+    id: number;
+    title: string;
+    dashboardDefinition: import("../../shared/dashboard").DashboardDefinition;
+};
+export type ApplyNewLayoutParams = {
+    dashboard: Dashboard;
+    newLayout: ReactGridLayout.Layout[];
+};
+export declare const applyNewLayout: ({ dashboard, newLayout, }: ApplyNewLayoutParams) => Dashboard;

package/dist/widgets/DashboardEditor/index.d.ts

@@ -0,0 +1 @@
+export * from './DashboardEditor';

package/dist/widgets/DashboardViewer/DashboardViewer.d.ts

@@ -0,0 +1,7 @@
+import { Dashboard } from '../../shared/dashboard';
+import { DashboardPanelGridProps } from '../../features/DashboardPanelGrid';
+export type DashboardViewerProps = {
+    dashboardId?: number;
+    dashboard?: Dashboard;
+} & Omit<DashboardPanelGridProps, 'dashboard'>;
+export declare const DashboardViewer: ({ dashboard, dashboardId, ...props }: DashboardViewerProps) => import("@emotion/react/jsx-runtime").JSX.Element;

package/dist/widgets/DashboardViewer/__mock__/index.d.ts

@@ -0,0 +1,16 @@
+import { Dashboard } from '../../../shared/dashboard';
+import { GrafanaPanelData } from '../../../shared/grafana';
+import { RestInfraDashTransport } from '../../../shared/transport';
+export declare const timeseriesData: GrafanaPanelData;
+export declare const bargaugeData: GrafanaPanelData;
+export declare const gaugeData: GrafanaPanelData;
+export declare const dashboard: Dashboard;
+export declare class MockTransport extends RestInfraDashTransport {
+    constructor();
+    protected makeRequest<T = unknown>(request: Request): Promise<T>;
+    getDashboard(): Promise<Dashboard>;
+    getGrafanaPanelData({ dashboardUid, panelId, }: {
+        dashboardUid: string;
+        panelId: number;
+    }): Promise<GrafanaPanelData>;
+}

package/dist/widgets/DashboardViewer/index.d.ts

@@ -0,0 +1 @@
+export * from './DashboardViewer';

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@ssa-ui-kit/infra-dash",
+  "version": "0.0.2",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "private": false,
+  "sideEffects": false,
+  "author": "SSA Group",
+  "license": "MIT",
+  "description": "SSA UI Kit",
+  "keywords": [
+    "react",
+    "SSA UI Kit",
+    "ui",
+    "monitoring"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ssagroup/ui-kit.git",
+    "directory": "packages/infra-dash"
+  },
+  "files": [
+    "dist"
+  ],
+  "browserslist": [
+    ">0.1%",
+    "not dead",
+    "not op_mini all"
+  ],
+  "dependencies": {
+    "@grafana/data": "^12.0.1",
+    "react-error-boundary": "^6.0.0",
+    "react-grid-layout": "^1.5.1",
+    "react-resizable": "^3.0.5",
+    "@rjsf/validator-ajv8": "^5.24.11",
+    "@rjsf/utils": "^5.24.11",
+    "@ssa-ui-kit/core": "^2.23.2",
+    "@ssa-ui-kit/hooks": "^2.23.2"
+  },
+  "devDependencies": {
+    "@emotion/css": "^11.13.5",
+    "@emotion/jest": "^11.13.0",
+    "@emotion/react": "^11.14.0",
+    "@emotion/styled": "^11.14.0",
+    "@playwright/test": "^1.48.0",
+    "@grafana/schema": "^12.0.1",
+    "@types/react-grid-layout": "^1.3.5"
+  },
+  "peerDependencies": {
+    "@emotion/css": "^11.13.5",
+    "@emotion/react": "^11.14.0",
+    "@emotion/styled": "^11.14.0",
+    "react": "18.x",
+    "react-dom": "18.x"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "test": "jest -i --no-cache",
+    "build": "webpack --mode=production --node-env=production && tsc --build --force ./tsconfig.build.json && resolve-tspaths -p ./tsconfig.build.json",
+    "sb:dev": "storybook dev -p 6009",
+    "sb:build": "storybook build",
+    "test:e2e": "pnpm exec playwright test --project=chromium",
+    "test:e2e:ui": "pnpm exec playwright test --project=chromium --ui",
+    "test:e2e:debug": "pnpm exec playwright test --project=chromium --debug"
+  }
+}