ith-ui-react-antd 0.1.1

package/README.md

@@ -0,0 +1,21 @@
+# ith-ui-react-antd
+
+ITH 新一代 React + Ant Design + TypeScript 业务组件库。
+
+## 当前组件（11 个对外 `Th*` 组件）
+
+- `ThDialog`：公司统一弹窗/抽屉、全屏和操作栏。
+- `ThEditor`、`ThEditorHtml`：富文本编辑与只读展示。
+- `ThSelectPage`：分页弹窗单选/多选。
+- `ThRegion`：异步地区级联。
+- `ThUploadFile`、`ThUploadImg`：附件与图片上传。
+- `ThUploadBig`：大文件 MD5、秒传、断点分片、进度与合并流程。
+- `ThDownload`：文件预览、水印与下载。
+- `ThSearchDescPlan`：更多条件与查询方案。
+- `ThColumnSelect`：列显示、顺序、宽度、冻结、导出和打印设置。
+
+内部仍复用职责明确的实现模块，但 npm 对外组件名和表单 JSON 统一使用原来的 `Th*` 名称。
+
+## 应用统一配置
+
+旧组件库使用可变的 `IthUI.config` 单例。React 版本改为 Provider：应用只传一次 Token、请求头、接口基址和默认端点，组件 Props 仍可覆盖全局设置。

package/dist/IthUiClient.d.ts

@@ -0,0 +1,20 @@
+import { LegacyAreaRequestOptions } from './components/AreaPickerAdapter';
+import { LegacyEntityRequestOptions } from './components/EntityPickerAdapter';
+import { LegacyRichTextUploadOptions } from './components/RichTextUploadAdapter';
+import { EntityRecord } from './components/EntityPicker';
+export declare function useIthUiClient(): {
+    config: import('./IthUiProvider').IthUiConfig;
+    createAreaRequest: (options?: LegacyAreaRequestOptions) => (parentValue: import('.').AreaValue | null, context: import('.').AreaLoadContext) => Promise<import('.').AreaOption[]>;
+    createEntityRequest: <T extends EntityRecord>(options: LegacyEntityRequestOptions<T>) => ({ keyword, page, pageSize, query, filters, signal }: import('.').EntityPickerRequestParams) => Promise<import('.').EntityPickerRequestResult<T>>;
+    createUploadAdapter: (options?: {
+        url?: string;
+        headers?: HeadersInit;
+    }) => (file: File, signal: AbortSignal, data: Record<string, unknown>) => Promise<import('.').LegacyUploadResponse>;
+    createMultipartUploadAdapter: () => import('.').MultipartUploadAdapter;
+    createRichTextUploadAdapters: (options?: LegacyRichTextUploadOptions) => {
+        uploadImage: (file: File, signal: AbortSignal) => Promise<import('.').RichTextUploadResult>;
+        uploadVideo: (file: File, signal: AbortSignal) => Promise<import('.').RichTextUploadResult>;
+        uploadAttachment: (file: File, signal: AbortSignal) => Promise<import('.').RichTextUploadResult>;
+    };
+    createPreviewHandler: () => (file: import('.').UploadedAsset) => void;
+};

package/dist/IthUiProvider.d.ts

@@ -0,0 +1,51 @@
+import { ReactNode } from 'react';
+export type IthTokenResolver = string | null | undefined | (() => string | null | undefined | Promise<string | null | undefined>);
+export type IthHeadersResolver = HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+export interface IthUiEndpoints {
+    area?: string;
+    upload?: string;
+    nodeUpload?: string;
+    multipartDirect?: string;
+    multipartVerify?: string;
+    multipartChunk?: string;
+    multipartMerge?: string;
+    richTextUpload?: string;
+}
+export interface IthUiPreviewConfig {
+    enabled?: boolean;
+    onlinePreview?: string;
+    previewWay?: boolean;
+    target?: '_blank' | '_self';
+}
+export interface IthUiUploadRule {
+    accept?: string;
+    maxSizeMB?: number;
+    limit?: number;
+}
+export interface IthUiConfig {
+    baseUrl?: string;
+    token?: IthTokenResolver;
+    tokenHeader?: string;
+    headers?: IthHeadersResolver;
+    credentials?: RequestCredentials;
+    fetcher?: typeof fetch;
+    endpoints?: IthUiEndpoints;
+    preview?: IthUiPreviewConfig;
+    upload?: {
+        file?: IthUiUploadRule;
+        image?: IthUiUploadRule;
+        multipart?: IthUiUploadRule & {
+            useChunkMB?: number;
+        };
+    };
+    locale?: string;
+}
+export interface IthUiProviderProps {
+    config: IthUiConfig;
+    children: ReactNode;
+}
+export declare function IthUiProvider({ config, children }: IthUiProviderProps): import("react").JSX.Element;
+export declare function useIthUiConfig(): IthUiConfig;
+export declare function resolveIthToken(config: IthUiConfig): Promise<string | null | undefined>;
+export declare function resolveIthHeaders(config: IthUiConfig): Promise<Headers>;
+export declare function resolveIthUrl(config: IthUiConfig, path: string): string;

