@nocobase/client-v2 2.1.0-alpha.4 → 2.1.0-alpha.40

package/es/components/form/PasswordInput.d.ts

@@ -0,0 +1,40 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type { PasswordProps as AntdPasswordProps } from 'antd/es/input';
+import React from 'react';
+export interface PasswordInputProps extends AntdPasswordProps {
+    /**
+     * Render a visual strength bar beneath the input. Defaults to `false`. The
+     * score is computed locally — opting in does NOT add any form validation;
+     * use a separate `Form.Item.rules` entry for that (or wire the entry up to
+     * a cross-plugin password-validator extension point if your project
+     * provides one).
+     */
+    checkStrength?: boolean;
+}
+/**
+ * `Input.Password` plus an optional strength meter, ported from the v1
+ * `Password` component. The strength scoring and bar UI are identical to v1,
+ * so users who switch from a v1 page to a v2 page see the same visual signal.
+ *
+ * The component is value-shape compatible with antd `Input.Password` — drop
+ * it into any existing `Form.Item<password>` and toggle the meter with
+ * `checkStrength`.
+ *
+ * Caveats:
+ *
+ * - Strength scoring is purely a UX hint, not validation. Submitting a weak
+ *   password is still allowed unless the server (or a separately installed
+ *   password-policy plugin) rejects it.
+ * - The meter swallows the gap between `<Input.Password>` and the next form
+ *   element. If your `Form.Item` already adds vertical rhythm, the meter
+ *   inherits it; no extra spacing is added.
+ */
+export declare function PasswordInput(props: PasswordInputProps): React.JSX.Element;
+export default PasswordInput;

package/es/components/form/RemoteSelect.d.ts

@@ -0,0 +1,79 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { type SelectProps } from 'antd';
+import React from 'react';
+export interface RemoteSelectFieldNames {
+    label?: string;
+    value?: string;
+}
+export interface RemoteSelectProps<RawItem = any, Resp = RawItem[], V = any> extends Omit<SelectProps<V>, 'options' | 'loading'> {
+    /**
+     * Fetch the option source. Receives no arguments; caller closes over the
+     * `ctx.api.resource(...)` (or any other source) it needs. May resolve
+     * with either an array of raw items (the common case) or an arbitrary
+     * envelope object — in the latter case, supply `selectItems` to pluck
+     * the array out.
+     */
+    request: () => Promise<Resp | undefined>;
+    /**
+     * When `request` returns an envelope (object with metadata around the
+     * list), use this to extract the array of items that drives the
+     * dropdown. Defaults to identity, i.e. `request` itself returns the
+     * array.
+     */
+    selectItems?: (response: Resp) => RawItem[] | undefined;
+    /**
+     * Names of the raw item properties that hold the display label and the
+     * persisted value. Defaults to `{ label: 'label', value: 'value' }`.
+     * Ignored when `mapOptions` is supplied.
+     */
+    fieldNames?: RemoteSelectFieldNames;
+    /**
+     * Full custom mapping from a raw item to an antd `OptionType`. When
+     * provided, overrides `fieldNames`.
+     */
+    mapOptions?: (item: RawItem, index: number) => {
+        label: React.ReactNode;
+        value: any;
+    };
+    /**
+     * Stable cache key for ahooks `useRequest` so the dropdown doesn't re-fetch
+     * on every re-mount. Pass a value tied to the request's effective inputs.
+     */
+    cacheKey?: string;
+    /**
+     * Re-run the request when any of these values changes. Forwarded to
+     * `useRequest`'s `refreshDeps`.
+     */
+    refreshDeps?: unknown[];
+    /**
+     * Skip the auto-fetch on mount when `false`. Defaults to `true`.
+     */
+    ready?: boolean;
+    /**
+     * Notified once the request resolves. Receives both the mapped item
+     * array and the raw response envelope — useful when callers need to
+     * read sibling metadata (counts, availability hints, etc.) without
+     * issuing a second request.
+     */
+    onLoaded?: (items: RawItem[], response: Resp) => void;
+}
+/**
+ * Generic settings-page Select bound to an async option source. The
+ * component itself stays framework-agnostic — it knows nothing about
+ * NocoBase resources, data sources, or Formily. Pass any async `request`
+ * that resolves with an array, and supply `fieldNames` (or `mapOptions`)
+ * to map raw items to antd option shape.
+ *
+ * Search is local-only (antd's default `optionFilterProp="label"`). For
+ * server-side search, drive `request` from external state and pass the
+ * search input via `refreshDeps`.
+ */
+export declare function RemoteSelect<RawItem = any, Resp = RawItem[], V = any>(props: RemoteSelectProps<RawItem, Resp, V>): React.JSX.Element;
+export default RemoteSelect;

