@e-llm-studio/repo-data-cart 1.0.0

package/README.md

@@ -0,0 +1,50 @@
+# React + TypeScript + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/README.md) uses [Babel](https://babeljs.io/) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend updating the configuration to enable type aware lint rules:
+
+- Configure the top-level `parserOptions` property like this:
+
+```js
+export default tseslint.config({
+  languageOptions: {
+    // other options...
+    parserOptions: {
+      project: ['./tsconfig.node.json', './tsconfig.app.json'],
+      tsconfigRootDir: import.meta.dirname,
+    },
+  },
+});
+```
+
+- Replace `tseslint.configs.recommended` to `tseslint.configs.recommendedTypeChecked` or `tseslint.configs.strictTypeChecked`
+- Optionally add `...tseslint.configs.stylisticTypeChecked`
+- Install [eslint-plugin-react](https://github.com/jsx-eslint/eslint-plugin-react) and update the config:
+
+```js
+// eslint.config.js
+import react from 'eslint-plugin-react';
+
+export default tseslint.config({
+  // Set the react version
+  settings: { react: { version: '18.3' } },
+  plugins: {
+    // Add the react plugin
+    react,
+  },
+  rules: {
+    // other rules...
+    // Enable its recommended rules
+    ...react.configs.recommended.rules,
+    ...react.configs['jsx-runtime'].rules,
+  },
+});
+```

package/dist/app/api/repo.api.service.d.ts

@@ -0,0 +1,4 @@
+import { IExistingRepoData } from '../types/types';
+export default class RepoApiService {
+    static getRepos(url: string): Promise<IExistingRepoData[]>;
+}

package/dist/app/components/badges/Badge.d.ts

@@ -0,0 +1,46 @@
+import { default as React } from 'react';
+import { SlotProps } from '../../types/types';
+export type BadgeColor = 'default' | 'primary' | 'secondary' | 'error' | 'warning' | 'info' | 'success';
+export type BadgeVariant = 'standard' | 'dot';
+export type BadgeOverlap = 'rectangular' | 'circular';
+export interface BadgeAnchorOrigin {
+    vertical: 'top' | 'bottom';
+    horizontal: 'left' | 'right';
+}
+export type BadgeSlotProps = {
+    root?: SlotProps<'span'>;
+    badge?: SlotProps<'span'>;
+};
+export type BadgeProps = BadgeSlotProps & {
+    children: React.ReactNode;
+    badgeContent?: React.ReactNode;
+    color?: BadgeColor;
+    variant?: BadgeVariant;
+    anchorOrigin?: BadgeAnchorOrigin;
+    overlap?: BadgeOverlap;
+    max?: number;
+    showZero?: boolean;
+    invisible?: boolean;
+    className?: string;
+    slotProps?: BadgeSlotProps;
+};
+/**
+ * Badge — a Material UI-style notification badge.
+ *
+ * <Badge badgeContent={4} color="primary">
+ *   <MailIcon />
+ * </Badge>
+ *
+ * Every Tailwind class this component applies internally can be
+ * overridden by the consumer:
+ *  - `className`      -> merged onto the outer wrapper span
+ *  - `badgeClassName`  -> merged onto the badge bubble itself
+ *
+ * Because both props are appended *after* the component's own
+ * classes, a conflicting utility supplied by the consumer (e.g.
+ * `bg-black` to override the default `bg-blue-600`) will win as
+ * long as your Tailwind build places user-authored classes after
+ * component classes in the generated stylesheet (true for a
+ * standard single Tailwind build, which is the common case).
+ */
+export declare function Badge({ children, badgeContent, color, variant, anchorOrigin, overlap, max, showZero, invisible, className, slotProps, }: BadgeProps): React.JSX.Element;

package/dist/app/components/buttons/PrimaryButtonNative.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+import { SlotProps } from '../../types/types';
+export type PrimaryButtonSlotProps = {
+    root?: SlotProps<'button'> & {
+        disabledClassName?: string;
+    };
+    content?: SlotProps<'div'>;
+    icon?: SlotProps<'span'>;
+    label?: SlotProps<'span'>;
+};
+export type PrimaryButtonNativeProps = {
+    children: React.ReactNode;
+    disabled?: boolean;
+    iconProps?: {
+        icon?: React.ReactNode;
+        iconPos?: 'left' | 'right';
+        loadingIcon?: React.ReactNode;
+    };
+    slotProps?: PrimaryButtonSlotProps;
+    loading?: boolean;
+};
+export default function PrimaryButtonNative({ children, disabled, loading, iconProps, slotProps, }: PrimaryButtonNativeProps): React.JSX.Element;

package/dist/app/components/cards/ActionCard.d.ts

@@ -0,0 +1,26 @@
+import { default as React } from 'react';
+import { SlotProps } from '../../types/types';
+export type ActionCardSlotProps = {
+    root?: SlotProps<'button'>;
+    icon?: SlotProps<'span'>;
+    content?: SlotProps<'span'>;
+    title?: SlotProps<'span'>;
+    description?: SlotProps<'span'>;
+    arrow?: SlotProps<'div'>;
+};
+export interface ActionCardProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    icon: React.ReactNode;
+    title: string;
+    description: string;
+    arrowIcon?: React.ReactNode;
+    slotProps?: ActionCardSlotProps;
+}
+/**
+ * ActionCard
+ *
+ * A clickable row card with an icon tile on the left,
+ * title and description in the middle, and an optional
+ * arrow on the right.
+ */
+export declare function ActionCard({ icon, title, description, arrowIcon, slotProps, className, type, ...rest }: ActionCardProps): React.JSX.Element;
+export default ActionCard;

