@akanjs/ui 0.0.149 → 0.0.151

package/BottomSheet.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+interface BottomSheetProps {
+    open: boolean;
+    onCancel: () => void;
+    children: any;
+    type: "full" | "half";
+}
+export interface BottomSheetRef {
+    open: () => void;
+    close: () => void;
+}
+export declare const BottomSheet: React.ForwardRefExoticComponent<BottomSheetProps & React.RefAttributes<BottomSheetRef>>;
+export {};

package/Button.d.ts

@@ -0,0 +1,9 @@
+import React, { ButtonHTMLAttributes } from "react";
+type ButtonProps<Result> = Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onClick"> & {
+    onClick: (e: React.MouseEvent<HTMLButtonElement>, { onError }: {
+        onError: (error: string) => void;
+    }) => Promise<Result> | Result;
+    onSuccess?: (result: Result) => void;
+};
+export declare const Button: <Result = any>({ className, children, onClick, onSuccess, ...rest }: ButtonProps<Result>) => React.JSX.Element;
+export {};

package/ClientSide.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from "react";
+export interface ClientSideProps {
+    children: any;
+    loading?: ReactNode;
+}
+export declare const ClientSide: ({ children, loading }: ClientSideProps) => import("react").JSX.Element;

package/Copy.d.ts

@@ -0,0 +1,6 @@
+export interface CopyProps {
+    text?: string;
+    copyMessage?: string;
+    children: any;
+}
+export declare const Copy: ({ text, copyMessage, children }: CopyProps) => import("react").JSX.Element;

package/CsrImage.d.ts

@@ -0,0 +1,11 @@
+import { ProtoFile } from "@akanjs/constant";
+import { ImageProps } from "next/image";
+export declare const CsrImage: ({ src, file, className, abstractData, ...props }: Omit<ImageProps, "alt" | "src"> & {
+    src?: string;
+    file?: ProtoFile | {
+        url: string;
+        imageSize: [number, number];
+        abstractData?: string | null;
+    } | null;
+    abstractData?: string;
+}) => import("react").JSX.Element;

package/Data/CardList.d.ts

@@ -0,0 +1,36 @@
+import { DataAction, DataColumn } from "@akanjs/client";
+import { type FilterType, SortType } from "@akanjs/constant";
+import { type FetchInitForm } from "@akanjs/signal";
+import { ReactNode } from "react";
+type DataItemProps<T extends string, M extends {
+    id: string;
+}, L extends {
+    id: string;
+}> = {
+    [key in T]: L;
+} & {
+    sliceName: string;
+};
+interface CardListProps<T extends string, Input, Full extends {
+    id: string;
+}, Light extends {
+    id: string;
+}, Filter extends FilterType> {
+    className?: string;
+    cardListClassName?: string;
+    init?: FetchInitForm<Input, Full, Filter>;
+    sliceName: string;
+    columns: DataColumn<any>[];
+    actions?: DataAction<Light>[] | ((item: Light, idx: number) => DataAction<Light>[]);
+    renderItem: (args: DataItemProps<T, Full, Light>) => ReactNode;
+    renderLoading?: () => ReactNode;
+    renderTemplate?: (props: any) => ReactNode | null;
+    renderView?: (model: Full) => ReactNode | null;
+    renderTitle?: (model: Full) => string | ReactNode;
+}
+export default function CardList<T extends string, Input, Full extends {
+    id: string;
+}, Light extends {
+    id: string;
+}, Sort extends SortType>({ className, cardListClassName, init, sliceName, actions, columns, renderItem, renderLoading, renderTemplate, renderView, renderTitle, }: CardListProps<T, Input, Full, Light, Sort>): import("react").JSX.Element;
+export {};

package/Data/Dashboard.d.ts

@@ -0,0 +1,15 @@
+import { StoreOf } from "@akanjs/store";
+export interface DashboardProps<T extends string, State, SL extends StoreOf<T, State>> {
+    className?: string;
+    summary: {
+        [key: string]: any;
+    };
+    sliceName: string;
+    queryMap: {
+        [key: string]: any;
+    };
+    columns?: string[];
+    presents?: string[];
+    hidePresents?: boolean;
+}
+export default function Dashboard<T extends string, State, SL extends StoreOf<T, State>>({ className, summary, sliceName, queryMap, columns, presents, hidePresents, }: DashboardProps<T, State, SL>): import("react").JSX.Element;

package/Data/Insight.d.ts

@@ -0,0 +1,8 @@
+interface InsightProps<T extends string, Insight> {
+    className?: string;
+    insight: Insight;
+    sliceName: T;
+    columns?: (keyof Insight)[];
+}
+export default function Insight<T extends string, Insight>({ className, insight, sliceName, columns, }: InsightProps<T, Insight>): import("react").JSX.Element;
+export {};