package/es/components/form/VariableInput.d.ts

@@ -0,0 +1,73 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { type MetaTreeNode, type VariableHybridInputConverters } from '@nocobase/flow-engine';
+import React from 'react';
+export declare function parseVariablePath(value?: string): string[] | undefined;
+export declare function formatVariablePath(meta?: MetaTreeNode): string | undefined;
+/**
+ * Resolve the meta tree the variable picker should expose. Filters the global
+ * meta tree by `namespaces` (top-level property names like `'$env'`,
+ * `'$user'`), appends `extraNodes`, and eagerly resolves any lazy `children`
+ * thunks so labels render on first paint.
+ *
+ * Returns `[]` while loading or when no nodes survive the filter, mirroring
+ * the existing EnvVariableInput behavior so the picker still opens but offers
+ * nothing.
+ */
+export declare function useFilteredMetaTree(options: {
+    namespaces?: string[];
+    extraNodes?: MetaTreeNode[];
+}): MetaTreeNode[];
+export interface VariableInputProps {
+    value?: string;
+    onChange?: (value: string) => void;
+    disabled?: boolean;
+    placeholder?: string;
+    addonBefore?: React.ReactNode;
+    /**
+     * Restrict the picker to specific top-level meta tree namespaces (e.g.
+     * `['$env', '$user']`). When omitted, every registered top-level property is
+     * exposed. Filter happens at the picker level — the underlying regex used
+     * for pill rendering still matches any `{{ ... }}` expression so pre-existing
+     * out-of-scope values stay legible.
+     */
+    namespaces?: string[];
+    /**
+     * Static leaves appended to the picker, after the namespace-filtered nodes.
+     * Use for ad-hoc local-only variables (e.g. `$resetLink`) that are not part
+     * of the global FlowContext registry.
+     */
+    extraNodes?: MetaTreeNode[];
+    /**
+     * Override the converters used by the underlying `VariableHybridInput`.
+     * Mostly useful when the caller wants to constrain `formatPathToValue` to a
+     * specific namespace (see `EnvVariableInput` for that pattern).
+     */
+    converters?: VariableHybridInputConverters;
+    className?: string;
+    style?: React.CSSProperties;
+}
+/**
+ * Inline (single-line) variable input. Renders the literal text and any
+ * `{{ ... }}` references as styled pills via `VariableHybridInput`. Use for
+ * fields like form input titles, email subject lines, or any place a single
+ * line of mixed literal+variable content is appropriate.
+ */
+export declare function VariableInput(props: VariableInputProps): React.JSX.Element;
+export interface VariableTextAreaProps extends Omit<VariableInputProps, 'converters' | 'addonBefore'> {
+    rows?: number;
+    maxRows?: number;
+}
+/**
+ * Multi-line variable input. Variables are inserted as raw `{{ ... }}` text at
+ * the caret rather than rendered as pills — use for email body templates and
+ * other free-form long-form text where literal display of variable expressions
+ * is desirable (the server expands them at render time).
+ */
+export declare function VariableTextArea(props: VariableTextAreaProps): React.JSX.Element;

package/es/components/form/createFormRegistry.d.ts