package/dist/ThComponents.d.ts

@@ -0,0 +1,31 @@
+import { AreaPickerProps } from './components/AreaPicker';
+import { BusinessDialogProps } from './components/BusinessDialog';
+import { BusinessUploadProps } from './components/BusinessUpload';
+import { ColumnSettingsProps } from './components/ColumnSettings';
+import { EntityPickerProps, EntityRecord } from './components/EntityPicker';
+import { FilePreviewProps } from './components/FilePreview';
+import { MultipartUploadProps } from './components/MultipartUpload';
+import { RichTextEditorProps } from './components/RichTextEditor';
+import { SearchSchemeProps } from './components/SearchScheme';
+export type ThRegionProps = AreaPickerProps;
+export declare function ThRegion({ requestChildren, ...props }: ThRegionProps): import("react").JSX.Element;
+export type ThDialogProps = BusinessDialogProps;
+export declare function ThDialog(props: ThDialogProps): import("react").JSX.Element;
+export type ThUploadFileProps = Omit<BusinessUploadProps, 'variant'>;
+export declare function ThUploadFile({ mode, ...props }: ThUploadFileProps): import("react").JSX.Element;
+export type ThUploadImgProps = Omit<BusinessUploadProps, 'variant'>;
+export declare function ThUploadImg({ mode, ...props }: ThUploadImgProps): import("react").JSX.Element;
+export type ThUploadBigProps = MultipartUploadProps;
+export declare function ThUploadBig(props: ThUploadBigProps): import("react").JSX.Element;
+export type ThSelectPageProps<T extends EntityRecord> = EntityPickerProps<T>;
+export declare function ThSelectPage<T extends EntityRecord>(props: ThSelectPageProps<T>): import("react").JSX.Element;
+export type ThEditorProps = RichTextEditorProps;
+export declare function ThEditor(props: ThEditorProps): import("react").JSX.Element;
+export type ThEditorHtmlProps = Omit<RichTextEditorProps, 'readOnly'>;
+export declare function ThEditorHtml(props: ThEditorHtmlProps): import("react").JSX.Element;
+export type ThSearchDescPlanProps = SearchSchemeProps;
+export declare function ThSearchDescPlan(props: ThSearchDescPlanProps): import("react").JSX.Element;
+export type ThColumnSelectProps<RecordType extends Record<string, unknown> = Record<string, unknown>> = ColumnSettingsProps<RecordType>;
+export declare function ThColumnSelect<RecordType extends Record<string, unknown> = Record<string, unknown>>(props: ThColumnSelectProps<RecordType>): import("react").JSX.Element;
+export type ThDownloadProps = FilePreviewProps;
+export declare function ThDownload(props: ThDownloadProps): import("react").JSX.Element;

package/dist/componentManifest.d.ts

