@dappworks/kit 0.5.40 → 0.5.41

package/dist/jsontable.d.mts

@@ -0,0 +1,126 @@
+import React from 'react';
+import { SpinnerProps, PaginationProps } from '@nextui-org/react';
+import { P as PaginationState } from './PaginationState-c19e621a.js';
+
+type TableClassNames = {
+    table?: string;
+    thead?: string;
+    tr?: string;
+    th?: string;
+    tbody?: string;
+    td?: string;
+};
+type HeaderKeys<T extends Record<string, any>> = Array<keyof T | "$actions">;
+type ColumnConfig<T> = {
+    label?: React.ReactNode;
+    width?: number;
+    hidden?: boolean;
+    sortable?: boolean;
+    sortKey?: string;
+    order?: number;
+    render?: (item: T) => any;
+};
+type ColumnOptions<T> = {
+    [key in keyof T]?: ColumnConfig<T>;
+} & {
+    $actions?: ColumnConfig<T>;
+};
+type CardOptions = {
+    cardContainerClassName?: string;
+    cardClassName?: string;
+    itemClassName?: string;
+    labelClassName?: string;
+    valueClassName?: string;
+    showDivider?: boolean;
+    dividerClassName?: string;
+    virtualizedOptions?: {
+        colSpan?: number;
+        cardContainerClassName?: string;
+    };
+};
+type LoadingOptions = {
+    type?: "skeleton" | "spinner";
+    skeleton?: {
+        boxClassName?: string;
+        skeletonClassName?: string;
+        line?: number;
+    };
+    spinner?: {
+        boxClassName?: string;
+        spinnerProps?: SpinnerProps;
+        text?: string;
+        textClassName?: string;
+    };
+};
+type SortingUIOptions = {
+    showDropdown?: boolean;
+    dropdownTriggerBtnClassName?: string;
+    dropdownContentClassName?: string;
+    dropdownItemClassName?: string;
+    titles?: {
+        asc?: string;
+        desc?: string;
+        none?: string;
+    };
+};
+type CollapsedTableConfig<T> = {
+    classNames?: TableClassNames;
+    options: {
+        key: keyof T;
+        headerKeys: string[];
+        columnOptions: ColumnOptions<any>;
+    }[];
+    collapsedHandlerPosition?: "left" | "right";
+    collapsedHandlerBoxCss?: string;
+    openedIcon?: React.ReactNode;
+    closedIcon?: React.ReactNode;
+    onRowClick?: (item: any) => void;
+    rowCss?: string | ((item: any) => string | undefined);
+    emptyContent?: React.ReactNode;
+};
+type VirtualizedOptions = {
+    isVirtualized?: boolean;
+    vListHeight?: number;
+    classNames?: {
+        header?: string;
+        headerCell?: string;
+        row?: string;
+        rowCell?: string;
+    };
+    cardOptions?: {
+        colSpan?: number;
+        cardContainerClassName?: string;
+    };
+    fetchData?: () => Promise<void>;
+};
+interface JSONTableProps<T extends Record<string, any>> {
+    className?: string;
+    classNames?: TableClassNames;
+    rowKey?: string;
+    dataSource: T[];
+    headerKeys?: HeaderKeys<T>;
+    columnOptions?: ColumnOptions<T>;
+    isServerPaging?: boolean;
+    pagination?: PaginationState;
+    nextuiPaginationProps?: Partial<PaginationProps>;
+    showPagination?: boolean;
+    onRowClick?: (item: T) => void;
+    rowCss?: string | ((item: T) => string | undefined);
+    asCard?: boolean;
+    cardOptions?: CardOptions;
+    autoScrollToTop?: boolean;
+    emptyContent?: React.ReactNode;
+    isLoading?: boolean;
+    loadingOptions?: LoadingOptions;
+    loadingContent?: React.ReactNode;
+    columnSlot?: ((props: {
+        row: T;
+    }) => React.ReactNode) | React.ReactNode;
+    isHeaderSticky?: boolean;
+    sortingUIOptions?: SortingUIOptions;
+    collapsedTableConfig?: CollapsedTableConfig<T>;
+    virtualizedOptions?: VirtualizedOptions;
+}
+declare const JSONTable: <T extends Record<string, any>>(props: JSONTableProps<T>) => React.JSX.Element;
+
+export { CardOptions, CollapsedTableConfig, ColumnOptions, HeaderKeys, JSONTable, LoadingOptions, SortingUIOptions };