@@ -0,0 +1,33 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export interface FormRegistryEntry {
+    name: string;
+}
+export interface FormRegistry<T extends FormRegistryEntry> {
+    readonly namespace: string;
+    register(entry: T): void;
+    unregister(name: string): boolean;
+    get(name: string): T | undefined;
+    has(name: string): boolean;
+    list(): T[];
+}
+/**
+ * Create an isolated, namespaced registry of form-like entries.
+ *
+ * Each call returns a fresh registry instance backed by its own closure-scoped
+ * `Map`, so plugins do not share state across namespaces. Plugins that need an
+ * extension point for form-shaped registrations (e.g. storage configuration
+ * forms, data-source connection forms) can build their own typed registry on
+ * top of this primitive instead of re-implementing the same boilerplate.
+ *
+ * Re-registering the same `name` overwrites the previous entry and emits a
+ * console warning. This is intentional so HMR / hot reload works without
+ * throwing, while still surfacing unintended duplicates during development.
+ */
+export declare function createFormRegistry<T extends FormRegistryEntry>(namespace: string): FormRegistry<T>;

package/es/components/form/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export * from './createFormRegistry';
+export * from './DialogFormLayout';
+export * from './DrawerFormLayout';
+export * from './EnvVariableInput';
+export * from './FileSizeInput';
+export * from './JsonTextArea';
+export * from './PasswordInput';
+export * from './RemoteSelect';
+export * from './VariableInput';

package/es/components/form/table/RowOverlayPreview.d.ts

@@ -0,0 +1,27 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import React from 'react';
+import type { RowSnapshot } from './utils';
+/**
+ * Floating clone of the row being dragged, rendered inside a `<DragOverlay>`
+ * so it follows the cursor while the source row stays in place. We inject the
+ * snapshot's `outerHTML` straight into a mini `<table>` so every antd class
+ * (`ant-table-cell`, `ant-table-selection-column`, theme tokens, etc.) is
+ * preserved. A `<colgroup>` re-applies the measured cell widths so the clone
+ * lines up column-for-column with the source row; the wrapper's pinned
+ * `height` + table `height:100%` keeps vertical sizing consistent regardless
+ * of which antd table size variant the caller picked.
+ *
+ * The wrapper also carries `overlayCellStylesClassName` so the index numeric
+ * (`.nb-table-index`) is hidden while dragging — only the handle + checkbox
+ * are surfaced inside the floating clone.
+ */
+export declare function RowOverlayPreview(props: {
+    snapshot: RowSnapshot;
+}): React.JSX.Element;

package/es/components/form/table/SelectionCell.d.ts

@@ -0,0 +1,36 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import React from 'react';
+export interface SelectionCellProps {
+    /** Whether the row is currently selected — drives the index/checkbox swap. */
+    checked: boolean;
+    /** Zero-based row index (within the current page). `TableIndex` displays it as `index + 1`. */
+    index: number;
+    /** Render the drag handle on the left gutter. Mutually exclusive with `showStandaloneHandle`. */
+    showHandle: boolean;
+    /** Render the row index numeric. When `false` only the antd checkbox is shown (default antd UX). */
+    showIndex: boolean;
+    /** The original antd checkbox node produced by `rowSelection.renderCell`. */
+    originalNode: React.ReactNode;
+}
+/**
+ * The body half of the rowSelection column. Renders, in order:
+ *   1. An absolute-positioned drag handle pinned to the left gutter (only
+ *      when `showHandle` is true). The parent `<td>` must be
+ *      `position: relative` for the handle to land inside the gutter —
+ *      `selectionGutterClassName` in `styles.ts` adds that.
+ *   2. A `.nb-row-selection-cell` wrapper that contains both the row index
+ *      and the checkbox. CSS in `indexSwapClassName` swaps which one is
+ *      visible depending on hover / `checked` state.
+ *
+ * When `showIndex` is false we drop the swap entirely and render only the
+ * original antd checkbox — matches the default antd selection column UX for
+ * tables that don't want the index numeric.
+ */
+export declare function SelectionCell(props: SelectionCellProps): React.JSX.Element;

package/es/components/form/table/Table.d.ts