@@ -0,0 +1,29 @@
+export type IthComponentCategory = 'data-entry' | 'data-display' | 'feedback' | 'navigation' | 'advanced';
+export type IthValueType = 'string' | 'string[]' | 'object' | 'object[]' | 'html' | 'void';
+export type IthPropertyEditor = 'input' | 'number' | 'switch' | 'select' | 'tags' | 'json' | 'code' | 'endpoint';
+export interface IthPropertyOption {
+    label: string;
+    value: string | number | boolean;
+}
+export interface IthComponentProperty {
+    key: string;
+    label: string;
+    editor: IthPropertyEditor;
+    group?: 'basic' | 'data' | 'behavior' | 'appearance' | 'permission';
+    defaultValue?: unknown;
+    options?: IthPropertyOption[];
+    description?: string;
+}
+export interface IthComponentManifestItem {
+    key: string;
+    title: string;
+    category: IthComponentCategory;
+    valueType: IthValueType;
+    legacy: string[];
+    dataSource: 'none' | 'options' | 'endpoint' | 'adapter';
+    events: string[];
+    properties: IthComponentProperty[];
+}
+/** 表单设计器可直接消费的、无 React 节点和函数的组件定义。 */
+export declare const componentManifest: IthComponentManifestItem[];
+export declare const componentManifestMap: Record<string, IthComponentManifestItem>;

package/dist/components/AreaPicker.d.ts

@@ -0,0 +1,44 @@
+import { CSSProperties } from 'react';
+export type AreaValue = string | number;
+export interface AreaOption {
+    value: AreaValue;
+    label: string;
+    disabled?: boolean;
+    isLeaf?: boolean;
+    searchText?: string;
+    raw?: unknown;
+}
+export interface AreaLoadContext {
+    level: number;
+    path: AreaOption[];
+    signal: AbortSignal;
+}
+export interface AreaChangeInfo {
+    valueArr: AreaValue[];
+    textArr: string[];
+    options: AreaOption[];
+}
+export interface AreaPickerProps {
+    value?: AreaValue[];
+    defaultValue?: AreaValue[];
+    onChange?: (value: AreaValue[], info: AreaChangeInfo) => void;
+    requestChildren?: (parentValue: AreaValue | null, context: AreaLoadContext) => Promise<AreaOption[]>;
+    /** 兼容早期 React 版本；根节点仍通过 options 提供。 */
+    options?: AreaOption[];
+    loadChildren?: (parentValue: AreaValue) => Promise<AreaOption[]>;
+    placeholder?: string;
+    tabTitle?: string;
+    joinChart?: string;
+    disabled?: boolean;
+    allowClear?: boolean;
+    anyLevel?: boolean;
+    level?: number;
+    textModel?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    size?: 'small' | 'middle' | 'large';
+    panelWidth?: number;
+    searchable?: boolean;
+    levelNames?: string[];
+}
+export declare function AreaPicker({ value, defaultValue, onChange, requestChildren, options, loadChildren, placeholder, tabTitle, joinChart, disabled, allowClear, anyLevel, level, textModel, className, style, size, panelWidth, searchable, levelNames, }: AreaPickerProps): import("react").JSX.Element | null;

package/dist/components/AreaPickerAdapter.d.ts

@@ -0,0 +1,16 @@
+import { AreaLoadContext, AreaOption, AreaValue } from './AreaPicker';
+export interface LegacyAreaRecord {
+    id: AreaValue;
+    name: string;
+    disabled?: boolean;
+    isLeaf?: boolean;
+    [key: string]: unknown;
+}
+export interface LegacyAreaRequestOptions {
+    url?: string;
+    getToken?: () => string | null | undefined | Promise<string | null | undefined>;
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+    fetcher?: typeof fetch;
+}
+/** 将旧版 /sys/area?pId= 接口转换为 AreaPicker 的逐层数据源。 */
+export declare function createLegacyAreaRequest({ url, getToken, headers, fetcher, }?: LegacyAreaRequestOptions): (parentValue: AreaValue | null, context: AreaLoadContext) => Promise<AreaOption[]>;

package/dist/components/BusinessDialog.d.ts

@@ -0,0 +1,25 @@
+import { ReactNode } from 'react';
+export type BusinessDialogMode = 'dialog' | 'drawer';
+export interface BusinessDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title?: ReactNode;
+    children?: ReactNode;
+    mode?: BusinessDialogMode;
+    onModeChange?: (mode: BusinessDialogMode) => void;
+    size?: number | string;
+    fullscreen?: boolean;
+    showClose?: boolean;
+    showFooter?: boolean;
+    closeText?: ReactNode;
+    footer?: ReactNode;
+    footerLeading?: ReactNode;
+    headerExtra?: ReactNode;
+    mask?: boolean;
+    maskClosable?: boolean;
+    keyboard?: boolean;
+    destroyOnHidden?: boolean;
+    bodyClassName?: string;
+    className?: string;
+}
+export declare function BusinessDialog({ open, onOpenChange, title, children, mode, onModeChange, size, fullscreen, showClose, showFooter, closeText, footer, footerLeading, headerExtra, mask, maskClosable, keyboard, destroyOnHidden, bodyClassName, className, }: BusinessDialogProps): import("react").JSX.Element;