package/dist/jsontable.mjs

@@ -1,8 +1,8 @@
-export { JSONTable } from './chunk-MPNSYZJU.mjs';
+export { JSONTable } from './chunk-ISV4OEKJ.mjs';
 import './chunk-ONVPCAMQ.mjs';
-import './chunk-QA3E2PJT.mjs';
+import './chunk-FJHGIW3I.mjs';
 import './chunk-K7LFG5BA.mjs';
-import './chunk-2HNXZE3X.mjs';
-import './chunk-R4SQKVDQ.mjs';
+import './chunk-M5Y3VYMJ.mjs';
+import './chunk-6F7H4PAA.mjs';
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=jsontable.mjs.map

package/dist/metrics.d.mts

@@ -0,0 +1,121 @@
+import React from 'react';
+import { ValueFormatter, CurveType, Color, CustomTooltipProps } from '@tremor/react';
+
+interface ChartBox {
+    title?: React.ReactNode;
+    description?: string;
+    error?: string;
+    data?: {
+        [key: string]: any;
+    }[];
+    children?: React.ReactNode;
+    gridH?: number;
+    numColSpanMd?: number;
+    className?: string;
+    headerClassName?: string;
+    contentClassName?: string;
+    chartClassName?: string;
+}
+declare const ChartBox: ({ title, description, error, children, className, headerClassName, contentClassName }: ChartBox) => React.JSX.Element;
+
+type BarChartCard = ChartBox & {
+    type?: 'BarChartCard';
+    categories?: string[];
+    index?: string;
+    valueFormatter?: ValueFormatter;
+    showLegend?: boolean;
+    showGridLines?: boolean;
+    stack?: boolean;
+    showAnimation?: boolean;
+};
+declare const BarChartCard: (props: BarChartCard) => React.JSX.Element;
+
+type LineChartCard = ChartBox & {
+    type?: 'LineChartCard';
+    categories?: string[];
+    index?: string;
+    curveType?: CurveType;
+    colors?: (Color | string)[];
+    showLegend?: boolean;
+    showGridLines?: boolean;
+    showXAxis?: boolean;
+    showYAxis?: boolean;
+    startEndOnly?: boolean;
+    showTooltip?: boolean;
+    showAnimation?: boolean;
+    autoMinValue?: boolean;
+    valueFormatter?: ValueFormatter;
+    customTooltip?: React.ComponentType<CustomTooltipProps>;
+};
+declare const LineChartCard: (props: LineChartCard) => React.JSX.Element;
+
+type AreaChartCard = ChartBox & {
+    type?: 'AreaChartCard';
+    categories?: string[];
+    index?: string;
+    curveType?: CurveType;
+    colors?: (Color | string)[];
+    showLegend?: boolean;
+    showGridLines?: boolean;
+    stack?: boolean;
+    showXAxis?: boolean;
+    showYAxis?: boolean;
+    startEndOnly?: boolean;
+    showTooltip?: boolean;
+    showAnimation?: boolean;
+    autoMinValue?: boolean;
+    valueFormatter?: ValueFormatter;
+    customTooltip?: React.ComponentType<CustomTooltipProps>;
+};
+declare const AreaChartCard: (props: AreaChartCard) => React.JSX.Element;
+
+type DonutChartCard = ChartBox & {
+    type?: 'DonutChartCard';
+    categories?: string[];
+    index?: string;
+    valueFormatter?: ValueFormatter;
+    showLabel?: boolean;
+    variant?: 'donut' | 'pie';
+    showAnimation?: boolean;
+};
+declare const DonutChartCard: (props: DonutChartCard) => React.JSX.Element;
+
+type CountCard = ChartBox & {
+    type?: 'CountCard';
+    summedColumnIndex?: string;
+};
+declare const CountCard: (props: CountCard) => React.JSX.Element;
+
+type TableCard = ChartBox & {
+    type?: 'TableCard';
+    columnOptions?: {
+        [key: string]: {
+            label: string;
+            hidden: boolean;
+        };
+    };
+};
+declare const TableCard: (props: TableCard) => React.JSX.Element;
+
+type KPICard = ChartBox & {
+    type?: 'KPICard';
+    categories?: string[];
+    index?: string;
+    chartType?: 'area' | 'line';
+    curveType?: 'linear' | 'step' | 'monotone';
+    metricTitle?: string;
+    metric?: string | number;
+    valueFormatter?: ValueFormatter;
+    loading?: boolean;
+};
+declare const KPICard: (props: KPICard) => React.JSX.Element;
+
+type JSONMetricsViewType = AreaChartCard | LineChartCard | BarChartCard | DonutChartCard | CountCard | TableCard | KPICard;
+declare const JSONMetricsView: ({ data }: {
+    data: JSONMetricsViewType[];
+}) => React.JSX.Element;
+declare const MetricsView: ({ data }: {
+    data: JSONMetricsViewType;
+}) => React.JSX.Element;
+
+export { JSONMetricsView, JSONMetricsViewType, MetricsView };

