@odigos/ui-kit 0.0.2

package/lib/store/index.d.ts

@@ -0,0 +1,10 @@
+export * from './useDarkMode';
+export * from './useDrawerStore';
+export * from './useEntityStore';
+export * from './useFilterStore';
+export * from './useInstrumentStore';
+export * from './useModalStore';
+export * from './useNotificationStore';
+export * from './usePendingStore';
+export * from './useSelectedStore';
+export * from './useSetupStore';

package/lib/store/useDarkMode.d.ts

@@ -0,0 +1,17 @@
+export interface DarkModeState {
+    darkMode: boolean;
+}
+export interface DarkModeStateSetters {
+    setDarkMode: (bool: boolean) => void;
+}
+export declare const useDarkMode: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<DarkModeState & DarkModeStateSetters>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<DarkModeState & DarkModeStateSetters, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: DarkModeState & DarkModeStateSetters) => void) => () => void;
+        onFinishHydration: (fn: (state: DarkModeState & DarkModeStateSetters) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<DarkModeState & DarkModeStateSetters, unknown>>;
+    };
+}>;

package/lib/store/useDrawerStore.d.ts

@@ -0,0 +1,11 @@
+import { ENTITY_TYPES, type WorkloadId } from '@/types';
+export interface DrawerStoreState {
+    drawerType: ENTITY_TYPES | null;
+    drawerEntityId: string | WorkloadId | null;
+}
+interface DrawerStoreStateSetters {
+    setDrawerType: (value: DrawerStoreState['drawerType']) => void;
+    setDrawerEntityId: (value: DrawerStoreState['drawerEntityId']) => void;
+}
+export declare const useDrawerStore: import("zustand").UseBoundStore<import("zustand").StoreApi<DrawerStoreState & DrawerStoreStateSetters>>;
+export {};

package/lib/store/useEntityStore.d.ts

@@ -0,0 +1,21 @@
+import { type Action, type Destination, ENTITY_TYPES, type InstrumentationRule, type Source, type WorkloadId } from '@/types';
+interface IEntityState {
+    sourcesLoading: boolean;
+    sources: Source[];
+    destinationsLoading: boolean;
+    destinations: Destination[];
+    actionsLoading: boolean;
+    actions: Action[];
+    instrumentationRulesLoading: boolean;
+    instrumentationRules: InstrumentationRule[];
+}
+type EntityId = string | WorkloadId;
+type EntityItems = IEntityState['sources'] | IEntityState['destinations'] | IEntityState['actions'] | IEntityState['instrumentationRules'];
+interface IEntityStateSetters {
+    setEntitiesLoading: (entityType: ENTITY_TYPES, bool: boolean) => void;
+    setEntities: (entityType: ENTITY_TYPES, entities: EntityItems) => void;
+    addEntities: (entityType: ENTITY_TYPES, entities: EntityItems) => void;
+    removeEntities: (entityType: ENTITY_TYPES, entityIds: EntityId[]) => void;
+}
+export declare const useEntityStore: import("zustand").UseBoundStore<import("zustand").StoreApi<IEntityState & IEntityStateSetters>>;
+export {};

package/lib/store/useFilterStore.d.ts

@@ -0,0 +1,37 @@
+import type { DropdownProps } from '@/components';
+export interface FiltersState {
+    searchText?: string;
+    statuses?: DropdownProps['options'];
+    platformTypes?: DropdownProps['options'];
+    namespaces?: DropdownProps['options'];
+    kinds?: DropdownProps['options'];
+    monitors?: DropdownProps['options'];
+    languages?: DropdownProps['options'];
+    errors?: DropdownProps['options'];
+    onlyErrors?: boolean;
+}
+interface StoreState {
+    searchText: FiltersState['searchText'];
+    setSearchText: (setSearchText: FiltersState['searchText']) => void;
+    statuses: FiltersState['statuses'];
+    setStatuses: (statuses: FiltersState['statuses']) => void;
+    platformTypes: FiltersState['platformTypes'];
+    setPlatformTypes: (platformTypes: FiltersState['platformTypes']) => void;
+    namespaces: FiltersState['namespaces'];
+    setNamespaces: (namespaces: FiltersState['namespaces']) => void;
+    kinds: FiltersState['kinds'];
+    setKinds: (kinds: FiltersState['kinds']) => void;
+    monitors: FiltersState['monitors'];
+    setMonitors: (metrics: FiltersState['monitors']) => void;
+    languages: FiltersState['languages'];
+    setLanguages: (metrics: FiltersState['languages']) => void;
+    errors: FiltersState['errors'];
+    setErrors: (metrics: FiltersState['errors']) => void;
+    onlyErrors: FiltersState['onlyErrors'];
+    setOnlyErrors: (onlyErrors: FiltersState['onlyErrors']) => void;
+    setAll: (params: FiltersState) => void;
+    clearAll: () => void;
+    getEmptyState: () => FiltersState;
+}
+export declare const useFilterStore: import("zustand").UseBoundStore<import("zustand").StoreApi<StoreState>>;
+export {};