@@ -0,0 +1,82 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { type TableProps as AntdTableProps } from 'antd';
+import React from 'react';
+import { type RowKey } from './utils';
+/**
+ * Default initial page size for `Table`. Exposed so consumers can seed their
+ * controlled `pageSize` state with the same value the component would use if
+ * they relied purely on the built-in pagination defaults.
+ */
+export declare const DEFAULT_PAGE_SIZE = 50;
+/**
+ * Default `pageSizeOptions` injected into the pagination config. Matches the
+ * v1 settings-page table so users see the same choices across versions.
+ * Consumers can override by passing their own `pageSizeOptions` in
+ * `pagination`.
+ */
+export declare const PAGE_SIZE_OPTIONS: readonly number[];
+export interface TableProps<RecordType extends object = any> extends AntdTableProps<RecordType> {
+    /**
+     * Required so drag-sort, hover-swap and row identity work. Accepts the same
+     * shape as antd `Table.rowKey`. When passed as a function it gets the
+     * record + index and must return a serializable id.
+     */
+    rowKey: RowKey<RecordType>;
+    /**
+     * Show row index (1, 2, 3, …) in the rowSelection column by default; hovering
+     * a row or selecting it reveals the checkbox in the same cell. Requires
+     * `rowSelection` — the index lives in the selection column. Defaults to
+     * `true`.
+     */
+    showIndex?: boolean;
+    /**
+     * Enable vertical drag-and-drop row reordering. When true, rows show a drag
+     * handle on the left and `onSortEnd` fires after each drop. Defaults to
+     * `false`; the rest of the table behaves like a plain antd Table.
+     */
+    isDraggable?: boolean;
+    /**
+     * Called after a row is dropped onto another. Only used when `isDraggable`
+     * is true. The caller persists the move (e.g. `resource.move(...)`) and
+     * refreshes `dataSource` — this component does NOT mutate the data array.
+     */
+    onSortEnd?: (from: RecordType, to: RecordType) => void | Promise<void>;
+    /**
+     * Hide the drag handle entirely while still keeping `isDraggable` on. Useful
+     * when the caller wants to embed `<SortHandle />` inside a custom column.
+     * Defaults to `true`.
+     */
+    showSortHandle?: boolean;
+    /**
+     * Override the width of the auto-inserted handle column when `rowSelection`
+     * is absent. When `rowSelection` is provided the handle is rendered inside
+     * the selection column instead, so this prop is ignored.
+     */
+    sortHandleColumnWidth?: number;
+}
+/**
+ * Generic v2 settings-page table primitive. Built on antd's `Table` and adds:
+ *
+ * - Row-index ↔ checkbox swap inside the selection column (`showIndex`,
+ *   on by default): index visible at rest, checkbox shows on hover or when
+ *   selected. Both elements are absolutely positioned inside the cell so
+ *   they share the same center anchor and never compete for layout space.
+ * - Optional vertical drag-and-drop reordering (`isDraggable`): handle is
+ *   absolute-positioned in a 32px left gutter so the checkbox column stays
+ *   visually centered. The drag overlay renders an `outerHTML` clone of the
+ *   source `<tr>`; the index is suppressed inside the clone so the row
+ *   being moved doesn't display a stale ordinal.
+ *
+ * Use this in place of antd `Table` for any settings-page list. When
+ * `isDraggable` is false the component is a thin pass-through to antd Table
+ * plus the index swap, so it is safe as the default table on any page.
+ */
+export declare function Table<RecordType extends object = any>(props: TableProps<RecordType>): React.JSX.Element;
+export default Table;

package/es/components/form/table/constants.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+/**
+ * Pixel reservation on the left side of the rowSelection column for the drag
+ * handle. Used by the runtime `selectionGutterClassName` (real table) and by
+ * the drag overlay `overlayCellStylesClassName` (floating clone) so both
+ * variants put the handle in the same gutter position.
+ */
+export declare const SORT_HANDLE_GUTTER = 32;

package/es/components/form/table/dnd/SortableRow.d.ts