package/Data/Item.d.ts

@@ -0,0 +1,74 @@
+import { Dayjs } from "@akanjs/base";
+import { DataAction, DataColumn } from "@akanjs/client";
+import React, { ReactNode } from "react";
+export declare const convToAntdColumn: (column: DataColumn<any>) => {
+    key: string;
+    dataIndex: string;
+    title: string;
+    responsive: readonly ["xs", "sm", "md", "xl"] | undefined;
+    render: ((value: any, model: any) => ReactNode) | undefined;
+} | {
+    key: string;
+    dataIndex: string;
+    title: string;
+    render: (date: Dayjs) => React.JSX.Element;
+    responsive?: undefined;
+} | {
+    key: string;
+    dataIndex: string;
+    title: string;
+    render: (status: string) => React.JSX.Element;
+    responsive?: undefined;
+} | {
+    key: string;
+    dataIndex: string;
+    title: string;
+    responsive?: undefined;
+    render?: undefined;
+};
+interface ItemProps<T extends string, Full extends {
+    id: string;
+}, Light extends {
+    id: string;
+}> {
+    className?: string;
+    model: Light;
+    sliceName: T;
+    onClick?: () => void;
+    cover?: ReactNode;
+    title?: ReactNode;
+    actions?: DataAction<Light>[];
+    columns?: DataColumn<any>[];
+    children?: ReactNode;
+}
+declare function Item<T extends string, Full extends {
+    id: string;
+}, Light extends {
+    id: string;
+}>({ className, model, sliceName, onClick, title, actions, columns, children, }: ItemProps<T, Full, Light>): React.JSX.Element;
+declare namespace Item {
+    var StatusTag: ({ status, className }: {
+        status: string;
+        className?: string;
+    }) => React.JSX.Element;
+    var RoleTags: ({ role }: {
+        role: string | string[];
+    }) => React.JSX.Element;
+}
+export default Item;
+interface ActionProps<T extends string, M extends {
+    id: string;
+}, L extends {
+    id: string;
+}> {
+    action: DataAction<L>;
+    model: L;
+    sliceName: string;
+}
+export declare const Action: <T extends string, M extends {
+    id: string;
+}, L extends {
+    id: string;
+}>({ action, model, sliceName, outline, }: ActionProps<T, M, L> & {
+    outline?: boolean;
+}) => string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<React.AwaitedReactNode> | React.JSX.Element | null | undefined;

package/Data/ListContainer.d.ts

@@ -0,0 +1,38 @@
+import { DataAction, DataColumn, DataTool, ModelInsightProps, ModelProps } from "@akanjs/client";
+import { SortType } from "@akanjs/constant";
+import { type FetchInitForm } from "@akanjs/signal";
+import React, { ReactNode } from "react";
+interface ListContainerProps<T extends string, State, Input, Full extends {
+    id: string;
+}, Light extends {
+    id: string;
+}, Sort extends SortType> {
+    className?: string;
+    cardListClassName?: string;
+    type?: "card" | "list";
+    query?: {
+        [key: string]: any;
+    };
+    init?: FetchInitForm<Input, Full, Sort>;
+    sliceName: string;
+    create?: boolean;
+    title?: string;
+    sort?: SortType;
+    columns?: DataColumn<any>[];
+    tools?: DataTool[] | ((modelList: Light[]) => DataTool[]);
+    actions?: DataAction<Light>[] | ((item: Light, idx: number) => DataAction<Light>[]);
+    renderDashboard?: ({ summary, hidePresents }: any) => ReactNode;
+    renderItem?: (props: ModelProps<any, any>) => ReactNode;
+    renderTemplate?: (props: any) => ReactNode | null;
+    renderTitle?: (model: Full) => string | ReactNode;
+    renderView?: (model: Full) => ReactNode | null;
+    renderQueryMaker?: () => ReactNode;
+    renderInsight?: (props: ModelInsightProps<any>) => ReactNode;
+    renderLoading?: () => ReactNode;
+}
+export default function ListContainer<T extends string, State, Input, Full extends {
+    id: string;
+}, Light extends {
+    id: string;
+}, Sort extends SortType>({ className, cardListClassName, type, query, init, create, sliceName, title, sort, columns, actions, tools, renderDashboard, renderItem, renderTemplate, renderTitle, renderView, renderQueryMaker, renderInsight, renderLoading, }: ListContainerProps<T, State, Input, Full, Light, Sort>): React.JSX.Element;
+export {};

package/Data/Pagination.d.ts

@@ -0,0 +1,6 @@
+interface PaginationProps<T extends string> {
+    className?: string;
+    sliceName: string;
+}
+export default function Pagination<T extends string>({ className, sliceName }: PaginationProps<T>): import("react").JSX.Element;
+export {};