package/lib/store/useInstrumentStore.d.ts

@@ -0,0 +1,13 @@
+interface StoreValues {
+    isAwaitingInstrumentation: boolean;
+    sourcesToCreate: number;
+    sourcesCreated: number;
+    sourcesToDelete: number;
+    sourcesDeleted: number;
+}
+interface StoreSetters {
+    setInstrumentAwait: (v: boolean) => void;
+    setInstrumentCount: (k: keyof Omit<StoreValues, 'isAwaitingInstrumentation'>, v: number) => void;
+}
+export declare const useInstrumentStore: import("zustand").UseBoundStore<import("zustand").StoreApi<StoreValues & StoreSetters>>;
+export {};

package/lib/store/useModalStore.d.ts

@@ -0,0 +1,6 @@
+interface ModalStoreState {
+    currentModal: string;
+    setCurrentModal: (str: string) => void;
+}
+export declare const useModalStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ModalStoreState>>;
+export {};

package/lib/store/useNotificationStore.d.ts

@@ -0,0 +1,12 @@
+import type { Notification } from '@/types';
+export type NotifyPayload = Omit<Notification, 'id' | 'dismissed' | 'seen' | 'time'>;
+interface StoreState {
+    notifications: Notification[];
+    addNotification: (notif: NotifyPayload) => void;
+    markAsDismissed: (id: string) => void;
+    markAsSeen: (id: string) => void;
+    removeNotification: (id: string) => void;
+    removeNotifications: (target: string) => void;
+}
+export declare const useNotificationStore: import("zustand").UseBoundStore<import("zustand").StoreApi<StoreState>>;
+export {};

package/lib/store/usePendingStore.d.ts

@@ -0,0 +1,14 @@
+import { ENTITY_TYPES, type WorkloadId } from '@/types';
+export interface PendingItem {
+    entityType: ENTITY_TYPES;
+    entityId?: string | WorkloadId;
+}
+interface StoreState {
+    pendingItems: PendingItem[];
+    setPendingItems: (arr: PendingItem[]) => void;
+    addPendingItems: (arr: PendingItem[]) => void;
+    removePendingItems: (arr: PendingItem[]) => void;
+    isThisPending: (item: PendingItem) => boolean;
+}
+export declare const usePendingStore: import("zustand").UseBoundStore<import("zustand").StoreApi<StoreState>>;
+export {};

package/lib/store/useSelectedStore.d.ts

@@ -0,0 +1,12 @@
+import type { Source } from '@/types';
+export interface SelectedState {
+    selectedSources: {
+        [namespace: string]: Source[];
+    };
+}
+interface SelectedStateSetters {
+    setSelectedSources: (payload: SelectedState['selectedSources']) => void;
+    resetSelectedState: () => void;
+}
+export declare const useSelectedStore: import("zustand").UseBoundStore<import("zustand").StoreApi<SelectedState & SelectedStateSetters>>;
+export {};

package/lib/store/useSetupStore.d.ts