@@ -0,0 +1,40 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type { SyntheticListenerMap } from '@dnd-kit/core/dist/hooks/utilities';
+import type { DraggableAttributes } from '@dnd-kit/core';
+import React from 'react';
+type DragSortRowContextValue = {
+    attributes?: DraggableAttributes;
+    listeners?: SyntheticListenerMap;
+    setActivatorNodeRef?: (node: HTMLElement | null) => void;
+};
+export declare const DragSortRowContext: React.Context<DragSortRowContextValue>;
+/**
+ * Activator handle that initiates a row drag. Reads `attributes` / `listeners`
+ * / `setActivatorNodeRef` from the surrounding `DragSortRowContext` provided
+ * by `SortableRow`, so the handle can sit anywhere within the row's cells
+ * (typically a dedicated first column).
+ */
+export declare const SortHandle: React.FC<{
+    id?: string | number;
+    style?: React.CSSProperties;
+}>;
+/**
+ * Drop-in replacement for antd Table's `<tr>` body row that wires `useSortable`
+ * keyed by the `data-row-key` attribute antd injects. Pass via
+ * `Table.components.body.row` and wrap the `<tbody>` with `DndContext` +
+ * `SortableContext`. The `DragSortRowContext` it provides lets `SortHandle`
+ * be placed anywhere inside the row, not just on the row itself.
+ */
+export declare const SortableRow: React.FC<{
+    rowIndex?: number;
+    className?: string;
+    [key: string]: any;
+}>;
+export {};

package/{lib/hooks → es/components/form/table/dnd}/index.d.ts

@@ -6,6 +6,4 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-export * from './useApp';
-export * from './usePlugin';
-export * from './useRouter';
+export * from './SortableRow';

package/es/components/form/table/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export * from './Table';

package/es/components/form/table/styles.d.ts

@@ -0,0 +1,51 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+/**
+ * Restore horizontal scrolling on `.ant-table-content` so wide tables in
+ * narrow containers (drawer / settings panel) scroll their inner `<table>`
+ * instead of getting clipped or forcing the outer container to grow.
+ *
+ * `width: max-content` on the inner `<table>` lets columns size to their
+ * natural width; `min-width: 100%` keeps the table filling the viewport
+ * when total column width is smaller than the container.
+ */
+export declare const tableScrollClassName: string;
+/**
+ * Reserve a `SORT_HANDLE_GUTTER`-wide gap on the left of the rowSelection
+ * column so the handle's `left:0` lands inside a `position:relative` cell.
+ * Padding is mirrored on both the header `<th>` and body `<td>` so the
+ * "select all" checkbox stays vertically aligned with body checkboxes.
+ *
+ * The class is a module-level constant — emotion's hash is stable across
+ * re-renders, so the caller doesn't need a `useMemo` to keep referential
+ * equality.
+ */
+export declare const selectionGutterClassName: string;
+/**
+ * Index ↔ checkbox hover swap CSS. Both `.nb-table-index` and the antd
+ * checkbox (wrapped in `.nb-origin-node`) are absolutely positioned and
+ * centered inside `.nb-row-selection-cell`, so they share the same anchor
+ * without one displacing the other. `display: none/flex` flips so they never
+ * overlap mid-transition.
+ */
+export declare const indexSwapClassName: string;
+/**
+ * Self-contained styles for the drag-overlay clone. The runtime
+ * `selectionGutterClassName` + `indexSwapClassName` are scoped to AntdTable's
+ * emotion hash, so they don't reach the cloned `<tr>` injected via
+ * `dangerouslySetInnerHTML`. This class replays the minimal subset that the
+ * clone needs:
+ *   - selection column gutter + `position: relative` so the absolute handle
+ *     lands correctly
+ *   - hide the row index inside the overlay (drag preview shouldn't carry
+ *     a stale ordinal)
+ *   - force the checkbox (`.nb-origin-node`) absolute-centered and visible
+ *     regardless of hover/checked state, so the selection cell isn't empty
+ */
+export declare const overlayCellStylesClassName: string;

package/es/components/form/table/utils.d.ts