package/dist/metrics.mjs

@@ -1,9 +1,9 @@
-import { JSONTable } from './chunk-MPNSYZJU.mjs';
+import { JSONTable } from './chunk-ISV4OEKJ.mjs';
 import './chunk-ONVPCAMQ.mjs';
-import { SkeletonBox } from './chunk-QA3E2PJT.mjs';
+import { SkeletonBox } from './chunk-FJHGIW3I.mjs';
 import './chunk-K7LFG5BA.mjs';
-import { cn } from './chunk-2HNXZE3X.mjs';
-import { __spreadValues } from './chunk-R4SQKVDQ.mjs';
+import { cn } from './chunk-M5Y3VYMJ.mjs';
+import { __spreadValues } from './chunk-6F7H4PAA.mjs';
 import React8 from 'react';
 import { Grid, Col, BarChart, LineChart, AreaChart, DonutChart, Text } from '@tremor/react';
 import { Card } from '@nextui-org/react';

package/dist/plugins.d.mts

@@ -0,0 +1,118 @@
+import { S as Store } from './root-218afa4f.js';
+import React from 'react';
+import { SlotsToClasses, ModalSlots, ButtonProps, SpinnerProps } from '@nextui-org/react';
+import { T as ThemeType } from './index-38be834f.js';
+import * as react_hot_toast from 'react-hot-toast';
+import { P as PromiseState } from './PromiseState-e64b3707.js';
+import 'typed-emitter';
+import 'events';
+
+declare class ConfirmStore implements Store {
+    sid: string;
+    provider: () => React.JSX.Element;
+    isOpen: boolean;
+    title?: string;
+    description?: string;
+    size: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | 'full' | 'xs' | '3xl' | '4xl' | '5xl';
+    className: string;
+    classNames?: SlotsToClasses<ModalSlots>;
+    theme: ThemeType;
+    cancelBtnProps?: ButtonProps;
+    okBtnProps?: ButtonProps;
+    constructor();
+    toggleOpen(val: boolean): void;
+    onOk(): void;
+    onCancel(): void;
+    show(confirmProps: Partial<ConfirmStore>): void;
+    close(): void;
+}
+
+declare class ToastPlugin implements Store {
+    sid: string;
+    provider: () => React.JSX.Element;
+    success: (message: react_hot_toast.Renderable | react_hot_toast.ValueFunction<react_hot_toast.Renderable, react_hot_toast.Toast>, options?: react_hot_toast.ToastOptions) => string;
+    error: (message: react_hot_toast.Renderable | react_hot_toast.ValueFunction<react_hot_toast.Renderable, react_hot_toast.Toast>, options?: react_hot_toast.ToastOptions) => string;
+    loading: (message: react_hot_toast.Renderable | react_hot_toast.ValueFunction<react_hot_toast.Renderable, react_hot_toast.Toast>, options?: react_hot_toast.ToastOptions) => string;
+    custom: (message: react_hot_toast.Renderable | react_hot_toast.ValueFunction<react_hot_toast.Renderable, react_hot_toast.Toast>, options?: react_hot_toast.ToastOptions) => string;
+    dismiss: (toastId?: string, toasterId?: string) => void;
+    remove: (toastId?: string, toasterId?: string) => void;
+    promise: <T>(promise: Promise<T> | (() => Promise<T>), msgs: {
+        loading: react_hot_toast.Renderable;
+        success?: react_hot_toast.ValueOrFunction<react_hot_toast.Renderable, T>;
+        error?: react_hot_toast.ValueOrFunction<react_hot_toast.Renderable, any>;
+    }, opts?: react_hot_toast.DefaultToastOptions) => Promise<T>;
+}
+
+declare class DialogStore implements Store {
+    sid: string;
+    provider: () => React.JSX.Element;
+    isOpen: boolean;
+    placement: "center" | "auto" | "top" | "bottom" | "top-center" | "bottom-center";
+    title: string;
+    size: "sm" | "md" | "lg" | "xl" | "2xl" | "full" | "xs" | "3xl" | "4xl" | "5xl";
+    className: string;
+    classNames?: SlotsToClasses<ModalSlots>;
+    theme: ThemeType;
+    content: React.ReactNode | ((props: any) => React.ReactNode);
+    isDismissable: boolean;
+    constructor(args?: Partial<DialogStore>);
+    setData(v: Partial<DialogStore>): void;
+    close(): void;
+    static show(v: Partial<DialogStore>): void;
+    static close(): void;
+}
+
+type GroupOptions = {
+    args?: any[];
+    title: React.ReactNode;
+}[];
+type DialogContentUIProps = {
+    className?: string;
+    itemClassName?: string;
+    numberClassName?: string;
+    spinnerProps?: SpinnerProps;
+    SuccessIcon?: React.ReactNode;
+    FailureIcon?: React.ReactNode;
+};
+type StepUIProps = {
+    className?: string;
+    itemClassName?: string;
+    activatedItemClassName?: string;
+    numberClassName?: string;
+    activatedNumberClassName?: string;
+    spinnerProps?: SpinnerProps;
+    SuccessIcon?: React.ReactNode;
+    FailureIcon?: React.ReactNode;
+};
+
+declare class PromiseStateGroup {
+    group: PromiseState<any, any>[];
+    groupOptions: GroupOptions;
+    currentCallStepNo: number;
+    constructor({ group, groupOptions }: {
+        group: PromiseState<any, any>[];
+        groupOptions: GroupOptions;
+    });
+    call(): Promise<{
+        result: any[];
+        errMsg: string;
+    }>;
+    callWithDialog(dialogOptions?: Partial<DialogStore>, dialogContentOptions?: DialogContentUIProps, successMsg?: string, autoClose?: boolean): Promise<{
+        result: any[];
+        errMsg: string;
+    }>;
+    showDialog(dialogOptions?: Partial<DialogStore>, dialogContentOptions?: DialogContentUIProps): this;
+    closeDialog(): void;
+    stepCall(stepNo: number): Promise<{
+        result: any;
+        errMsg: string;
+    } | {
+        result: any;
+        errMsg: any;
+    }>;
+    onNext(): void;
+    onPrevious(): void;
+    render(props?: StepUIProps): React.JSX.Element;
+}
+
+export { ConfirmStore, DialogStore, PromiseStateGroup, ToastPlugin };

