@sonamu-kit/react-components 0.1.0 → 0.1.2

package/dist/components/ui/table.d.ts

@@ -0,0 +1,24 @@
+import type * as React from "react";
+type TableAlign = "left" | "center" | "right";
+type TableCol<T> = {
+    label: string | React.ReactNode;
+    tc: (row: T, rowIndex?: number) => React.ReactNode;
+    fit?: boolean;
+    className?: string;
+    align?: TableAlign;
+};
+declare function Table({ className, ...props }: React.ComponentProps<"table">): import("react/jsx-runtime").JSX.Element;
+declare function TableHeader({ className, ...props }: React.ComponentProps<"thead">): import("react/jsx-runtime").JSX.Element;
+declare function TableBody({ className, ...props }: React.ComponentProps<"tbody">): import("react/jsx-runtime").JSX.Element;
+declare function TableFooter({ className, ...props }: React.ComponentProps<"tfoot">): import("react/jsx-runtime").JSX.Element;
+declare function TableRow({ className, ...props }: React.ComponentProps<"tr">): import("react/jsx-runtime").JSX.Element;
+declare function TableHead({ className, fit, align, ...props }: React.ComponentProps<"th"> & {
+    fit?: boolean;
+    align?: TableAlign;
+}): import("react/jsx-runtime").JSX.Element;
+declare function TableCell({ className, fit, align, ...props }: React.ComponentProps<"td"> & {
+    fit?: boolean;
+    align?: TableAlign;
+}): import("react/jsx-runtime").JSX.Element;
+declare function TableCaption({ className, ...props }: React.ComponentProps<"caption">): import("react/jsx-runtime").JSX.Element;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, type TableCol, };

package/dist/components/ui/tabs.d.ts

@@ -0,0 +1,7 @@
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+import * as React from "react";
+declare const Tabs: React.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

package/dist/components/ui/textarea.d.ts

@@ -0,0 +1,7 @@
+import { Override } from '../../lib/helpers';
+import * as React from "react";
+export type TextareaProps = Override<React.ComponentProps<"textarea">, {
+    onValueChange?: (value: string) => void;
+}>;
+declare const Textarea: React.ForwardRefExoticComponent<Omit<TextareaProps, "ref"> & React.RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

package/dist/components/ui/toast.d.ts

@@ -0,0 +1,15 @@
+import { VariantProps } from 'class-variance-authority';
+import * as ToastPrimitives from "@radix-ui/react-toast";
+import * as React from "react";
+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/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, };

package/dist/components/ui/toaster.d.ts

@@ -0,0 +1 @@
+export declare function Toaster(): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/toggle-group.d.ts

@@ -0,0 +1,12 @@
+import { VariantProps } from 'class-variance-authority';
+import * as ToggleGroupPrimitive from "@radix-ui/react-toggle-group";
+import * as React from "react";
+declare const ToggleGroup: React.ForwardRefExoticComponent<((Omit<ToggleGroupPrimitive.ToggleGroupSingleProps & React.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupPrimitive.ToggleGroupMultipleProps & React.RefAttributes<HTMLDivElement>, "ref">) & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string>) & React.RefAttributes<HTMLDivElement>>;
+declare const ToggleGroupItem: React.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string> & React.RefAttributes<HTMLButtonElement>>;
+export { ToggleGroup, ToggleGroupItem };

package/dist/components/ui/toggle.d.ts

@@ -0,0 +1,12 @@
+import { VariantProps } from 'class-variance-authority';
+import * as TogglePrimitive from "@radix-ui/react-toggle";
+import * as React from "react";
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const Toggle: React.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string> & React.RefAttributes<HTMLButtonElement>>;
+export { Toggle, toggleVariants };

package/dist/components/ui/tooltip.d.ts

@@ -0,0 +1,7 @@
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import * as React from "react";
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: 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>>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/hooks/index.d.ts

@@ -0,0 +1 @@
+export { toast, useToast } from './use-toast';

package/dist/hooks/use-toast.d.ts

@@ -0,0 +1,44 @@
+import { ToastActionElement, ToastProps } from '../components/ui/toast';
+import * as React from "react";
+type ToasterToast = ToastProps & {
+    id: string;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    action?: ToastActionElement;
+};
+declare const actionTypes: {
+    readonly ADD_TOAST: "ADD_TOAST";
+    readonly UPDATE_TOAST: "UPDATE_TOAST";
+    readonly DISMISS_TOAST: "DISMISS_TOAST";
+    readonly REMOVE_TOAST: "REMOVE_TOAST";
+};
+type ActionType = typeof actionTypes;
+type Action = {
+    type: ActionType["ADD_TOAST"];
+    toast: ToasterToast;
+} | {
+    type: ActionType["UPDATE_TOAST"];
+    toast: Partial<ToasterToast>;
+} | {
+    type: ActionType["DISMISS_TOAST"];
+    toastId?: ToasterToast["id"];
+} | {
+    type: ActionType["REMOVE_TOAST"];
+    toastId?: ToasterToast["id"];
+};
+interface State {
+    toasts: ToasterToast[];
+}
+export declare const reducer: (state: State, action: Action) => State;
+type Toast = Omit<ToasterToast, "id">;
+declare function toast({ ...props }: Toast): {
+    id: string;
+    dismiss: () => void;
+    update: (props: ToasterToast) => void;
+};
+declare function useToast(): {
+    toast: typeof toast;
+    dismiss: (toastId?: string) => void;
+    toasts: ToasterToast[];
+};
+export { useToast, toast };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './components';
+export * from './hooks';
+export * from './lib';