@@ -0,0 +1,46 @@
+import type { Destination, DestinationFormData, Source } from '@/types';
+export interface AvailableSourcesByNamespace {
+    [namespace: string]: Pick<Source, 'name' | 'kind' | 'selected' | 'numberOfInstances'>[];
+}
+export interface SourceSelectionFormData {
+    [namespace: string]: Pick<Source, 'name' | 'kind' | 'selected'>[];
+}
+export interface NamespaceSelectionFormData {
+    [namespace: string]: boolean;
+}
+export interface StoredSetupDestination {
+    type: string;
+    displayName: string;
+    imageUrl: string;
+    category: string;
+    exportedSignals: Destination['exportedSignals'];
+    destinationTypeDetails: {
+        title: string;
+        value: string;
+    }[];
+}
+export interface ISetupState {
+    availableSources: AvailableSourcesByNamespace;
+    configuredSources: SourceSelectionFormData;
+    configuredFutureApps: NamespaceSelectionFormData;
+    configuredDestinations: {
+        stored: StoredSetupDestination;
+        form: DestinationFormData;
+    }[];
+}
+interface ISetupStateSetters {
+    setAvailableSources: (payload: ISetupState['availableSources']) => void;
+    setConfiguredSources: (payload: ISetupState['configuredSources']) => void;
+    setConfiguredFutureApps: (payload: ISetupState['configuredFutureApps']) => void;
+    setConfiguredDestinations: (payload: ISetupState['configuredDestinations']) => void;
+    addConfiguredDestination: (payload: {
+        stored: StoredSetupDestination;
+        form: DestinationFormData;
+    }) => void;
+    removeConfiguredDestination: (payload: {
+        type: string;
+    }) => void;
+    resetState: () => void;
+}
+export declare const useSetupStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ISetupState & ISetupStateSetters>>;
+export {};

package/lib/theme/animations/index.d.ts

@@ -0,0 +1,22 @@
+export declare const slide: {
+    in: {
+        left: import("styled-components/dist/models/Keyframes").default;
+        right: import("styled-components/dist/models/Keyframes").default;
+        top: import("styled-components/dist/models/Keyframes").default;
+        bottom: import("styled-components/dist/models/Keyframes").default;
+        center: import("styled-components/dist/models/Keyframes").default;
+    };
+    out: {
+        left: import("styled-components/dist/models/Keyframes").default;
+        right: import("styled-components/dist/models/Keyframes").default;
+        top: import("styled-components/dist/models/Keyframes").default;
+        bottom: import("styled-components/dist/models/Keyframes").default;
+        center: import("styled-components/dist/models/Keyframes").default;
+    };
+};
+export declare const progress: {
+    in: import("styled-components/dist/models/Keyframes").default;
+    out: import("styled-components/dist/models/Keyframes").default;
+};
+export declare const ping: import("styled-components/dist/models/Keyframes").default;
+export declare const shimmer: import("styled-components/dist/models/Keyframes").default;

package/lib/theme/index.d.ts

@@ -0,0 +1,13 @@
+import * as opacity from './opacity';
+import * as palletes from './palletes';
+import * as animations from './animations';
+declare const Theme: {
+    Provider: import("react").FC<{
+        children?: import("react").ReactNode | undefined;
+    }>;
+    useTheme: () => palletes.ITheme;
+    opacity: typeof opacity;
+    palletes: typeof palletes;
+    animations: typeof animations;
+};
+export default Theme;

package/lib/theme/opacity/index.d.ts