package/dist/plugins.mjs

@@ -1,12 +1,12 @@
-import { DialogStore } from './chunk-PZ3VSAOC.mjs';
-export { DialogStore } from './chunk-PZ3VSAOC.mjs';
+import { DialogStore } from './chunk-C5BPNLKH.mjs';
+export { DialogStore } from './chunk-C5BPNLKH.mjs';
 import { ToastPlugin } from './chunk-IMOLRP7I.mjs';
 export { ToastPlugin } from './chunk-IMOLRP7I.mjs';
 import { getStyle } from './chunk-GKAU4P5I.mjs';
-import { useStore, RootStore } from './chunk-XSGTWROT.mjs';
+import { useStore, RootStore } from './chunk-IDKGZ5T4.mjs';
 import './chunk-K7LFG5BA.mjs';
-import { cn } from './chunk-2HNXZE3X.mjs';
-import { __spreadProps, __spreadValues } from './chunk-R4SQKVDQ.mjs';
+import { cn } from './chunk-M5Y3VYMJ.mjs';
+import { __spreadProps, __spreadValues } from './chunk-6F7H4PAA.mjs';
 import { makeAutoObservable, makeObservable } from 'mobx';
 import React3 from 'react';
 import { observer } from 'mobx-react-lite';

package/dist/root-218afa4f.d.ts