package/dist/app/components/cards/CustomRadioCard.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+interface CustomRadioCardProps {
+    children?: React.ReactNode;
+    selected?: boolean;
+    disabled?: boolean;
+    onSelect?: () => void;
+}
+declare const CustomRadioCard: React.FC<CustomRadioCardProps>;
+export default CustomRadioCard;

package/dist/app/components/cards/GithubRepoRadioCard.d.ts

@@ -0,0 +1,51 @@
+import { default as React } from 'react';
+import { SlotProps } from '../../types/types';
+import { ChipProps } from '../chips/CustomChip';
+interface GithubRepoRadioCardProps {
+    title: string;
+    description: string;
+    organization: string;
+    repoUrl: string;
+    branch: string;
+    lastAnalyzedDate: string;
+    itemNumber: number;
+    selected?: boolean;
+    disabled?: boolean;
+    status: string;
+    onSelect?: () => void;
+    showNavigateToAppModeOption?: boolean;
+    onDescriptionClick?: () => void;
+    disableShowNavigation?: boolean;
+    slot?: {
+        root?: SlotProps<'div'>;
+        headerContainer?: SlotProps<'div'>;
+        titleText?: SlotProps<'p'>;
+        chipsContainer?: SlotProps<'div'>;
+        githubChip?: {
+            root?: ChipProps;
+            icon?: React.ReactNode;
+            textContainer?: SlotProps<'span'>;
+        };
+        branchChip?: {
+            root?: SlotProps<'p'>;
+            icon?: React.ReactNode;
+            textContainer?: SlotProps<'span'>;
+        };
+        descriptionText?: SlotProps<'span'>;
+        lastAnalyzedContainer?: SlotProps<'div'>;
+        viewButton?: {
+            root?: SlotProps<'button'>;
+            icon?: React.ReactNode;
+            label?: string;
+        };
+    };
+    customComponents?: {
+        headerComponent?: React.ReactNode;
+        chipsComponent?: React.ReactNode;
+        descriptionComponent?: React.ReactNode;
+        lastAnalyzedComponent?: React.ReactNode;
+        viewButtonComponent?: React.ReactNode;
+    };
+}
+declare const GithubRepoRadioCard: React.FC<GithubRepoRadioCardProps>;
+export default GithubRepoRadioCard;

package/dist/app/components/cards/RepoCard.d.ts

@@ -0,0 +1,32 @@
+import { default as React } from 'react';
+import { SlotProps } from '../../types/types';
+export interface RepoCardStatus {
+    icon: React.ReactNode;
+    text: string;
+}
+export type RepoCardSlotProps = {
+    root?: SlotProps<'div'>;
+    header?: SlotProps<'div'>;
+    main?: SlotProps<'div'>;
+    checkbox?: SlotProps<'button'>;
+    icon?: SlotProps<'span'>;
+    title?: SlotProps<'span'>;
+    status?: SlotProps<'span'>;
+    actions?: SlotProps<'div'>;
+    openAction?: SlotProps<'button'>;
+    removeAction?: SlotProps<'button'>;
+    description?: SlotProps<'p'>;
+};
+export interface RepoCardProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    icon: React.ReactNode;
+    title: string;
+    status?: RepoCardStatus;
+    description: string;
+    checked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    onOpen?: () => void;
+    onRemove?: () => void;
+    slotProps?: RepoCardSlotProps;
+}
+export declare function RepoCard({ icon, title, status, description, checked, onCheckedChange, onOpen, onRemove, className, slotProps, ...rest }: RepoCardProps): React.JSX.Element;
+export default RepoCard;