package/dist/components/BusinessUpload.d.ts

@@ -0,0 +1,56 @@
+import { UploadFile, UploadProps } from 'antd';
+import { ReactNode } from 'react';
+export type UploadStatusValue = -1 | 0 | 1 | 2;
+export interface UploadedAsset {
+    [key: string]: unknown;
+    type?: 'file';
+    id: string;
+    uid?: string;
+    name: string;
+    url: string;
+    status?: 'success';
+    size?: number;
+    mimeType?: string;
+    response?: unknown;
+}
+export interface LegacyUploadResponse {
+    code: number;
+    msg?: string;
+    ext?: {
+        fileId?: string;
+        fileName?: string;
+        url?: string;
+    };
+    [key: string]: unknown;
+}
+export interface UploadModuleConfig {
+    fileType?: string;
+    fileNumber?: number;
+    fileSize?: number;
+    nodeFileId?: string;
+    remark?: ReactNode;
+}
+export interface BusinessUploadProps extends Omit<UploadProps, 'accept' | 'beforeUpload' | 'customRequest' | 'fileList' | 'maxCount' | 'onChange' | 'onPreview' | 'onRemove'> {
+    variant?: 'file' | 'image';
+    mode?: 'button' | 'drag' | 'picture-card';
+    value?: UploadedAsset[];
+    defaultValue?: UploadedAsset[];
+    onValueChange?: (files: UploadedAsset[]) => void;
+    upload?: (file: File, signal: AbortSignal, data: Record<string, unknown>) => Promise<UploadedAsset | LegacyUploadResponse>;
+    uploadData?: Record<string, unknown>;
+    accept?: string;
+    limit?: number;
+    maxSizeMB?: number;
+    moduleConfig?: UploadModuleConfig;
+    showTip?: boolean;
+    enableSingleMode?: boolean;
+    previewEnabled?: boolean;
+    onPreviewAsset?: (file: UploadedAsset) => void;
+    onlinePreview?: string;
+    previewWay?: boolean;
+    onUploadStatusChange?: (status: UploadStatusValue) => void;
+    onUploadError?: (error: unknown) => void;
+    rawResponse?: boolean;
+    onResponse?: (files: UploadFile[]) => void;
+}
+export declare function BusinessUpload({ variant, mode, value, defaultValue, onValueChange, upload, uploadData, accept, limit, maxSizeMB, moduleConfig, showTip, enableSingleMode, previewEnabled, onPreviewAsset, onlinePreview, previewWay, onUploadStatusChange, onUploadError, rawResponse, onResponse, multiple, disabled, children, ...props }: BusinessUploadProps): import("react").JSX.Element;

package/dist/components/BusinessUploadAdapter.d.ts

@@ -0,0 +1,21 @@
+import { LegacyUploadResponse, UploadedAsset } from './BusinessUpload';
+import { MultipartUploadAdapter } from './MultipartUpload';
+export interface LegacyUploadAdapterOptions {
+    url?: string;
+    getToken?: () => string | null | undefined | Promise<string | null | undefined>;
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+}
+export declare function createLegacyUploadAdapter(options?: LegacyUploadAdapterOptions): (file: File, signal: AbortSignal, data: Record<string, unknown>) => Promise<LegacyUploadResponse>;
+export interface LegacyPreviewOptions {
+    onlinePreview: string;
+    previewWay?: boolean;
+}
+export declare function createLegacyPreviewHandler({ onlinePreview, previewWay }: LegacyPreviewOptions): (file: UploadedAsset) => void;
+interface LegacyMultipartOptions extends LegacyUploadAdapterOptions {
+    directUrl?: string;
+    verifyUrl?: string;
+    chunkUrl?: string;
+    mergeUrl?: string;
+}
+export declare function createLegacyMultipartUploadAdapter(options?: LegacyMultipartOptions): MultipartUploadAdapter;
+export {};