@@ -0,0 +1,111 @@
+import TypedEmitter from 'typed-emitter';
+
+declare abstract class Store {
+    sid?: string;
+    stype?: string;
+    disabled?: boolean;
+    autoObservable?: boolean;
+    autoAsyncable?: boolean;
+    _active?: number;
+    stores?: Store[];
+    private pannel?;
+    devtools?: {
+        enable?: boolean;
+        started?: boolean;
+        panels: Store["pannel"][];
+    };
+    private slot?;
+    slots?: Record<string, Store["slot"]>;
+    events?: Record<string, {
+        name: string;
+        handler(args: {
+            e: MouseEvent;
+            v?: any;
+        }): any;
+    }>;
+    provider?({ rootStore }: {
+        rootStore: RootStore;
+    }): any;
+    onNewStore?({ rootStore, store }: {
+        rootStore: RootStore;
+        store: Store;
+    }): void;
+    onAddedStores?({ rootStore }: {
+        rootStore: RootStore;
+    }): void;
+    onAdded?({ rootStore }: {
+        rootStore: RootStore;
+    }): void;
+    init?(): void;
+    JSONView?: Record<string, {
+        name: string;
+        render: React.FC;
+    }>;
+    onKeyBindings?: () => {
+        key: string;
+        fn: () => void;
+    }[];
+    constructor();
+}
+type StoreClass<T extends Store> = new (...args: any[]) => T;
+interface BaseState {
+    value: number;
+    setValue(value: any): any;
+}
+declare class StringState<T extends string> {
+    value: T;
+    constructor(args?: Partial<StringState<T>>);
+    setValue(value: T): void;
+}
+declare class BooleanState {
+    value: boolean;
+    constructor(args?: Partial<BooleanState>);
+    setValue(value: boolean): void;
+}
+declare class NumberState {
+    value: number;
+    constructor(args?: Partial<NumberState>);
+    setValue(value: number): void;
+}
+declare class ValueState<T> {
+    _value: T;
+    constructor(args?: Partial<ValueState<T>>);
+    get value(): T;
+    set value(value: T);
+    getValue: (value: T) => T;
+    setValue(value: T): void;
+}
+
+type EventMap = {
+    "*": (args: any) => void;
+    add: (store: Store) => void;
+};
+declare class RootStore<T extends EventMap = any> {
+    instanceMap: Map<Function, Map<string, Store>>;
+    instance: Record<string, Store>;
+    providers: Store[];
+    events: TypedEmitter<T>;
+    isInited: boolean;
+    static init<T extends EventMap>(args?: Partial<RootStore<T>>): RootStore<T>;
+    add(store: Store, { sid }?: {
+        sid?: string;
+    }): void;
+    addStores(store: Store[]): this;
+    get<T extends Store>(store: StoreClass<T>, config?: {
+        sid?: string;
+        args?: Partial<T>;
+    }): T;
+    has(store: Function): boolean;
+    constructor(args?: Partial<RootStore<T>>);
+    crawlStore(obj: Object): void;
+    static Get<T extends Store>(store: StoreClass<T>, config?: {
+        sid?: string;
+        args?: Partial<T>;
+    }): T;
+    static Local<T>(func: () => T, config?: {
+        sid?: string;
+        args?: Partial<T>;
+    }, ann?: any): T;
+}
+
+export { BaseState as B, EventMap as E, NumberState as N, RootStore as R, Store as S, ValueState as V, StoreClass as a, StringState as b, BooleanState as c };

package/dist/ui.d.mts

@@ -0,0 +1,29 @@
+import React from 'react';
+import { SlotsToClasses } from '@nextui-org/react';
+
+declare const PanelCard: ({ className, title, content }: {
+    className?: string;
+    title: React.ReactNode;
+    content?: React.ReactNode;
+}) => React.JSX.Element;
+
+declare const Copy: ({ className, value, iconSize, iconClassName }: {
+    className?: string;
+    value: string;
+    iconSize?: number;
+    iconClassName?: string;
+}) => React.JSX.Element;
+
+declare function JSONHighlight({ jsonStr, className }: {
+    jsonStr: string;
+    className?: string;
+}): React.JSX.Element;
+
+declare const SkeletonBox: ({ line, className, skClassName, skClassNames }: {
+    line?: number;
+    className?: string;
+    skClassName?: string;
+    skClassNames?: SlotsToClasses<"base" | "content">;
+}) => React.JSX.Element;
+
+export { Copy, JSONHighlight, PanelCard, SkeletonBox };

package/dist/ui.mjs

@@ -1,6 +1,6 @@
-export { SkeletonBox } from './chunk-QA3E2PJT.mjs';
-import { cn } from './chunk-2HNXZE3X.mjs';
-import './chunk-R4SQKVDQ.mjs';
+export { SkeletonBox } from './chunk-FJHGIW3I.mjs';
+import { cn } from './chunk-M5Y3VYMJ.mjs';
+import './chunk-6F7H4PAA.mjs';
 import React, { useState, useEffect } from 'react';
 import { Card } from '@nextui-org/react';
 import copyToClipboard from 'copy-to-clipboard';