@@ -0,0 +1,44 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type React from 'react';
+/**
+ * Same shape as antd Table's `rowKey` prop — either a record key name or a
+ * function. Hoisted here so utilities and `Table.tsx` agree on the contract.
+ */
+export type RowKey<RecordType extends object> = (keyof RecordType & (string | number)) | ((record: RecordType, index?: number) => React.Key);
+/**
+ * Read a stable row id off a record. Mirrors antd Table's rowKey resolution
+ * but normalises non-primitive ids to strings so `data-row-key` attributes
+ * and `useSortable({ id })` agree on equality.
+ */
+export declare function readRowKey<RecordType extends object>(record: RecordType, rowKey: RowKey<RecordType>, index?: number): React.Key | undefined;
+/**
+ * Pixel-perfect snapshot of a rendered `<tr>` for the drag overlay clone.
+ * Contains everything needed to rebuild a visually identical floating row
+ * without re-running antd's column layout pass.
+ */
+export type RowSnapshot = {
+    /** outerHTML of the source `<tr>`, captured at drag start. */
+    html: string;
+    /** Per-cell pixel widths (in DOM order) so the clone can fix them via `<col>`. */
+    cellWidths: number[];
+    /** Total row width — used as the wrapper width so the clone matches source horizontally. */
+    totalWidth: number;
+    /** Total row height — applied to the clone so cell padding matches the source row exactly. */
+    totalHeight: number;
+};
+/**
+ * Snapshot the source `<tr>` so the drag overlay can render a pixel-accurate
+ * floating clone. We can't reliably recompute the layout from `columns` alone
+ * — antd auto-sizes columns at runtime based on content + the surrounding
+ * container — so we read the rendered widths off the DOM at drag start. The
+ * row height is captured too because antd's cell padding rules are scoped to
+ * a selector chain we strip in the clone.
+ */
+export declare function snapshotSourceRow(rowKey: string): RowSnapshot | null;

package/es/components/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export * from './AppComponents';
+export * from './BlankComponent';
+export * from './form/table/dnd';
+export * from './form';
+export * from './Icon';
+export * from './PoweredBy';
+export * from './RouterContextCleaner';
+export * from './SwitchLanguage';
+export * from './form/table';

package/es/css-variable/CSSVariableProvider.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export declare const CSSVariableProvider: {
+    ({ children }: {
+        children: any;
+    }): any;
+    displayName: string;
+};
+export default CSSVariableProvider;

package/es/flow/FlowModelRepository.d.ts

@@ -0,0 +1,36 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { FlowModel, IFlowModelRepository } from '@nocobase/flow-engine';
+import type { BaseApplication } from '../BaseApplication';
+export declare class MockFlowModelRepository implements IFlowModelRepository<FlowModel> {
+    protected prefix: string;
+    constructor(prefix?: string);
+    get models(): Map<any, any>;
+    findOne(query: any): Promise<any>;
+    loadByParentId(parentId: string): Promise<any>;
+    load(uid: string): Promise<any>;
+    save(model: FlowModel): Promise<Record<string, any>>;
+    destroy(uid: string): Promise<boolean>;
+    clear(): Promise<boolean>;
+    move(sourceId: string, targetId: string, position?: 'before' | 'after'): Promise<void>;
+    duplicate(uid: string): Promise<any>;
+}
+export declare class FlowModelRepository implements IFlowModelRepository<FlowModel> {
+    private app;
+    constructor(app: BaseApplication);
+    private inFlightFindOne;
+    private buildFindOneKey;
+    findOne(query: any): Promise<any>;
+    save(model: FlowModel, options?: {
+        onlyStepParams?: boolean;
+    }): Promise<any>;
+    destroy(uid: string): Promise<boolean>;
+    move(sourceId: string, targetId: string, position?: 'before' | 'after'): Promise<any>;
+    duplicate(uid: string): Promise<any>;
+}

package/es/flow/FlowPage.d.ts

@@ -0,0 +1,20 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type { FlowModel } from '@nocobase/flow-engine';
+import React from 'react';
+import FlowRoute from './components/FlowRoute';
+type FlowPageProps = {
+    pageModelClass?: string;
+    parentId?: string;
+    onModelLoaded?: (uid: string, model: FlowModel) => void;
+    defaultTabTitle?: string;
+};
+export declare const FlowPage: React.MemoExoticComponent<(props: FlowPageProps & Record<string, unknown>) => React.JSX.Element>;
+export declare const RemoteFlowModelRenderer: (props: any) => React.JSX.Element;
+export { FlowRoute };