package/dist/components/ColumnSettings.d.ts

@@ -0,0 +1,33 @@
+export type ColumnFixed = 'left' | 'right' | false;
+export interface ManagedColumn<RecordType extends Record<string, unknown> = Record<string, unknown>> {
+    key: string;
+    title: string;
+    dataIndex?: string;
+    visible?: boolean;
+    width?: number;
+    fixed?: ColumnFixed;
+    required?: boolean;
+    excludeFromExport?: boolean;
+    renderExport?: (value: unknown, row: RecordType) => unknown;
+}
+export interface ColumnSettingsPersistence<RecordType extends Record<string, unknown> = Record<string, unknown>> {
+    load: (key: string) => Promise<ManagedColumn<RecordType>[] | null> | ManagedColumn<RecordType>[] | null;
+    save: (key: string, columns: ManagedColumn<RecordType>[]) => Promise<void> | void;
+    reset: (key: string) => Promise<void> | void;
+}
+export interface ColumnSettingsProps<RecordType extends Record<string, unknown> = Record<string, unknown>> {
+    columns: ManagedColumn<RecordType>[];
+    onChange: (columns: ManagedColumn<RecordType>[]) => void;
+    currentData?: RecordType[];
+    selectedData?: RecordType[];
+    loadAll?: (limit: number) => Promise<RecordType[]>;
+    cacheKey?: string;
+    persistence?: ColumnSettingsPersistence<RecordType>;
+    enableWidth?: boolean;
+    maxExportRows?: number;
+    fileName?: string;
+    compact?: boolean;
+    onExport?: (rows: RecordType[], columns: ManagedColumn<RecordType>[], fileName: string) => Promise<void> | void;
+    onPrint?: (rows: RecordType[], columns: ManagedColumn<RecordType>[]) => Promise<void> | void;
+}
+export declare function ColumnSettings<RecordType extends Record<string, unknown> = Record<string, unknown>>({ columns, onChange, currentData, selectedData, loadAll, cacheKey, persistence, enableWidth, maxExportRows, fileName, compact, onExport, onPrint }: ColumnSettingsProps<RecordType>): import("react").JSX.Element;

package/dist/components/EntityPicker.d.ts

@@ -0,0 +1,61 @@
+import { ColumnsType } from 'antd/es/table/interface';
+import { Key, ReactNode } from 'react';
+export type EntityRecord = Record<string, unknown>;
+export type EntityQuery = Record<string, unknown>;
+export interface EntityPickerRequestParams {
+    keyword: string;
+    page: number;
+    pageSize: number;
+    query: EntityQuery;
+    filters: EntityQuery;
+    signal: AbortSignal;
+}
+export interface EntityPickerRequestResult<T extends EntityRecord> {
+    rows: T[];
+    total: number;
+}
+export interface EntityFilterRenderContext {
+    query: EntityQuery;
+    setQuery: (next: EntityQuery | ((current: EntityQuery) => EntityQuery)) => void;
+    search: () => void;
+    reset: () => void;
+}
+export interface EntitySelectDialogProps<T extends EntityRecord> {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    value?: T[];
+    onConfirm?: (value: T[]) => void;
+    request: (params: EntityPickerRequestParams) => Promise<EntityPickerRequestResult<T>>;
+    columns: ColumnsType<T>;
+    rowKey: keyof T | ((record: T) => Key);
+    multiple?: boolean;
+    title?: ReactNode;
+    size?: number | string;
+    filters?: EntityQuery;
+    defaultQuery?: EntityQuery;
+    showFilterHeader?: boolean;
+    showSearchMore?: boolean;
+    renderLeft?: (context: EntityFilterRenderContext) => ReactNode;
+    renderFilters?: (context: EntityFilterRenderContext) => ReactNode;
+    renderMoreFilters?: (context: EntityFilterRenderContext) => ReactNode;
+    disabledKeys?: Key[];
+    isRowDisabled?: (record: T) => boolean;
+    decorateData?: (rows: T[]) => T[];
+    immediateSingleSelect?: boolean;
+    autoClose?: boolean;
+    confirmLoading?: boolean;
+    onReset?: () => void;
+    pageSizeOptions?: number[];
+    tableScrollY?: number | string;
+}
+export declare function EntitySelectDialog<T extends EntityRecord>({ open, onOpenChange, value, onConfirm, request, columns, rowKey, multiple, title, size, filters, defaultQuery, showFilterHeader, showSearchMore, renderLeft, renderFilters, renderMoreFilters, disabledKeys, isRowDisabled, decorateData, immediateSingleSelect, autoClose, confirmLoading, onReset, pageSizeOptions, tableScrollY, }: EntitySelectDialogProps<T>): import("react").JSX.Element;
+export interface EntityPickerProps<T extends EntityRecord> extends Omit<EntitySelectDialogProps<T>, 'open' | 'onOpenChange' | 'onConfirm'> {
+    value?: T[];
+    onChange?: (value: T[]) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    allowClear?: boolean;
+    displayField?: keyof T | ((record: T) => ReactNode);
+    onOpenChange?: (open: boolean) => void;
+}
+export declare function EntityPicker<T extends EntityRecord>({ value, onChange, placeholder, disabled, allowClear, displayField, onOpenChange, ...dialogProps }: EntityPickerProps<T>): import("react").JSX.Element;