package/dist/app/components/checkboxes/Checkbox.d.ts

@@ -0,0 +1,29 @@
+import { default as React } from 'react';
+import { SlotProps } from '../../types/types';
+export type CheckboxColor = 'default' | 'primary' | 'secondary' | 'error' | 'warning' | 'info' | 'success';
+export type CheckboxSize = 'small' | 'medium';
+type CheckboxInputSlotProps = Omit<SlotProps<'input'>, 'type' | 'checked' | 'disabled' | 'id'>;
+export type CheckboxSlotProps = {
+    root?: SlotProps<'label'>;
+    control?: SlotProps<'span'>;
+    input?: CheckboxInputSlotProps;
+    box?: SlotProps<'span'>;
+    indeterminate?: SlotProps<'span'>;
+    icon?: SlotProps<'svg'>;
+    label?: SlotProps<'span'>;
+};
+export type CheckboxProps = {
+    color?: CheckboxColor;
+    size?: CheckboxSize;
+    /** Shows a dash instead of a check, without affecting `checked`. */
+    indeterminate?: boolean;
+    /** Optional label rendered next to the box. */
+    label?: React.ReactNode;
+    /** Customization for individual component slots. */
+    slotProps?: CheckboxSlotProps;
+    disabled?: boolean;
+    checked?: boolean;
+    id?: string;
+};
+export declare function Checkbox({ color, size, indeterminate, label, disabled, checked, id, slotProps, }: CheckboxProps): React.JSX.Element;
+export {};

package/dist/app/components/chips/CustomChip.d.ts

@@ -0,0 +1,7 @@
+import { default as React, HTMLAttributes } from 'react';
+export type ChipProps = HTMLAttributes<HTMLParagraphElement> & {
+    children: React.ReactNode;
+    className?: string;
+};
+declare const Chip: ({ children, className, ...rest }: ChipProps) => React.JSX.Element;
+export default Chip;

package/dist/app/components/containers/HighlightedIndex.d.ts

@@ -0,0 +1,5 @@
+declare const HighlightedIndex: ({ index, className }: {
+    index: string | number;
+    className?: string;
+}) => import("react").JSX.Element;
+export default HighlightedIndex;

package/dist/app/components/containers/StandardContainer.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { SlotProps } from '../../types/types';
+export type StandardContainerSlotProps = {
+    root?: SlotProps<'div'>;
+    header?: SlotProps<'div'>;
+    title?: SlotProps<'h2'>;
+    actions?: SlotProps<'div'>;
+    content?: SlotProps<'div'>;
+};
+export interface StandardContainerProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children' | 'title'> {
+    title: React.ReactNode;
+    actions?: React.ReactNode;
+    children: React.ReactNode;
+    slotProps?: StandardContainerSlotProps;
+}
+/**
+ * StandardContainer
+ *
+ * A generic container with a header row containing a title and
+ * optional actions, followed by a content area.
+ */
+export declare function StandardContainer({ title, actions, children, className, slotProps, ...rest }: StandardContainerProps): React.JSX.Element;
+export default StandardContainer;

package/dist/app/components/form-components/SearchInput.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+interface SearchInputProps {
+    searchTerm: string;
+    placeholder?: string;
+    slotProps?: {
+        container?: string;
+        icon?: string;
+        input?: string;
+    };
+    handleOnChange?: (value: string) => void;
+}
+declare const SearchInput: React.FC<SearchInputProps>;
+export default SearchInput;

package/dist/app/components/icon-components/circularRingIcon.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+export type CircularRingIconContainerProps = {
+    icon: React.ReactNode;
+    size?: number;
+    slotStyles?: {
+        outerCircle?: string;
+        innerCircle?: string;
+    };
+};
+export default function CircularRingIconContainer({ icon, size, slotStyles, }: CircularRingIconContainerProps): React.JSX.Element;