package/dist/lib/caster.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare function caster(zodType: z.ZodType<any>, raw: any): any;
+export declare function fastifyCaster(schema: z.ZodObject<any>): z.ZodPipe<z.ZodTransform<any, any>, z.ZodObject<any, z.core.$strip>>;

package/dist/lib/helpers.d.ts

@@ -0,0 +1,72 @@
+import { default as React, ReactElement } from 'react';
+import { z } from 'zod';
+export type PaginationProps = {
+    activePage?: number;
+    totalPages?: number;
+};
+export type TableColumnWidth = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16;
+export declare function hidden(condition: boolean | undefined): string;
+export declare function searchParamsToParams<T extends z.ZodType<any>>(searchParams: URLSearchParams, paramsSchema: T): z.infer<T>;
+export declare function paramsToSearchParams<T>(params: T): {
+    [key in string]: string | string[];
+};
+export type ErrorObj = {
+    content: string;
+    pointing?: "above" | "below" | "left" | "right";
+};
+export declare function useTypeForm<T extends z.ZodObject<any> | z.ZodArray<any>, U extends z.infer<T>>(zType: T, defaultValue: U): {
+    form: z.core.output<T>;
+    setForm: React.Dispatch<React.SetStateAction<z.core.output<T>>>;
+    register: (objPath: string, _emptyStringTo?: "normal" | "nullable" | "optional") => any;
+    addError: (objPath: string, errorMessage: string | ErrorObj) => void;
+    removeError: (objPath: string) => void;
+    clearError: () => void;
+    reset: () => void;
+};
+type ZodKeys<T extends z.ZodType<any>> = keyof z.infer<T>;
+export declare function useListParams<U extends z.ZodType<any>, T extends Partial<z.infer<U>>>(zType: U, defaultValue: T, options?: {
+    disableSearchParams?: boolean;
+}): {
+    listParams: T;
+    setListParams: (newParams: T) => void;
+    register: (name: ZodKeys<U>) => any;
+};
+export declare function useSelection<T>(allKeys: T[], defaultSelectedKeys?: T[]): {
+    getSelected: (key: T) => boolean;
+    toggle: (key: T) => void;
+    selectedKeys: T[];
+    deselectAll: () => void;
+    selectAll: () => void;
+    isAllSelected: boolean;
+    handleCheckboxClick: (e: React.MouseEvent<HTMLInputElement, MouseEvent>, index: number) => void;
+};
+export declare function sqlDateToDateString(sqlDateString: string | null): string | null;
+export declare function numF(num: number | null | undefined): string | number | undefined | null;
+export declare function dateF(dateValue: string | Date | null | undefined): string | null;
+export declare function datetimeF(dateValue: string | Date | null | undefined): string | null;
+export declare function arrayableToArray<T extends number | string | boolean>(val: T | T[] | undefined): T[];
+export type ControlledModalProps = {
+    open: boolean;
+    close: () => void;
+};
+export declare function useModal<T extends object>(ModalComponent: (props: T & ControlledModalProps) => React.ReactElement, defaultProps: T): {
+    open: (newProps: T) => void;
+    modal: React.FunctionComponentElement<T & ControlledModalProps>;
+};
+export declare function caller<T extends Function>(): {
+    set: (func: T) => void;
+    call: T;
+};
+export type SonamuCol<T> = {
+    label: string;
+    th?: ReactElement;
+    tc: (row: T, index: number) => ReactElement;
+    className?: string;
+    collapsing?: boolean;
+    width?: TableColumnWidth;
+    hidden?: boolean;
+    parentLabel?: string;
+};
+export type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+export type Override<T, U> = Omit<T, keyof U> & U;
+export {};

package/dist/lib/index.d.ts

@@ -0,0 +1,6 @@
+export { Pagination } from '../components/ui/pagination';
+export { caster, fastifyCaster } from './caster';
+export { arrayableToArray, type ControlledModalProps, caller, type DistributiveOmit, dateF, datetimeF, type ErrorObj, hidden, numF, type Override, type PaginationProps, paramsToSearchParams, type SonamuCol, searchParamsToParams, sqlDateToDateString, type TableColumnWidth, useListParams, useModal, useSelection, useTypeForm, } from './helpers';
+export { lazyUpload } from './lazy-upload';
+export { useIsMobile } from './use-mobile';
+export { cn } from './utils';

package/{src/lib/lazy-upload.ts → dist/lib/lazy-upload.d.ts}

@@ -6,15 +6,4 @@
  *
  * @returns 업로드된 URL 배열을 반환하는 Promise
  */
-export function lazyUpload(): Promise<string[]> {
-  return new Promise((resolve) => {
-    document.dispatchEvent(
-      new CustomEvent("app:image-uploader/commit", {
-        detail: {
-          channel: "image-uploader",
-          done: resolve,
-        },
-      }),
-    );
-  });
-}
+export declare function lazyUpload(): Promise<string[]>;

package/dist/lib/use-mobile.d.ts

@@ -0,0 +1 @@
+export declare function useIsMobile(): boolean;

package/dist/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;