@@ -0,0 +1,103 @@
+export declare const hex: {
+    '100': string;
+    '099': string;
+    '098': string;
+    '097': string;
+    '096': string;
+    '095': string;
+    '094': string;
+    '093': string;
+    '092': string;
+    '091': string;
+    '090': string;
+    '089': string;
+    '088': string;
+    '087': string;
+    '086': string;
+    '085': string;
+    '084': string;
+    '083': string;
+    '082': string;
+    '081': string;
+    '080': string;
+    '079': string;
+    '078': string;
+    '077': string;
+    '076': string;
+    '075': string;
+    '074': string;
+    '073': string;
+    '072': string;
+    '071': string;
+    '070': string;
+    '069': string;
+    '068': string;
+    '067': string;
+    '066': string;
+    '065': string;
+    '064': string;
+    '063': string;
+    '062': string;
+    '061': string;
+    '060': string;
+    '059': string;
+    '058': string;
+    '057': string;
+    '056': string;
+    '055': string;
+    '054': string;
+    '053': string;
+    '052': string;
+    '051': string;
+    '050': string;
+    '049': string;
+    '048': string;
+    '047': string;
+    '046': string;
+    '045': string;
+    '044': string;
+    '043': string;
+    '042': string;
+    '041': string;
+    '040': string;
+    '039': string;
+    '038': string;
+    '037': string;
+    '036': string;
+    '035': string;
+    '034': string;
+    '033': string;
+    '032': string;
+    '031': string;
+    '030': string;
+    '029': string;
+    '028': string;
+    '027': string;
+    '026': string;
+    '025': string;
+    '024': string;
+    '023': string;
+    '022': string;
+    '021': string;
+    '020': string;
+    '019': string;
+    '018': string;
+    '017': string;
+    '016': string;
+    '015': string;
+    '014': string;
+    '013': string;
+    '012': string;
+    '011': string;
+    '010': string;
+    '009': string;
+    '008': string;
+    '007': string;
+    '006': string;
+    '005': string;
+    '004': string;
+    '003': string;
+    '002': string;
+    '001': string;
+    '000': string;
+};

package/lib/theme/palletes/index.d.ts

@@ -0,0 +1,105 @@
+declare const darkModeTheme: {
+    darkMode: boolean;
+    colors: {
+        primary: string;
+        secondary: string;
+        border: string;
+        dark_grey: string;
+        translucent_bg: string;
+        dropdown_bg: string;
+        dropdown_bg_2: string;
+        warning: string;
+        error: string;
+        success: string;
+        info: string;
+        default: string;
+        majestic_blue: string;
+        majestic_blue_soft: string;
+        orange_og: string;
+        orange_soft: string;
+        dark_red: string;
+        darker_red: string;
+        darkest_red: string;
+        darkest_red_hover: string;
+        dark_green: string;
+    };
+    text: {
+        white: string;
+        primary: string;
+        secondary: string;
+        grey: string;
+        dark_grey: string;
+        darker_grey: string;
+        light_grey: string;
+        dark_button: string;
+        warning: string;
+        warning_secondary: string;
+        error: string;
+        error_secondary: string;
+        success: string;
+        success_secondary: string;
+        info: string;
+        info_secondary: string;
+        default: string;
+        default_secondary: string;
+    };
+    font_family: {
+        primary: string;
+        secondary: string;
+        code: string;
+    };
+};
+declare const lightModeTheme: {
+    darkMode: boolean;
+    colors: {
+        primary: string;
+        secondary: string;
+        border: string;
+        dark_grey: string;
+        translucent_bg: string;
+        dropdown_bg: string;
+        dropdown_bg_2: string;
+        warning: string;
+        error: string;
+        success: string;
+        info: string;
+        default: string;
+        majestic_blue: string;
+        majestic_blue_soft: string;
+        orange_og: string;
+        orange_soft: string;
+        dark_red: string;
+        darker_red: string;
+        darkest_red: string;
+        darkest_red_hover: string;
+        dark_green: string;
+    };
+    text: {
+        white: string;
+        primary: string;
+        secondary: string;
+        grey: string;
+        dark_grey: string;
+        darker_grey: string;
+        light_grey: string;
+        dark_button: string;
+        warning: string;
+        warning_secondary: string;
+        error: string;
+        error_secondary: string;
+        success: string;
+        success_secondary: string;
+        info: string;
+        info_secondary: string;
+        default: string;
+        default_secondary: string;
+    };
+    font_family: {
+        primary: string;
+        secondary: string;
+        code: string;
+    };
+};
+export type ITheme = typeof darkModeTheme & typeof lightModeTheme;
+export declare const getTheme: (darkMode: boolean) => ITheme;
+export {};

package/lib/theme/provider/index.d.ts

@@ -0,0 +1,3 @@
+import { type FC, type PropsWithChildren } from 'react';
+import './globals.css';
+export declare const Provider: FC<PropsWithChildren>;

package/lib/types/actions/index.d.ts