package/dist/components/EntityPickerAdapter.d.ts

@@ -0,0 +1,11 @@
+import { EntityPickerRequestParams, EntityPickerRequestResult, EntityRecord } from './EntityPicker';
+export interface LegacyEntityRequestOptions<T extends EntityRecord> {
+    url: string;
+    method?: 'get' | 'post';
+    getToken?: () => string | null | undefined | Promise<string | null | undefined>;
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+    fetcher?: typeof fetch;
+    decorateData?: (rows: T[]) => T[];
+}
+/** 适配旧 ThSelectPage 的 offset/limit、GET/POST 及 rows/ext 返回结构。 */
+export declare function createLegacyEntityRequest<T extends EntityRecord>({ url, method, getToken, headers, fetcher, decorateData, }: LegacyEntityRequestOptions<T>): ({ keyword, page, pageSize, query, filters, signal }: EntityPickerRequestParams) => Promise<EntityPickerRequestResult<T>>;

package/dist/components/FilePreview.d.ts

@@ -0,0 +1,43 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface PreviewFile {
+    id?: string | number;
+    url: string;
+    name: string;
+    mimeType?: string;
+    previewUrl?: string;
+    [key: string]: unknown;
+}
+export interface FileWatermark {
+    text: string;
+    angle?: number;
+    color?: string;
+    opacity?: number;
+}
+export interface FileActionContext {
+    file: PreviewFile;
+    files: PreviewFile[];
+    watermark?: FileWatermark;
+    params?: Record<string, unknown>;
+}
+export interface FilePreviewProps {
+    file: PreviewFile;
+    files?: PreviewFile[];
+    width?: number | string;
+    style?: CSSProperties;
+    className?: string;
+    preview?: boolean;
+    download?: boolean;
+    watermark?: FileWatermark;
+    previewTarget?: 'overlay' | 'blank';
+    resolvePreviewUrl?: (context: FileActionContext) => string | Promise<string>;
+    beforePreview?: (context: FileActionContext) => boolean | void | Promise<boolean | void>;
+    beforeDownload?: (context: FileActionContext) => boolean | void | Promise<boolean | void>;
+    downloadFile?: (context: FileActionContext, signal: AbortSignal) => Promise<Blob | void>;
+    downloadParams?: Record<string, unknown>;
+    onPreview?: (context: FileActionContext) => void;
+    onDownload?: (context: FileActionContext) => void;
+    onSuccess?: (context: FileActionContext) => void;
+    onError?: (error: Error, context: FileActionContext) => void;
+    extra?: ReactNode;
+}
+export declare function FilePreview({ file, files, width, style, className, preview, download, watermark, previewTarget, resolvePreviewUrl, beforePreview, beforeDownload, downloadFile, downloadParams, onPreview, onDownload, onSuccess, onError, extra, }: FilePreviewProps): import("react").JSX.Element;

package/dist/components/MultipartUpload.d.ts

