@importcsv/react 0.2.1 → 0.2.4

package/build/components/CSVImporter/index.d.ts

@@ -1,32 +1,9 @@
-import { default as React } from 'react';
-declare const CSVImporter: React.ForwardRefExoticComponent<{
-    columns?: import('../../types').Column[] | undefined;
-    importerKey?: string | undefined;
-    onComplete?: ((data: any) => void) | undefined;
-    backendUrl?: string | undefined;
-    user?: Record<string, any> | undefined;
-    metadata?: Record<string, any> | undefined;
-    darkMode?: boolean | undefined;
-    primaryColor?: string | undefined;
-    className?: string | undefined;
-    customStyles?: string | Record<string, string> | undefined;
-    showDownloadTemplateButton?: boolean | undefined;
-    skipHeaderRowSelection?: boolean | undefined;
-    waitOnComplete?: boolean | undefined;
-    language?: string | undefined;
-    customTranslations?: {
-        [language: string]: {
-            [key: string]: string;
-        };
-    } | undefined;
-    demoData?: {
-        fileName: string;
-        csvContent: string;
-    } | undefined;
-} & {
-    isModal?: boolean | undefined;
-    modalIsOpen?: boolean | undefined;
-    modalOnCloseTriggered?: (() => void) | undefined;
-    modalCloseOnOutsideClick?: boolean | undefined;
-} & React.RefAttributes<unknown>>;
+import { CSVImporterProps } from "../../types";
+import "../../index.css";
+import "./style/csv-importer.css";
+import "./style/dark-mode.css";
+import "../Modal/style.css";
+declare const CSVImporter: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<CSVImporterProps> & {
+    ref?: import("preact").Ref<unknown> | undefined;
+}>;
 export default CSVImporter;

package/build/components/Modal/index.d.ts

@@ -0,0 +1,12 @@
+import { ComponentChildren } from 'preact';
+interface ModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    children: ComponentChildren;
+    closeOnOutsideClick?: boolean;
+    className?: string;
+    overlayClassName?: string;
+    contentClassName?: string;
+}
+declare const Modal: ({ isOpen, onClose, children, closeOnOutsideClick, className, overlayClassName, contentClassName }: ModalProps) => import("preact").VNode<any> | null;
+export default Modal;

package/build/config/index.d.ts

@@ -0,0 +1,5 @@
+export function getApiBaseUrl(backendUrl: string): string;
+declare namespace _default {
+    export { getApiBaseUrl };
+}
+export default _default;

package/build/importer/components/Box/index.d.ts

@@ -1,2 +1,2 @@
-import { BoxProps } from './types';
+import { BoxProps } from "./types";
 export default function Box({ className, variants, ...props }: BoxProps): import("react/jsx-runtime").JSX.Element;

package/build/importer/components/Box/types/index.d.ts

@@ -1,6 +1,5 @@
-/// <reference types="react" />
 export type BoxVariant = "fluid" | "mid" | "wide" | "space-l" | "space-mid" | "space-none" | "bg-shade";