@@ -0,0 +1,80 @@
+import { SIGNAL_TYPE } from '../signals';
+import type { Condition, SVG } from '../common';
+export declare enum ACTION_TYPE {
+    K8S_ATTRIBUTES = "K8sAttributesResolver",
+    ADD_CLUSTER_INFO = "AddClusterInfo",
+    DELETE_ATTRIBUTES = "DeleteAttribute",
+    RENAME_ATTRIBUTES = "RenameAttribute",
+    ERROR_SAMPLER = "ErrorSampler",
+    PROBABILISTIC_SAMPLER = "ProbabilisticSampler",
+    LATENCY_SAMPLER = "LatencySampler",
+    PII_MASKING = "PiiMasking"
+}
+export interface Action {
+    id: string;
+    type: ACTION_TYPE;
+    conditions: Condition[] | null;
+    spec: {
+        actionName?: string;
+        notes?: string;
+        signals: SIGNAL_TYPE[];
+        disabled?: boolean;
+        collectContainerAttributes?: boolean | null;
+        collectWorkloadId?: boolean | null;
+        collectClusterId?: boolean | null;
+        labelsAttributes?: {
+            labelKey: string;
+            attributeKey: string;
+        }[] | null;
+        annotationsAttributes?: {
+            annotationKey: string;
+            attributeKey: string;
+        }[] | null;
+        clusterAttributes?: {
+            attributeName: string;
+            attributeStringValue: string;
+        }[] | null;
+        attributeNamesToDelete?: string[] | null;
+        renames?: {
+            [oldKey: string]: string;
+        } | null;
+        piiCategories?: string[] | null;
+        fallbackSamplingRatio?: number | null;
+        samplingPercentage?: number | null;
+        endpointsFilters?: {
+            serviceName: string;
+            httpRoute: string;
+            minimumLatencyThreshold: number;
+            fallbackSamplingRatio: number;
+        }[] | null;
+    };
+}
+export interface ActionOption {
+    type?: ACTION_TYPE;
+    icon?: SVG;
+    label: string;
+    description?: string;
+    allowedSignals?: SIGNAL_TYPE[];
+    docsEndpoint?: string;
+    docsDescription?: string;
+    items?: ActionOption[];
+}
+export interface ActionFormData {
+    type: Action['type'];
+    name: Action['spec']['actionName'];
+    notes: Action['spec']['notes'];
+    signals: Action['spec']['signals'];
+    disabled: Action['spec']['disabled'];
+    collectContainerAttributes: Action['spec']['collectContainerAttributes'];
+    collectWorkloadId: Action['spec']['collectWorkloadId'];
+    collectClusterId: Action['spec']['collectClusterId'];
+    labelsAttributes: Action['spec']['labelsAttributes'];
+    annotationsAttributes: Action['spec']['annotationsAttributes'];
+    clusterAttributes: Action['spec']['clusterAttributes'];
+    attributeNamesToDelete: Action['spec']['attributeNamesToDelete'];
+    renames: Action['spec']['renames'];
+    piiCategories: Action['spec']['piiCategories'];
+    fallbackSamplingRatio: Action['spec']['fallbackSamplingRatio'];
+    samplingPercentage: Action['spec']['samplingPercentage'];
+    endpointsFilters: Action['spec']['endpointsFilters'];
+}

package/lib/types/common/index.d.ts