package/Data/QueryMaker.d.ts

@@ -0,0 +1,9 @@
+interface QueryMakerProps {
+    className?: string;
+    sliceName: string;
+    query?: {
+        [key: string]: any;
+    };
+}
+export default function QueryMaker({ className, sliceName, query }: QueryMakerProps): import("react").JSX.Element;
+export {};

package/Data/TableList.d.ts

@@ -0,0 +1,26 @@
+import { DataAction, DataColumn } from "@akanjs/client";
+import { SortType } from "@akanjs/constant";
+import { type FetchInitForm } from "@akanjs/signal";
+import React, { ReactNode } from "react";
+interface TableListProps<T extends string, Input, Full extends {
+    id: string;
+}, Light extends {
+    id: string;
+}, Sort extends SortType> {
+    className?: string;
+    queryArgs?: any[];
+    init?: FetchInitForm<Input, Full, Sort>;
+    sliceName: string;
+    columns: DataColumn<any>[];
+    renderTemplate?: (props: any) => ReactNode | null;
+    renderTitle?: (model: Full) => string | ReactNode;
+    renderView?: (model: Full) => ReactNode | null;
+    actions?: DataAction<Light>[] | ((item: Light, idx: number) => DataAction<Light>[]);
+    onItemClick?: (item: Light, idx: number) => void;
+}
+export default function TableList<T extends string, Input, Full extends {
+    id: string;
+}, Light extends {
+    id: string;
+}, Sort extends SortType>({ className, init, queryArgs, sliceName, columns, actions, renderTemplate, renderTitle, renderView, onItemClick, }: TableListProps<T, Input, Full, Light, Sort>): React.JSX.Element;
+export {};

package/Data/index.d.ts

@@ -0,0 +1,10 @@
+export declare const Data: {
+    CardList: typeof import("./CardList").default;
+    Dashboard: typeof import("./Dashboard").default;
+    Insight: typeof import("./Insight").default;
+    Item: typeof import("./Item").default;
+    ListContainer: typeof import("./ListContainer").default;
+    Pagination: typeof import("./Pagination").default;
+    TableList: typeof import("./TableList").default;
+    QueryMaker: typeof import("./QueryMaker").default;
+};

package/Data/index_.d.ts

@@ -0,0 +1,8 @@
+export declare const CardList: typeof import("./CardList").default;
+export declare const Dashboard: typeof import("./Dashboard").default;
+export declare const Insight: typeof import("./Insight").default;
+export declare const Item: typeof import("./Item").default;
+export declare const ListContainer: typeof import("./ListContainer").default;
+export declare const Pagination: typeof import("./Pagination").default;
+export declare const TableList: typeof import("./TableList").default;
+export declare const QueryMaker: typeof import("./QueryMaker").default;

package/DatePicker.d.ts

@@ -0,0 +1,38 @@
+import "react-datepicker/dist/react-datepicker.css";
+import { Dayjs } from "@akanjs/base";
+import React from "react";
+interface DatePickerProps {
+    value?: Dayjs | null;
+    onChange: (value: Dayjs | null) => void;
+    showTime?: boolean;
+    format?: string;
+    timeIntervals?: number;
+    disabledDate?: (date: Dayjs) => boolean | null | undefined;
+    className?: string;
+    placement?: "top" | "bottom" | "left" | "right";
+    defaultValue?: Dayjs;
+}
+export declare const DatePicker: {
+    ({ value, onChange, showTime, format, timeIntervals, disabledDate, placement, className, defaultValue, }: DatePickerProps): React.JSX.Element;
+    RangePicker: ({ value, onChange, format, showTime, timeIntervals, disabledDate, className, }: RangePickerProps) => React.JSX.Element;
+    TimePicker: ({ disabled, className, value, format, onChange, timeIntervals, }: TimePickerProps) => React.JSX.Element;
+};
+interface RangePickerProps {
+    value: [Dayjs | null, Dayjs | null];
+    onChange: (value: [Dayjs | null, Dayjs | null]) => void;
+    format?: string;
+    showTime?: boolean;
+    timeIntervals?: number;
+    disabledDate?: (date: Dayjs) => boolean | null | undefined;
+    className?: string;
+}
+interface TimePickerProps {
+    value: Dayjs | null;
+    onChange: (value: Dayjs) => void;
+    format?: string;
+    timeIntervals?: number;
+    disabledDate?: (date: Dayjs) => boolean | null | undefined;
+    className?: string;
+    disabled?: boolean;
+}
+export {};

package/Dialog/Action.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from "react";
+export interface ActionProps {
+    children?: ReactNode;
+}
+export declare const Action: ({ children }: ActionProps) => null;

package/Dialog/Close.d.ts

@@ -0,0 +1,5 @@
+export interface CloseProps {
+    className?: string;
+    children?: any;
+}
+export declare const Close: ({ className, children }: CloseProps) => import("react").JSX.Element;