@@ -0,0 +1,43 @@
+import { UploadedAsset } from './BusinessUpload';
+export interface MultipartVerifyResult {
+    shouldUpload: boolean;
+    uploadedList?: string[];
+    url?: string;
+    fileId?: string;
+}
+export interface MultipartChunkParams {
+    chunk: Blob;
+    hash: string;
+    index: number;
+    fileHash: string;
+    filename: string;
+    signal: AbortSignal;
+    onProgress: (loaded: number, total: number) => void;
+}
+export interface MultipartUploadAdapter {
+    directUpload: (file: File, signal: AbortSignal, onProgress: (loaded: number, total: number) => void) => Promise<UploadedAsset>;
+    verifyUpload: (filename: string, fileHash: string, signal: AbortSignal) => Promise<MultipartVerifyResult>;
+    uploadChunk: (params: MultipartChunkParams) => Promise<void>;
+    mergeChunks: (params: {
+        size: number;
+        fileHash: string;
+        filename: string;
+        signal: AbortSignal;
+    }) => Promise<UploadedAsset>;
+}
+export interface MultipartUploadProps {
+    value?: UploadedAsset[];
+    defaultValue?: UploadedAsset[];
+    onValueChange?: (files: UploadedAsset[]) => void;
+    adapter: MultipartUploadAdapter;
+    accept?: string;
+    limit?: number;
+    maxSizeMB?: number;
+    useChunkMB?: number;
+    disabled?: boolean;
+    previewEnabled?: boolean;
+    onPreviewAsset?: (file: UploadedAsset) => void;
+    onlinePreview?: string;
+    previewWay?: boolean;
+}
+export declare function MultipartUpload({ value, defaultValue, onValueChange, adapter, accept, limit, maxSizeMB, useChunkMB, disabled, previewEnabled, onPreviewAsset, onlinePreview, previewWay, }: MultipartUploadProps): import("react").JSX.Element;

package/dist/components/RichTextEditor.d.ts

@@ -0,0 +1,35 @@
+import { Editor } from '@tiptap/core';
+export interface RichTextUploadResult {
+    url: string;
+    name?: string;
+    alt?: string;
+    title?: string;
+}
+export type RichTextToolbarKey = 'heading' | 'fontFamily' | 'fontSize' | 'bold' | 'italic' | 'underline' | 'strike' | 'textColor' | 'highlight' | 'align' | 'bulletList' | 'orderedList' | 'taskList' | 'blockquote' | 'code' | 'horizontalRule' | 'link' | 'table' | 'image' | 'video' | 'attachment' | 'clear' | 'undo' | 'redo' | 'fullscreen';
+export interface RichTextEditorProps {
+    value?: string;
+    onChange?: (html: string) => void;
+    onFocus?: () => void;
+    onBlur?: () => void;
+    onReady?: (editor: Editor) => void;
+    onUploadStatusChange?: (status: 'idle' | 'uploading' | 'success' | 'error', file?: File) => void;
+    placeholder?: string;
+    minHeight?: number;
+    maxHeight?: number;
+    disabled?: boolean;
+    readOnly?: boolean;
+    autoFocus?: boolean;
+    maxLength?: number;
+    showWordCount?: boolean;
+    toolbarItems?: RichTextToolbarKey[];
+    excludeToolbarItems?: RichTextToolbarKey[];
+    uploadImage?: (file: File, signal: AbortSignal) => Promise<RichTextUploadResult>;
+    uploadVideo?: (file: File, signal: AbortSignal) => Promise<RichTextUploadResult>;
+    uploadAttachment?: (file: File, signal: AbortSignal) => Promise<RichTextUploadResult>;
+    allowedImageTypes?: string[];
+    allowedVideoTypes?: string[];
+    maxImageSizeMB?: number;
+    maxVideoSizeMB?: number;
+    maxAttachmentSizeMB?: number;
+}
+export declare function RichTextEditor({ value, onChange, onFocus, onBlur, onReady, onUploadStatusChange, placeholder, minHeight, maxHeight, disabled, readOnly, autoFocus, maxLength, showWordCount, toolbarItems, excludeToolbarItems, uploadImage, uploadVideo, uploadAttachment, allowedImageTypes, allowedVideoTypes, maxImageSizeMB, maxVideoSizeMB, maxAttachmentSizeMB, }: RichTextEditorProps): import("react").JSX.Element;