@@ -0,0 +1,126 @@
+import type { FC, MouseEventHandler } from 'react';
+export type SVG = FC<{
+    /**
+     * Size of the SVG icon
+     */
+    size?: number;
+    /**
+     * Fill color of the SVG icon
+     */
+    fill?: string;
+    /**
+     * Rotate the SVG icon by a number of degrees
+     */
+    rotate?: number;
+    /**
+     * Click handler for the SVG icon
+     */
+    onClick?: MouseEventHandler<SVGSVGElement>;
+}>;
+export declare enum TIER {
+    COMMUNITY = "community",
+    CLOUD = "cloud",
+    ONPREM = "onprem"
+}
+export declare enum PLATFORM_TYPE {
+    K8S = "k8s",
+    VM = "vm"
+}
+export declare enum PROGRAMMING_LANGUAGES {
+    GO = "go",
+    JAVASCRIPT = "javascript",
+    PYTHON = "python",
+    JAVA = "java",
+    DOTNET = "dotnet",
+    CSHARP = "csharp",
+    CPLUSPLUS = "cplusplus",
+    PHP = "php",
+    RUBY = "ruby",
+    RUST = "rust",
+    SWIFT = "swift",
+    ELIXIR = "elixir",
+    MYSQL = "mysql",
+    NGINX = "nginx",
+    POSTGRES = "postgres",
+    REDIS = "redis",
+    KAFKA = "kafka",
+    IGNORED = "ignored",
+    UNKNOWN = "unknown",// language detection completed but could not find a supported language
+    PROCESSING = "processing",// language detection is not yet complotted, data is not available
+    NO_CONTAINERS = "no containers",// language detection completed but no containers found or they are ignored
+    NO_RUNNING_PODS = "no running pods"
+}
+export declare enum CRUD {
+    CREATE = "Create",
+    READ = "Read",
+    UPDATE = "Update",
+    DELETE = "Delete"
+}
+export declare enum ENTITY_TYPES {
+    SOURCE = "source",
+    DESTINATION = "destination",
+    ACTION = "action",
+    INSTRUMENTATION_RULE = "rule"
+}
+export declare enum FIELD_TYPES {
+    INPUT = "input",
+    MULTI_INPUT = "multiInput",
+    MULTI_TABLED_INPUT = "multiTabledInput",// not used by dests, but is in form components
+    KEY_VALUE_PAIR = "keyValuePairs",
+    TEXTAREA = "textarea",
+    DROPDOWN = "dropdown",
+    CHECKBOX = "checkbox",
+    TOGGLE = "toggle"
+}
+export declare enum CRD_TYPES {
+    ODIGOS_CONFIGURATION = "OdigosConfiguration",
+    COLLECTORS_GROUP = "CollectorsGroup",
+    SOURCE = "Source",
+    INSTRUMENTATION_CONFIG = "InstrumentationConfig",
+    INSTRUMENTATION_INSTANCE = "InstrumentationInstance",
+    DESTINATION = "Destination",
+    INSTRUMENTATION_RULE = "InstrumentationRule",
+    PROCESSOR = "Processor",
+    ADD_CLUSTER_INFO = "AddClusterInfo",
+    DELETE_ATTTRIBUTE = "DeleteAttribute",
+    RENAME_ATTRIBUTE = "RenameAttribute",
+    PII_MASKING = "PiiMasking",
+    ERROR_SAMPLER = "ErrorSampler",
+    LATENCY_SAMPLER = "LatencySampler",
+    PROBABILISTIC_SAMPLER = "ProbabilisticSampler"
+}
+export declare enum NOTIFICATION_TYPE {
+    WARNING = "warning",
+    ERROR = "error",
+    SUCCESS = "success",
+    INFO = "info",
+    DEFAULT = "default"
+}
+export declare enum OTHER_STATUS {
+    LOADING = "loading",
+    DISABLED = "disabled"
+}
+export interface Condition {
+    status: NOTIFICATION_TYPE | OTHER_STATUS;
+    type: string;
+    reason?: string | null;
+    message?: string | null;
+    lastTransitionTime: string;
+}
+export interface Notification {
+    id: string;
+    type: NOTIFICATION_TYPE;
+    title?: string;
+    message?: string;
+    crdType?: string;
+    target?: string;
+    dismissed: boolean;
+    seen: boolean;
+    hideFromHistory?: boolean;
+    time: string;
+}
+export type CustomFieldProps<T = Record<string, any>> = {
+    value: T;
+    setValue: (key: keyof T, value: any) => void;
+    formErrors: Record<string, string>;
+};

package/lib/types/compute-platform/index.d.ts

@@ -0,0 +1,7 @@
+import { NOTIFICATION_TYPE, PLATFORM_TYPE } from '../common';
+export interface Platform {
+    id: string;
+    name?: string;
+    type: PLATFORM_TYPE;
+    connectionStatus: NOTIFICATION_TYPE;
+}