package/Dialog/Content.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from "react";
+export interface ContentProps {
+    className?: string;
+    children?: ReactNode;
+}
+export declare const Content: ({ className, children }: ContentProps) => import("react").JSX.Element;

package/Dialog/Modal.d.ts

@@ -0,0 +1,8 @@
+export interface ModalProps {
+    className?: string;
+    bodyClassName?: string;
+    confirmClose?: boolean;
+    children?: any;
+    onCancel?: () => void;
+}
+export declare const Modal: ({ className, bodyClassName, confirmClose, children, onCancel }: ModalProps) => import("react").JSX.Element;

package/Dialog/Provider.d.ts

@@ -0,0 +1,7 @@
+export interface ProviderProps {
+    className?: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    children?: any;
+}
+export declare const Provider: ({ className, defaultOpen, open, children }: ProviderProps) => import("react").JSX.Element;

package/Dialog/Title.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from "react";
+export interface TitleProps {
+    children?: ReactNode;
+}
+export declare const Title: ({ children }: TitleProps) => null;

package/Dialog/Trigger.d.ts

@@ -0,0 +1,5 @@
+export interface TriggerProps {
+    className?: string;
+    children?: any;
+}
+export declare const Trigger: ({ className, children }: TriggerProps) => import("react").JSX.Element;

package/Dialog/context.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from "react";
+export interface DialogContextType {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    title: ReactNode;
+    setTitle: (title: ReactNode) => void;
+    action: ReactNode;
+    setAction: (action: ReactNode) => void;
+}
+export declare const DialogContext: import("react").Context<DialogContextType>;

package/Dialog/index.d.ts

@@ -0,0 +1,9 @@
+import { ProviderProps } from "./Provider";
+export declare const Dialog: {
+    ({ children, ...props }: ProviderProps): import("react").JSX.Element;
+    Modal: ({ className, bodyClassName, confirmClose, children, onCancel }: import("./Modal").ModalProps) => import("react").JSX.Element;
+    Title: ({ children }: import("./Title").TitleProps) => null;
+    Action: ({ children }: import("./Action").ActionProps) => null;
+    Trigger: ({ className, children }: import("./Trigger").TriggerProps) => import("react").JSX.Element;
+    Content: ({ className, children }: import("./Content").ContentProps) => import("react").JSX.Element;
+};

package/DragAction.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from "react";
+interface DragActionProps {
+    className?: string;
+    children: any;
+    onClick?: () => void;
+    onLeft?: () => void;
+    onRight?: () => void;
+}
+export declare const DragAction: {
+    ({ className, children, onClick, onLeft, onRight }: DragActionProps): import("react").JSX.Element;
+    Body: ({ children }: BodyProps) => import("react").JSX.Element;
+    Left: ({ children }: LeftProps) => import("react").JSX.Element;
+    Right: ({ children }: RightProps) => import("react").JSX.Element;
+};
+interface BodyProps {
+    children: ReactNode;
+}
+interface LeftProps {
+    children: ReactNode;
+}
+interface RightProps {
+    children: ReactNode;
+}
+export {};

package/DraggableList.d.ts

@@ -0,0 +1,25 @@
+import { type ReactElement, type ReactNode } from "react";
+interface DragListProps<V> {
+    className?: string;
+    mode?: "horizontal" | "vertical";
+    children: ReactElement[];
+    onChange: (value: V[], draggedValue: V, info: {
+        originalIdx: number;
+        newIdx: number;
+        idxChanged: boolean;
+    }) => void;
+}
+interface Cursor {
+    className?: string;
+    children: any;
+}
+interface ItemProps {
+    value: any;
+    children: ReactNode;
+}
+export declare const DraggableList: {
+    <V>({ className, mode, children, onChange }: DragListProps<V>): import("react").JSX.Element;
+    Cursor({ className, children }: Cursor): import("react").JSX.Element;
+    Item: ({ value, children }: ItemProps) => ReactNode;
+};
+export {};

package/Dropdown.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from "react";
+interface DropdownProps {
+    value: ReactNode;
+    content: ReactNode;
+    className?: string;
+    buttonClassName?: string;
+    dropdownClassName?: string;
+}
+export declare const Dropdown: ({ value, content, className, buttonClassName, dropdownClassName }: DropdownProps) => import("react").JSX.Element;
+export {};

package/Empty.d.ts

@@ -0,0 +1,9 @@
+import React, { ReactNode } from "react";
+interface EmptyProps {
+    className?: string;
+    description?: ReactNode;
+    children?: ReactNode;
+    minHeight?: number;
+}
+export declare const Empty: ({ className, description, children, minHeight }: EmptyProps) => React.JSX.Element;
+export {};