package/dist/app/components/loaders/Spinner.d.ts

@@ -0,0 +1,31 @@
+import { default as React } from 'react';
+export type SpinnerColor = 'default' | 'primary' | 'secondary' | 'error' | 'warning' | 'info' | 'success' | 'white';
+export type SpinnerSize = 'small' | 'medium' | 'large' | number;
+export interface SpinnerProps extends React.SVGAttributes<SVGSVGElement> {
+    color?: SpinnerColor;
+    /** "small" | "medium" | "large", or an exact pixel number. */
+    size?: SpinnerSize;
+    /** Stroke thickness, in the SVG's own coordinate units (default 4). */
+    thickness?: number;
+    /** Determinate mode: 0–100. Omit for indeterminate (spinning) mode. */
+    value?: number;
+    /** Accessible label read by screen readers. */
+    label?: string;
+    /** Merged onto the root <svg>. */
+    className?: string;
+}
+/**
+ * Spinner — a Material UI-style circular progress indicator.
+ *
+ * <Spinner />
+ * <Spinner color="secondary" size="large" />
+ * <Spinner size={28} thickness={5} />
+ * <Spinner value={72} />           // determinate
+ * <Spinner className="text-pink-500" />   // Tailwind override
+ *
+ * Color and size are driven by CSS (currentColor + width/height), so
+ * a Tailwind class passed via `className` — e.g. `text-pink-500` or
+ * `h-10 w-10` — overrides the built-in `color`/`size` props, since
+ * it's merged in last.
+ */
+export declare function Spinner({ color, size, thickness, value, label, className, ...rest }: SpinnerProps): React.JSX.Element;

package/dist/app/components/seperators/Divider.d.ts

@@ -0,0 +1,28 @@
+import { default as React } from 'react';
+import { SlotProps } from '../../types/types';
+export type DividerOrientation = 'horizontal' | 'vertical';
+export type DividerTextAlign = 'left' | 'center' | 'right';
+export type DividerSlotProps = {
+    root?: SlotProps<'div'>;
+    line?: SlotProps<'span'>;
+    text?: SlotProps<'span'>;
+};
+export interface DividerProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** Optional label placed inline on the divider line. */
+    children?: React.ReactNode;
+    orientation?: DividerOrientation;
+    /** Where the text sits along the line — only applies with `children`. */
+    textAlign?: DividerTextAlign;
+    /** Inset the line from both edges, like MUI's `inset` variant. */
+    inset?: boolean;
+    /** Customization for individual component slots. */
+    slotProps?: DividerSlotProps;
+}
+/**
+ * Divider
+ *
+ * A horizontal or vertical divider, optionally carrying inline text
+ * at the start, center, or end.
+ */
+export declare function Divider({ children, orientation, textAlign, inset, className, slotProps, ...rest }: DividerProps): React.JSX.Element;
+export default Divider;

package/dist/app/components/skeletons/RepoSkeleton.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+declare const GithubRepoRadioCardSkeleton: React.FC;
+export default GithubRepoRadioCardSkeleton;

package/dist/app/components/ui/CodebaseCart.d.ts