-export type BoxProps = React.HTMLAttributes<HTMLDivElement> & {
+export type BoxProps = JSX.HTMLAttributes<HTMLDivElement> & {
     variants?: BoxVariant[];
 };
 export declare const boxVariants: BoxVariant[];

package/build/importer/components/Checkbox/index.d.ts

@@ -1,2 +1,2 @@
-import { CheckboxProps } from './types';
+import { CheckboxProps } from "./types";
 export default function Checkbox({ label, className, ...props }: CheckboxProps): import("react/jsx-runtime").JSX.Element;

package/build/importer/components/Checkbox/types/index.d.ts

@@ -1,4 +1,4 @@
-import { InputHTMLAttributes, ReactElement } from 'react';
+import { InputHTMLAttributes, ReactElement } from "preact/hooks";
 export type CheckboxProps = InputHTMLAttributes<HTMLInputElement> & {
     label?: string | ReactElement;
 };

package/build/importer/components/Input/index.d.ts

@@ -1,2 +1,2 @@
-import { InputProps } from './types';
+import { InputProps } from "./types";
 export default function Input({ as, label, icon, iconAfter, error, options, className, variants, children, ...props }: InputProps): import("react/jsx-runtime").JSX.Element;

package/build/importer/components/Input/types/index.d.ts

@@ -1,4 +1,4 @@
-import { ButtonHTMLAttributes, InputHTMLAttributes, ReactElement } from 'react';
+import { ButtonHTMLAttributes, InputHTMLAttributes, ReactElement } from "preact/hooks";
 export type inputTypes = "date" | "datetime-local" | "email" | "file" | "month" | "number" | "password" | "search" | "tel" | "text" | "time" | "url" | "week";
 export type InputVariants = "fluid" | "small";
 export type InputOption = ButtonHTMLAttributes<HTMLButtonElement> & {

package/build/importer/components/Root/index.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentChildren } from 'preact';
+interface RootProps {
+    children?: ComponentChildren;
+    className?: string;
+    primaryColor?: string;
+}
+declare const _default: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<RootProps> & {
+    ref?: import("preact").Ref<HTMLDivElement> | undefined;
+}>;
+export default _default;

package/build/importer/components/StepLayout/index.d.ts

@@ -0,0 +1,18 @@
+import type { ComponentChildren } from 'preact';
+interface StepLayoutProps {
+    title?: string;
+    subtitle?: string;
+    children: ComponentChildren;
+    headerContent?: ComponentChildren;
+    footerContent?: ComponentChildren;
+    showHeader?: boolean;
+    showFooter?: boolean;
+    className?: string;
+    contentClassName?: string;
+}
+/**
+ * Consistent layout wrapper for all importer steps
+ * Ensures uniform spacing, typography, and structure
+ */
+export default function StepLayout({ title, subtitle, children, headerContent, footerContent, showHeader, showFooter, className, contentClassName, }: StepLayoutProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/build/importer/components/Stepper/hooks/useStepper.d.ts

@@ -1,2 +1,2 @@
-import { Step, StepperProps } from '../types';
+import { Step, StepperProps } from "../types";
 export default function useStepper(steps: Step[], initialStep: number | undefined, skipHeader: boolean): StepperProps;

package/build/importer/components/Stepper/index.d.ts

@@ -1,2 +1,2 @@
-import { StepperProps } from './types';
+import { StepperProps } from "./types";
 export default function Stepper({ steps, current, hide, skipHeader }: StepperProps): import("react/jsx-runtime").JSX.Element | null;

package/build/importer/components/Table/index.d.ts

@@ -1,9 +1,9 @@
-import { default as React } from 'react';
-import { TableProps } from './types';
+import type { JSX } from 'preact';
+import { TableProps } from "./types";
 export default function Table({ data, // An array of objects with the data to be displayed
 keyAsId, // Has to be a unique property in the data array to be used as key
 theme, // A CSS module object to style the table
 mergeThemes, // Should 'theme' be the only style applied (false) or be merged with the default style (true)
 highlightColumns, // Columns that should use the highlighted style
 hideColumns, // Array of columns to be hidden in the display
-emptyState, heading, background, columnWidths, columnAlignments, fixHeader, onRowClick, }: TableProps): React.ReactElement;
+emptyState, heading, background, columnWidths, columnAlignments, fixHeader, onRowClick, }: TableProps): JSX.Element;

package/build/importer/components/ToggleFilter/index.d.ts

@@ -1,3 +1,3 @@
-import { ToggleFilterProps } from './types';
+import { ToggleFilterProps } from "./types";
 declare function ToggleFilter({ options, onChange, className }: ToggleFilterProps): import("react/jsx-runtime").JSX.Element;
 export default ToggleFilter;

package/build/importer/components/Tooltip/index.d.ts