package/dist/components/RichTextUploadAdapter.d.ts

@@ -0,0 +1,35 @@
+import { RichTextUploadResult } from './RichTextEditor';
+export type RichTextUploadType = 'IMAGE' | 'VIDEO' | 'FILE';
+export interface LegacyRichTextUploadResponse {
+    code?: number | string;
+    msg?: string;
+    message?: string;
+    ext?: {
+        url?: string;
+        fileName?: string;
+        name?: string;
+        title?: string;
+    };
+    data?: {
+        url?: string;
+        fileName?: string;
+        name?: string;
+        title?: string;
+    };
+}
+export interface LegacyRichTextUploadOptions {
+    url?: string;
+    fieldName?: string;
+    tokenHeader?: string;
+    getToken?: () => string | null | undefined | Promise<string | null | undefined>;
+    actionData?: Record<string, unknown>;
+    credentials?: RequestCredentials;
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+    fetcher?: typeof fetch;
+}
+export declare function createLegacyRichTextUploadAdapter(type: RichTextUploadType, options?: LegacyRichTextUploadOptions): (file: File, signal: AbortSignal) => Promise<RichTextUploadResult>;
+export declare function createLegacyRichTextUploadAdapters(options?: LegacyRichTextUploadOptions): {
+    uploadImage: (file: File, signal: AbortSignal) => Promise<RichTextUploadResult>;
+    uploadVideo: (file: File, signal: AbortSignal) => Promise<RichTextUploadResult>;
+    uploadAttachment: (file: File, signal: AbortSignal) => Promise<RichTextUploadResult>;
+};

package/dist/components/SearchScheme.d.ts

@@ -0,0 +1,49 @@
+import { ReactNode } from 'react';
+export type SearchRelation = 'and' | 'or';
+export type SearchFieldType = 'input' | 'select' | 'multiSelect' | 'date' | 'dateRange';
+export type SearchValue = unknown;
+export interface SearchOption {
+    label: string;
+    value: string | number;
+}
+export interface SearchTerm {
+    fieldJava: string;
+    fieldLabel: string;
+    component?: SearchFieldType;
+    placeholder?: string;
+    options?: SearchOption[];
+    defaultValue?: SearchValue;
+    bitVague?: 0 | 1;
+}
+export interface SearchCondition {
+    id: string;
+    fieldJava: string;
+    conditionValue: string;
+    fieldValue: SearchValue;
+}
+export interface SearchSchemeValue {
+    schemeId: string;
+    schemeName: string;
+    relation: SearchRelation;
+    where: SearchCondition[];
+}
+export interface SearchPayload {
+    queryBizCode: string;
+    threlation: SearchRelation;
+    wrappers: Record<string, {
+        conditionValue: string;
+        fieldValue: unknown;
+    }>;
+}
+export interface SearchSchemeProps {
+    terms: SearchTerm[];
+    queryBizCode: string;
+    mode?: 'more' | 'scheme';
+    schemes?: SearchSchemeValue[];
+    defaultExpanded?: boolean;
+    onSearch?: (payload: SearchPayload) => void;
+    onSaveScheme?: (scheme: SearchSchemeValue) => void;
+    onDeleteScheme?: (schemeId: string) => void;
+    renderField?: (term: SearchTerm, value: SearchValue, onChange: (value: SearchValue) => void) => ReactNode;
+}
+export declare function SearchScheme({ terms, queryBizCode, mode, schemes, defaultExpanded, onSearch, onSaveScheme, onDeleteScheme, renderField, }: SearchSchemeProps): import("react").JSX.Element;

package/dist/components/Title.d.ts

@@ -0,0 +1,7 @@
+import { HTMLAttributes, ReactNode } from 'react';
+export interface ThTitleProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    text?: ReactNode;
+    children?: ReactNode;
+    variant?: 'line' | 'soft' | 'badge' | 'solid' | 'outline' | 'corner' | 'pill' | 'ribbon' | 'marker' | 'split' | 'centered' | 'tab' | 'accent' | 'rail' | 'chapter';
+}
+export declare function ThTitle({ text, children, variant, className, ...rest }: ThTitleProps): import("react").JSX.Element;