@@ -0,0 +1,50 @@
+import { SlotProps, TCodebaseInCart } from '../../types/types';
+import { DividerProps } from '../seperators/Divider';
+import { ActionCardProps } from '../cards/ActionCard';
+import { RepoCardProps } from '../cards/RepoCard';
+import { StandardContainerProps } from '../containers/StandardContainer';
+import { EmptyCartProps } from './EmptyCart';
+export type CodebaseCartProps = {
+    onCodebaseAdd?: () => void;
+    reposInCart: TCodebaseInCart[];
+    onOpenCodebaseFromCart?: (repo: TCodebaseInCart) => void;
+    onRemoveCodebaseFromCart?: (repo: TCodebaseInCart) => void;
+    onSelectionChange?: (repo: TCodebaseInCart) => void;
+    onSearchAll?: () => void;
+    isSearchAllEnabled?: boolean;
+    slot?: {
+        root?: SlotProps<'div'>;
+        standardContainer?: {
+            root?: StandardContainerProps;
+            actionButton?: SlotProps<'button'>;
+            icon?: React.ReactNode;
+        };
+        emptyCartContainer?: {
+            root?: SlotProps<'div'>;
+            emptyCartIcon?: EmptyCartProps;
+            actionCardContainer?: {
+                root?: SlotProps<'div'>;
+                actionCard?: ActionCardProps;
+            };
+        };
+        allRepoContainer?: {
+            root?: SlotProps<'div'>;
+            singleRepoContainer?: {
+                root?: SlotProps<'div'>;
+                getRepoCardProps?: (repo: TCodebaseInCart) => RepoCardProps;
+            };
+        };
+        divider?: {
+            root?: DividerProps;
+            textElement?: SlotProps<'span'>;
+            text?: string;
+        };
+        searchAllActionCard?: ActionCardProps;
+    };
+    customComponents?: {
+        emptyCartComponent?: React.ReactNode;
+        searchAllActionCardComponent?: React.ReactNode;
+        renderRepoCard?: (repo: TCodebaseInCart, index: number) => React.ReactNode;
+    };
+};
+export declare function CodebaseCart({ onCodebaseAdd, reposInCart, onOpenCodebaseFromCart, onRemoveCodebaseFromCart, onSelectionChange, onSearchAll, isSearchAllEnabled, slot, customComponents, }: CodebaseCartProps): import("react").JSX.Element;

package/dist/app/components/ui/EmptyCart.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { LucideIcon } from 'lucide-react';
+import { SlotProps } from '../../types/types';
+export type EmptyCartSlotProps = {
+    root?: SlotProps<'div'>;
+    iconContainer?: SlotProps<'div'>;
+    icon?: SlotProps<'svg'>;
+    title?: SlotProps<'h2'>;
+    description?: SlotProps<'p'>;
+};
+export interface EmptyCartProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
+    icon: LucideIcon;
+    title: string;
+    description: string;
+    slotProps?: EmptyCartSlotProps;
+}
+declare const EmptyCart: ({ icon: Icon, title, description, className, slotProps, ...rest }: EmptyCartProps) => React.JSX.Element;
+export default EmptyCart;

package/dist/app/components/ui/MultiRepoAction.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+import { SlotProps } from '../../types/types';
+import { CodebaseCartProps } from './CodebaseCart';
+import { BadgeProps } from '../badges/Badge';
+interface MultiRepoActionProps {
+    slots?: {
+        root?: SlotProps<'div'>;
+        cartContainer?: {
+            root?: SlotProps<'div'>;
+            cart?: CodebaseCartProps;
+        };
+        badge?: {
+            root?: BadgeProps;
+            badgeButton?: {
+                root?: SlotProps<'button'>;
+                icon?: React.ReactNode;
+            };
+        };
+    };
+}
+export default function MultiRepoAction({ slots }: MultiRepoActionProps): React.JSX.Element;
+export {};

package/dist/app/components/ui/NoCodebaseFound.d.ts

@@ -0,0 +1,12 @@
+import { CircularRingIconContainerProps } from '../icon-components/circularRingIcon';
+import { SlotProps } from '../../types/types';
+export type NoCodebaseFoundProps = {
+    slot?: {
+        root?: SlotProps<'div'>;
+        textContainer?: SlotProps<'div'>;
+        headingText?: SlotProps<'h3'>;
+        descriptionText?: SlotProps<'p'>;
+        iconContainerProps?: CircularRingIconContainerProps;
+    };
+};
+export default function NoCodebaseFound({ slot }: NoCodebaseFoundProps): import("react").JSX.Element;

package/dist/app/components/ui/RepoLoading.d.ts

@@ -0,0 +1 @@
+export default function RepoLoading(): import("react").JSX.Element;

package/dist/app/components/ui/RepoSelectorHeader.d.ts