@@ -1,2 +1,2 @@
-import { AsMap, TooltipProps } from './types';
+import { AsMap, TooltipProps } from "./types";
 export default function Tooltip<T extends keyof AsMap>({ as, className, title, children, icon, ...props }: TooltipProps<T>): import("react/jsx-runtime").JSX.Element;

package/build/importer/components/Tooltip/types/index.d.ts

@@ -1,8 +1,8 @@
-import { ReactNode } from 'react';
+import { ReactNode } from "preact/hooks";
 export type AsMap = {
-    div: React.HTMLProps<HTMLDivElement>;
-    span: React.HTMLProps<HTMLSpanElement>;
-    p: React.HTMLProps<HTMLParagraphElement>;
+    div: JSX.HTMLAttributes<HTMLDivElement>;
+    span: JSX.HTMLAttributes<HTMLSpanElement>;
+    p: JSX.HTMLAttributes<HTMLParagraphElement>;
 };
 export type TooltipProps<T extends keyof AsMap = "span"> = {
     as?: T;

package/build/importer/components/UploaderWrapper/NativeDropzone.d.ts

@@ -0,0 +1,11 @@
+import type { ComponentChildren } from 'preact';
+interface NativeDropzoneProps {
+    onFileSelect: (file: File) => void;
+    accept?: Record<string, string[]>;
+    disabled?: boolean;
+    loading?: boolean;
+    className?: string;
+    children?: ComponentChildren;
+}
+export default function NativeDropzone({ onFileSelect, accept, disabled, loading, className, children }: NativeDropzoneProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/build/importer/components/UploaderWrapper/UploaderWrapper.d.ts

@@ -1,2 +1,2 @@
-import { UploaderWrapperProps } from './types';
+import { UploaderWrapperProps } from "./types";
 export default function UploaderWrapper({ onSuccess, setDataError, ...props }: UploaderWrapperProps): import("react/jsx-runtime").JSX.Element;

package/build/importer/components/UploaderWrapper/types/index.d.ts

@@ -1,2 +1,2 @@
-import { UploaderProps } from '../../../features/uploader/types';
+import { UploaderProps } from "../../../features/uploader/types";
 export type UploaderWrapperProps = Omit<UploaderProps, "template"> & {};

package/build/importer/components/VirtualTable/index.d.ts

@@ -0,0 +1,17 @@
+import type { JSX } from 'preact';
+import type { FileRow } from '../../features/main/types';
+interface VirtualTableProps {
+    headers: string[];
+    rows: FileRow[];
+    renderCell: (row: FileRow, colIdx: number, actualRowIdx: number) => JSX.Element;
+    onCellEdit?: (rowIdx: number, colIdx: number, value: string) => void;
+    rowHeight?: number;
+    overscan?: number;
+    stickyHeader?: boolean;
+    stickyFirstColumn?: boolean;
+    getRowClassName?: (row: FileRow, actualRowIdx: number) => string;
+    headerRowIndex?: number;
+    includedColumns: number[];
+}
+export default function VirtualTable({ headers, rows, renderCell, rowHeight, overscan, stickyHeader, stickyFirstColumn, getRowClassName, headerRowIndex, includedColumns, }: VirtualTableProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/build/importer/components/ui/alert.d.ts

@@ -1,8 +1,10 @@
-import { VariantProps } from 'class-variance-authority';
-import * as React from "react";
-declare const Alert: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
-    variant?: "default" | "destructive" | null | undefined;
-} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string> & React.RefAttributes<HTMLDivElement>>;
-declare const AlertTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
-declare const AlertDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const Alert: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<any> & {
+    ref?: import("preact").Ref<HTMLDivElement> | undefined;
+}>;
+declare const AlertTitle: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<JSX.HTMLAttributes<HTMLHeadingElement>> & {
+    ref?: import("preact").Ref<HTMLParagraphElement> | undefined;
+}>;
+declare const AlertDescription: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<JSX.HTMLAttributes<HTMLParagraphElement>> & {
+    ref?: import("preact").Ref<HTMLParagraphElement> | undefined;
+}>;
 export { Alert, AlertTitle, AlertDescription };

package/build/importer/components/ui/button.d.ts

@@ -1,12 +1,12 @@
-import { VariantProps } from 'class-variance-authority';
-import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
 declare const buttonVariants: (props?: ({
     variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
     size?: "default" | "sm" | "lg" | "icon" | null | undefined;
-} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
-export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
-    asChild?: boolean;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export interface ButtonProps extends JSX.HTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
     isLoading?: boolean;
 }
-declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Button: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<ButtonProps> & {
+    ref?: import("preact").Ref<HTMLButtonElement> | undefined;
+}>;
 export { Button, buttonVariants };

package/build/importer/components/ui/card.d.ts

@@ -1,8 +1,19 @@
-import * as React from "react";
-declare const Card: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
-declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
-declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
-declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
-declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
-declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const Card: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<JSX.HTMLAttributes<HTMLDivElement>> & {
+    ref?: import("preact").Ref<HTMLDivElement> | undefined;
+}>;
+declare const CardHeader: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<JSX.HTMLAttributes<HTMLDivElement>> & {
+    ref?: import("preact").Ref<HTMLDivElement> | undefined;
+}>;
+declare const CardTitle: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<JSX.HTMLAttributes<HTMLHeadingElement>> & {
+    ref?: import("preact").Ref<HTMLParagraphElement> | undefined;
+}>;
+declare const CardDescription: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<JSX.HTMLAttributes<HTMLParagraphElement>> & {
+    ref?: import("preact").Ref<HTMLParagraphElement> | undefined;
+}>;
+declare const CardContent: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<JSX.HTMLAttributes<HTMLDivElement>> & {
+    ref?: import("preact").Ref<HTMLDivElement> | undefined;
+}>;
+declare const CardFooter: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<JSX.HTMLAttributes<HTMLDivElement>> & {
+    ref?: import("preact").Ref<HTMLDivElement> | undefined;
+}>;
 export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent };

package/build/importer/components/ui/checkbox.d.ts

@@ -1,4 +1,7 @@
-import * as React from "react";
-import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
-declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export interface CheckboxProps extends JSX.HTMLAttributes<HTMLInputElement> {
+    onCheckedChange?: (checked: boolean) => void;
+}
+declare const Checkbox: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<CheckboxProps> & {
+    ref?: import("preact").Ref<HTMLInputElement> | undefined;
+}>;
 export { Checkbox };

package/build/importer/components/ui/dialog.d.ts

@@ -1,19 +1,39 @@
-import * as React from "react";
-import * as DialogPrimitive from "@radix-ui/react-dialog";
-declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
-declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
-declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
-declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const DialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+import { h } from 'preact';
+import type { ComponentChildren, JSX } from 'preact';
+interface DialogProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: ComponentChildren;
+}
+declare const Dialog: ({ open, onOpenChange, children }: DialogProps) => import("react/jsx-runtime").JSX.Element;
+declare const DialogTrigger: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<h.JSX.HTMLAttributes<HTMLButtonElement>> & {
+    ref?: import("preact").Ref<HTMLButtonElement> | undefined;
+}>;
+interface DialogContentProps extends JSX.HTMLAttributes<HTMLDialogElement> {
+    onClose?: () => void;
+}
+declare const DialogContent: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<DialogContentProps> & {
+    ref?: import("preact").Ref<HTMLDialogElement> | undefined;
+}>;
 declare const DialogHeader: {
-    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    ({ className, ...props }: JSX.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const DialogFooter: {
-    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    ({ className, ...props }: JSX.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
-declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
-declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const DialogTitle: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<h.JSX.HTMLAttributes<HTMLHeadingElement>> & {
+    ref?: import("preact").Ref<HTMLHeadingElement> | undefined;
+}>;
+declare const DialogDescription: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<h.JSX.HTMLAttributes<HTMLParagraphElement>> & {
+    ref?: import("preact").Ref<HTMLParagraphElement> | undefined;
+}>;
+declare const DialogPortal: ({ children }: {
+    children: ComponentChildren;
+}) => ComponentChildren;
+declare const DialogOverlay: () => null;
+declare const DialogClose: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<h.JSX.HTMLAttributes<HTMLButtonElement>> & {
+    ref?: import("preact").Ref<HTMLButtonElement> | undefined;
+}>;
 export { Dialog, DialogPortal, DialogOverlay, DialogClose, DialogTrigger, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogDescription, };

package/build/importer/components/ui/flex.d.ts

@@ -1,14 +1,23 @@
-import * as React from "react";
-interface FlexProps extends React.HTMLAttributes<HTMLDivElement> {
+interface FlexProps extends JSX.HTMLAttributes<HTMLDivElement> {
     direction?: "row" | "column" | "row-reverse" | "column-reverse";
     align?: "start" | "center" | "end" | "stretch" | "baseline";
     justify?: "start" | "center" | "end" | "between" | "around" | "evenly";
     wrap?: boolean;
     gap?: number | string;
 }
-declare const Flex: React.ForwardRefExoticComponent<FlexProps & React.RefAttributes<HTMLDivElement>>;
-declare const Box: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
-declare const HStack: React.ForwardRefExoticComponent<Omit<FlexProps, "direction"> & React.RefAttributes<HTMLDivElement>>;
-declare const VStack: React.ForwardRefExoticComponent<Omit<FlexProps, "direction"> & React.RefAttributes<HTMLDivElement>>;
-declare const Text: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const Flex: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<FlexProps> & {
+    ref?: import("preact").Ref<HTMLDivElement> | undefined;
+}>;
+declare const Box: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<JSX.HTMLAttributes<HTMLDivElement>> & {
+    ref?: import("preact").Ref<HTMLDivElement> | undefined;
+}>;
+declare const HStack: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<Omit<FlexProps, "direction">> & {
+    ref?: import("preact").Ref<HTMLDivElement> | undefined;
+}>;
+declare const VStack: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<Omit<FlexProps, "direction">> & {
+    ref?: import("preact").Ref<HTMLDivElement> | undefined;
+}>;
+declare const Text: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<JSX.HTMLAttributes<HTMLDivElement>> & {
+    ref?: import("preact").Ref<HTMLDivElement> | undefined;
+}>;
 export { Flex, Box, HStack, VStack, Text };

package/build/importer/components/ui/input.d.ts

@@ -1,5 +1,6 @@
-import * as React from "react";
-export interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+export interface InputProps extends JSX.HTMLAttributes<HTMLInputElement> {
 }
-declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+declare const Input: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<InputProps> & {
+    ref?: import("preact").Ref<HTMLInputElement> | undefined;
+}>;
 export { Input };

package/build/importer/components/ui/select.d.ts

@@ -1,13 +1,13 @@
-import * as React from "react";
-import * as SelectPrimitive from "@radix-ui/react-select";
-declare const Select: React.FC<SelectPrimitive.SelectProps>;
-declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
-declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
-declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
-declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, SelectScrollUpButton, SelectScrollDownButton, };
+interface SelectProps extends JSX.SelectHTMLAttributes<HTMLSelectElement> {
+    placeholder?: string;
+    options?: Array<{
+        value: string;
+        label: string;
+        disabled?: boolean;
+    }>;
+    onValueChange?: (value: string) => void;
+}
+declare const Select: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<SelectProps> & {
+    ref?: import("preact").Ref<HTMLSelectElement> | undefined;
+}>;
+export { Select };

package/build/importer/components/ui/switch.d.ts

@@ -1,4 +1,7 @@
-import * as React from "react";
-import * as SwitchPrimitives from "@radix-ui/react-switch";
-declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export interface SwitchProps extends Omit<JSX.HTMLAttributes<HTMLInputElement>, 'type'> {
+    onCheckedChange?: (checked: boolean) => void;
+}
+declare const Switch: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<SwitchProps> & {
+    ref?: import("preact").Ref<HTMLInputElement> | undefined;
+}>;
 export { Switch };

package/build/importer/components/ui/toast.d.ts

@@ -1,15 +1,23 @@
-import { VariantProps } from 'class-variance-authority';
-import * as React from "react";
-import * as ToastPrimitives from "@radix-ui/react-toast";
-declare const ToastProvider: React.FC<ToastPrimitives.ToastProviderProps>;
-declare const ToastViewport: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
-declare const Toast: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React.RefAttributes<HTMLLIElement>, "ref"> & VariantProps<(props?: ({
-    variant?: "default" | "destructive" | null | undefined;
-} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string> & React.RefAttributes<HTMLLIElement>>;
-declare const ToastAction: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
-declare const ToastClose: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
-declare const ToastTitle: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const ToastDescription: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastDescriptionProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-type ToastProps = React.ComponentPropsWithoutRef<typeof Toast>;
-type ToastActionElement = React.ReactElement<typeof ToastAction>;
-export { type ToastProps, type ToastActionElement, ToastProvider, ToastViewport, Toast, ToastTitle, ToastDescription, ToastClose, ToastAction, };
+import { h } from 'preact';
+import type { JSX } from 'preact';
+export interface ToastProps extends JSX.HTMLAttributes<HTMLDivElement> {
+    variant?: 'default' | 'destructive';
+    onClose?: () => void;
+}
+declare const Toast: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<ToastProps> & {
+    ref?: import("preact").Ref<HTMLDivElement> | undefined;
+}>;
+declare const ToastAction: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<h.JSX.HTMLAttributes<HTMLButtonElement>> & {
+    ref?: import("preact").Ref<HTMLButtonElement> | undefined;
+}>;
+declare const ToastClose: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<h.JSX.HTMLAttributes<HTMLButtonElement>> & {
+    ref?: import("preact").Ref<HTMLButtonElement> | undefined;
+}>;
+declare const ToastTitle: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<h.JSX.HTMLAttributes<HTMLDivElement>> & {
+    ref?: import("preact").Ref<HTMLDivElement> | undefined;
+}>;
+declare const ToastDescription: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<h.JSX.HTMLAttributes<HTMLDivElement>> & {
+    ref?: import("preact").Ref<HTMLDivElement> | undefined;
+}>;
+type ToastActionElement = JSX.Element<typeof ToastAction>;
+export { Toast, ToastAction, ToastClose, ToastTitle, ToastDescription, type ToastActionElement, };

package/build/importer/components/ui/tooltip.d.ts

@@ -1,13 +1,20 @@
-import * as React from "react";
-import * as TooltipPrimitive from "@radix-ui/react-tooltip";
-declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
-declare const TooltipRoot: React.FC<TooltipPrimitive.TooltipProps>;
-declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+import type { ComponentChildren } from 'preact';
 interface TooltipProps {
-    content: React.ReactNode;
-    children: React.ReactNode;
+    content: ComponentChildren;
+    children: ComponentChildren;
     delayDuration?: number;
+    side?: 'top' | 'bottom' | 'left' | 'right';
+    className?: string;
 }
-declare const Tooltip: ({ content, children, delayDuration }: TooltipProps) => import("react/jsx-runtime").JSX.Element;
+declare const Tooltip: ({ content, children, delayDuration, side, className }: TooltipProps) => import("react/jsx-runtime").JSX.Element;
+declare const TooltipProvider: ({ children }: {
+    children: ComponentChildren;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const TooltipRoot: ({ content, children, delayDuration, side, className }: TooltipProps) => import("react/jsx-runtime").JSX.Element;
+declare const TooltipTrigger: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<any> & {
+    ref?: import("preact").Ref<HTMLDivElement> | undefined;
+}>;
+declare const TooltipContent: import("preact").FunctionalComponent<import("preact/compat").PropsWithoutRef<any> & {
+    ref?: import("preact").Ref<HTMLDivElement> | undefined;
+}>;
 export { Tooltip, TooltipRoot, TooltipTrigger, TooltipContent, TooltipProvider };

package/build/importer/components/ui/use-toast.d.ts

@@ -1,10 +1,12 @@
-import { ToastActionElement, ToastProps } from './toast';
-import * as React from "react";
+import type { ComponentChildren } from 'preact';
+import type { ToastActionElement, ToastProps } from "./toast";
 type ToasterToast = ToastProps & {
     id: string;
-    title?: React.ReactNode;
-    description?: React.ReactNode;
+    title?: ComponentChildren;
+    description?: ComponentChildren;
     action?: ToastActionElement;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
 };
 declare const actionTypes: {
     readonly ADD_TOAST: "ADD_TOAST";
@@ -34,7 +36,7 @@ type Toast = Omit<ToasterToast, "id">;
 declare function toast({ ...props }: Toast): {
     id: string;
     dismiss: () => void;
-    update: (props: ToasterToast) => void;
+    update: () => void;
 };
 declare function useToast(): {
     toast: typeof toast;

package/build/importer/features/complete/index.d.ts

@@ -1,2 +1,2 @@
-import { CompleteProps } from './types';
+import { CompleteProps } from "./types";
 export default function Complete({ reload, close, isModal }: CompleteProps): import("react/jsx-runtime").JSX.Element;

package/build/importer/features/main/hooks/useStepNavigation.d.ts

@@ -10,7 +10,7 @@ declare function useStepNavigation(initialStep: number, skipHeader: boolean, isD
     setStep: (newStep: number) => void;
     goBack: (backStep?: number) => void;
     goNext: (nextStep?: number) => void;
-    stepper: import('../../../components/Stepper/types').StepperProps;
+    stepper: import("../../../components/Stepper/types").StepperProps;
     stepId: string | number | undefined;
     setStorageStep: any;
 };

package/build/importer/features/main/index.d.ts

@@ -1,2 +1,2 @@
-import { CSVImporterProps } from '../../../types';
+import { CSVImporterProps } from "../../../types";
 export default function Main(props: CSVImporterProps): import("react/jsx-runtime").JSX.Element;

package/build/importer/features/map-columns/components/DropDownFields.d.ts

@@ -1,4 +1,4 @@
-import { InputOption } from '../../../components/Input/types';
+import { InputOption } from "../../../components/Input/types";
 type DropdownFieldsProps = {
     options: {
         [key: string]: InputOption;

package/build/importer/features/map-columns/hooks/useMapColumnsTable.d.ts

@@ -1,6 +1,6 @@
-import { UploadColumn } from '../../../types';
-import { Column } from '../../../../types';
-import { TemplateColumnMapping } from '../types';
+import { UploadColumn } from "../../../types";
+import { Column } from "../../../../types";
+import { TemplateColumnMapping } from "../types";
 export default function useMapColumnsTable(uploadColumns: UploadColumn[], templateColumns: Column[] | undefined, columnsValues: {
     [uploadColumnIndex: number]: TemplateColumnMapping;
 }, isLoading?: boolean, importerKey?: string, backendUrl?: string): {
@@ -11,6 +11,6 @@ export default function useMapColumnsTable(uploadColumns: UploadColumn[], templa
         };
     }[];
     formValues: {
-        [key: number]: import('../types').ColumnMapping;
+        [key: number]: import("../types").ColumnMapping;
     };
 };