@@ -0,0 +1,32 @@
+import { PrimaryButtonSlotProps } from '../buttons/PrimaryButtonNative';
+import { SlotProps } from '../../types/types';
+export type RepoSelectorHeaderProps = {
+    showProceedButton: boolean;
+    showSearchBar?: boolean;
+    showFilter?: boolean;
+    proceedButtonText?: string;
+    fallbackButtonText?: string;
+    onProceed: () => void;
+    onExitRepoSelection: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+    slots?: {
+        root?: SlotProps<'div'>;
+        headingText?: SlotProps<'h1'>;
+        actionsContainerSlots?: {
+            root?: SlotProps<'div'>;
+            searchInputContainerSlots?: {
+                root?: SlotProps<'div'>;
+                searchIcon?: React.ReactNode;
+                input?: SlotProps<'input'>;
+            };
+            filterButtonSlots?: {
+                root?: SlotProps<'button'>;
+                filterIcon?: React.ReactNode;
+                text?: SlotProps<'span'>;
+                chevronIcon?: React.ReactNode;
+            };
+            proceedButtonSlots?: PrimaryButtonSlotProps;
+            exitButtonSlots?: PrimaryButtonSlotProps;
+        };
+    };
+};
+export default function RepoSelectorHeader({ showProceedButton, showSearchBar, showFilter, proceedButtonText, fallbackButtonText, onProceed, onExitRepoSelection, slots, }: RepoSelectorHeaderProps): import("react").JSX.Element;

package/dist/app/pages/RepoSelectorDetailPage.d.ts

@@ -0,0 +1,22 @@
+import { SlotProps, TCodebase } from '../types/types';
+import { RepoSelectorHeaderProps } from '../components/ui/RepoSelectorHeader';
+import { DividerProps } from '../components/seperators/Divider';
+import { NoCodebaseFoundProps } from '../components/ui/NoCodebaseFound';
+type RepoSelectorDetailPageProps = {
+    fetchRepoUrl: string;
+    fetchRepos?: () => TCodebase[];
+    showToast?: (message: string) => void;
+    slots?: {
+        repoSelectionHeaderProps: RepoSelectorHeaderProps;
+        dividerProps?: DividerProps;
+        repoDataContainer: SlotProps<'div'>;
+        noCodebaseFoundProps?: NoCodebaseFoundProps;
+    };
+    customComponents?: {
+        repoLoadingComponent?: React.ReactNode;
+        renderRepoComponent?: (repo: TCodebase) => React.ReactNode;
+        noCodebaseFoundComponent?: React.ReactNode;
+    };
+};
+export default function RepoSelectorDetailPage({ fetchRepoUrl, fetchRepos, slots, customComponents, }: RepoSelectorDetailPageProps): import("react").JSX.Element;
+export {};

package/dist/app/services/converter.service.d.ts

@@ -0,0 +1,4 @@
+import { IExistingRepoData, TCodebase } from '../types/types';
+export default class ConverterService {
+    static convertRepoApiDataToStateData(repositories: IExistingRepoData[]): TCodebase[];
+}

package/dist/app/store/repo-data.store.d.ts

@@ -0,0 +1,28 @@
+import { TCodebase } from '../types/types';
+import { Dispatch, SetStateAction } from 'react';
+export type IRepoAddedToCart = {
+    id: string;
+    selected: boolean;
+};
+type RepoDataProviderProps = {
+    children?: React.ReactNode;
+    repoData: TCodebase[];
+    setRepoData: Dispatch<SetStateAction<TCodebase[]>>;
+    isSearchingAcrossAllRepo: boolean;
+    setIsSearchingAcrossAllRepo: Dispatch<SetStateAction<boolean>>;
+    isRepositorySelectorPageOpen: boolean;
+    setIsRepositorySelectorPageOpen: Dispatch<SetStateAction<boolean>>;
+    refreshRepoData: boolean;
+    showToast?: (type: 'success' | 'error' | 'warning', message: string, subMessage?: string) => void;
+};
+type TRepoContextInternalData = {
+    reposAddedToCart: IRepoAddedToCart[];
+    setRepoAddedToCart: Dispatch<SetStateAction<IRepoAddedToCart[]>>;
+    isRepoDataLoaded: boolean;
+    setIsRepoDataLoaded: Dispatch<SetStateAction<boolean>>;
+    updateCartRepoById: (id: string, updater: (item: IRepoAddedToCart) => IRepoAddedToCart) => void;
+};
+export declare const RepoDataContext: import('react').Context<(RepoDataProviderProps & TRepoContextInternalData) | undefined>;
+export declare const RepoDataProvider: ({ children, repoData, setRepoData, isSearchingAcrossAllRepo, setIsSearchingAcrossAllRepo, isRepositorySelectorPageOpen, setIsRepositorySelectorPageOpen, refreshRepoData, showToast, }: RepoDataProviderProps) => import("react").JSX.Element;
+export declare function useRepoData(): RepoDataProviderProps & TRepoContextInternalData;
+export {};