@nocobase/plugin-workflow 2.2.0-alpha.1 → 2.2.0-alpha.3

package/dist/client-v2/canvas/addNodeController.d.ts

@@ -0,0 +1,70 @@
+/**
+ * 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 { Instruction } from './Instruction';
+import type { SharedAddNodeAnchor } from './AddNodeContext.shared';
+export type AddNodeControllerRuntime = {
+    workflow: any;
+    nodes: any[];
+    getInstruction: (type: string) => Instruction | undefined;
+    getInstructionAvailable?: (instruction: Instruction, context: Record<string, any>) => string | null;
+    translateTitle: (title: string) => string;
+    api: any;
+    refresh?: () => void;
+};
+export type AddNodeDraft = {
+    key: string;
+    type: string;
+    upstreamId: any;
+    branchIndex: number | null | undefined;
+    title: string;
+    config: Record<string, any>;
+};
+export type AddNodeDecision = {
+    kind: 'missing';
+    type: string;
+} | {
+    kind: 'blocked';
+    message: string;
+    instruction: Instruction;
+} | {
+    kind: 'legacy-preset';
+    instruction: Instruction;
+    draft: AddNodeDraft;
+} | {
+    kind: 'modern-preset';
+    instruction: Instruction;
+    anchor: SharedAddNodeAnchor;
+    hasDownstream: boolean;
+} | {
+    kind: 'branch-fallback';
+    instruction: Instruction;
+    draft: AddNodeDraft;
+} | {
+    kind: 'direct';
+    instruction: Instruction;
+    draft: AddNodeDraft;
+};
+export declare function findDownstream(nodes?: any[], upstream?: any, branchIndex?: number | null): any;
+export declare function createNodeDraft({ instruction, anchor, translateTitle, }: {
+    instruction: Instruction;
+    anchor: SharedAddNodeAnchor;
+    translateTitle: (title: string) => string;
+}): AddNodeDraft;
+export declare function resolveAddNodeDecision({ type, anchor, runtime, }: {
+    type: string;
+    anchor: SharedAddNodeAnchor;
+    runtime: Pick<AddNodeControllerRuntime, 'workflow' | 'nodes' | 'getInstruction' | 'getInstructionAvailable' | 'translateTitle'>;
+}): AddNodeDecision;
+export declare function createNodeAndMaybeReparent({ workflowId, api, refresh, values, downstreamBranchIndex, }: {
+    workflowId: any;
+    api: any;
+    refresh?: () => void;
+    values: Record<string, any>;
+    downstreamBranchIndex?: number | null;
+}): Promise<any>;

package/dist/client-v2/canvas/collectionFieldOptions.d.ts

@@ -0,0 +1,57 @@
+/**
+ * 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';
+export type FieldTreeCollectionManager = {
+    getCollectionAllFields(collection: string): any[];
+    getCollection?(collection: string): {
+        template?: string;
+    } | undefined;
+};
+export type VariableOption = {
+    key?: string;
+    value?: string;
+    label?: string | React.ReactNode;
+    children?: VariableOption[] | null;
+    [key: string]: any;
+};
+export type VariableDataType = 'boolean' | 'number' | 'string' | 'date' | {
+    type: 'reference';
+    options: {
+        collection: string;
+        multiple?: boolean;
+        entity?: boolean;
+    };
+} | ((field: any, options: {
+    collectionManager?: FieldTreeCollectionManager;
+}) => boolean);
+export type UseVariableOptions = {
+    types?: VariableDataType[];
+    fieldNames?: {
+        label?: string;
+        value?: string;
+        children?: string;
+    };
+    appends?: string[] | null;
+    depth?: number;
+};
+export declare const defaultFieldNames: {
+    readonly label: "label";
+    readonly value: "value";
+    readonly children: "children";
+};
+/**
+ * @deprecated
+ */
+export declare const BaseTypeSets: {
+    boolean: Set<string>;
+    number: Set<string>;
+    string: Set<string>;
+    date: Set<string>;
+};
+export declare function getCollectionFieldOptions(options: any): VariableOption[];

package/dist/client-v2/canvas/contexts.d.ts

@@ -0,0 +1,84 @@
+/**
+ * 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.
+ */
+/**
+ * The two canvas React contexts, shared by both canvases (ADR-0003, doc §9.4).
+ *
+ * Aligns with v1's two-context split:
+ *   - FlowContext (canvas root) = `{ workflow, nodes, refresh }`
+ *   - NodeContext (per node)    = the node object itself (with live
+ *                                 `upstream`/`downstream` linked-list refs)
+ *
+ * Zero dependencies (bare `React.createContext`), so both v1 and v2 share this
+ * one definition. v1 re-exports `NodeContext`/`useNodeContext` from here via the
+ * allowed `v1 → v2` import direction.
+ *
+ * `workflow`/`upstreams` are derived via hooks (`useAvailableUpstreams`), never
+ * bundled into the node-context value.
+ */
+import React from 'react';
+import type { WorkflowCanvasRecord, WorkflowRevision } from '../components/workflowCanvas';
+/**
+ * A canvas node — the live linked-list element produced by `linkNodes`: the flat
+ * `flow_nodes` row plus the wired `upstream`/`downstream` object refs. Kept loose
+ * (index signature) because node `config` shapes are per-instruction; the named
+ * fields are the ones the canvas itself reads.
+ */
+export type CanvasNode = {
+    id: number;
+    key?: string;
+    type?: string;
+    title?: string;
+    config?: Record<string, any>;
+    upstreamId?: number | null;
+    downstreamId?: number | null;
+    branchIndex?: number | null;
+    upstream?: CanvasNode | null;
+    downstream?: CanvasNode | null;
+    [key: string]: any;
+};
+/**
+ * The canvas-root context value, shared by both canvases and matching v1's
+ * `FlowContext.Provider` shapes:
+ *   - editor canvas        → `{ workflow, nodes, refresh }`
+ *   - execution canvas     → `{ workflow, nodes, execution, viewJob, setViewJob }`
+ *   - manual-todo canvas   → `{ workflow, nodes, execution, userJob }`
+ * All fields optional so a consumer reading e.g. only `nodes` is typed against
+ * any canvas, and the bare-`{}` default (no provider) still satisfies it.
+ */
+export type WorkflowCanvasFlowContextValue = {
+    workflow?: WorkflowCanvasRecord | null;
+    nodes?: CanvasNode[];
+    refresh?: () => void;
+    /** Editor canvas: sibling versions of the workflow (the version dropdown). */
+    revisions?: WorkflowRevision[];
+    /** Execution canvas only: the execution being viewed (read-only nodes). */
+    execution?: Record<string, any> | null;
+    /** Execution canvas only: the job whose result modal is open. */
+    viewJob?: Record<string, any> | null;
+    /** Execution canvas only: open/close the job result modal. */
+    setViewJob?: (job: Record<string, any> | null) => void;
+    /** Manual-todo canvas only (plugin-workflow-manual): the current user job
+     *  record whose form/status the todo card renders. */
+    userJob?: Record<string, any> | null;
+};
+export declare const FlowContext: React.Context<WorkflowCanvasFlowContextValue>;
+export declare function useFlowContext(): WorkflowCanvasFlowContextValue;
+export declare const CurrentWorkflowContext: React.Context<Partial<WorkflowCanvasRecord>>;
+export declare function useCurrentWorkflowContext(): Partial<WorkflowCanvasRecord>;
+export declare const NodeContext: React.Context<CanvasNode>;
+export declare function useNodeContext(): CanvasNode;
+/**
+ * The executed-version count of the workflow shown on the canvas — `> 0n` means
+ * its nodes are read-only. A BigInt mirroring v1's `useWorkflowExecuted`, reading
+ * the same `versionStats.executed` field (the workflow record has NO top-level
+ * `executed` — the previous `workflow?.executed` read was always undefined, so
+ * the canvas never went read-only after an execution). Callers needing a boolean
+ * coerce with `Boolean(...)`.
+ */
+export declare function useWorkflowCanvasExecuted(): bigint;

package/dist/client-v2/canvas/dropImpact.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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.
+ */
+/**
+ * Pure graph walks for drag/clipboard impact analysis (ADR-0003, doc §9.6).
+ *
+ * Relocated verbatim from `src/client/NodeDragContext.tsx` — Formily-free,
+ * hook-free — so both canvases' drag/clipboard Providers share one copy of the
+ * tricky topology math while each keeps its own hook-ful Provider shell. v1
+ * re-exports these; the v1 golden-baseline tests re-run unchanged against this
+ * copy.
+ */
+/**
+ * Walk the full downstream reachable set from `start`: the main chain plus
+ * every branch subtree (via `branchChildrenMap: upstreamId → branch-head nodes`).
+ */
+export declare function collectDownstreams(start: any, branchChildrenMap: Map<number, any[]>, visited?: Set<number>): Set<number>;
+/**
+ * Collect a branching node's own subtree: the node itself plus all of its
+ * branch subtrees (but NOT its main-chain downstream). Used to know which nodes
+ * move together when a branch node is dragged.
+ */
+export declare function collectBranchSubtree(root: any, branchChildrenMap: Map<number, any[]>): Set<number>;

package/dist/client-v2/canvas/instructionAvailability.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 { SharedAddNodeAnchor } from './AddNodeContext.shared';
+type WorkflowCapabilityContext = SharedAddNodeAnchor & {
+    engine: {
+        isWorkflowSync(workflow: unknown): boolean;
+    };
+    workflow?: unknown;
+    syncOnly?: boolean;
+};
+type Translate = (key: string, options?: Record<string, unknown>) => string;
+type AvailableInstruction = {
+    async?: boolean;
+    isAvailable?(ctx: Omit<WorkflowCapabilityContext, 'branchContext'>): boolean;
+};
+export declare function getInstructionUnavailableMessage(instruction: AvailableInstruction, ctx: WorkflowCapabilityContext, t: Translate): string;
+export declare function getInstructionAvailable(instruction: AvailableInstruction, ctx: WorkflowCapabilityContext & {
+    t: Translate;
+}): string;
+export {};

package/dist/client-v2/canvas/nodeRenderDispatch.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.
+ */
+/**
+ * Which renderer a node uses on the LEGACY canvas, across all three migratable
+ * surfaces — the in-canvas card, the config drawer, and the add-time preset
+ * (ADR-0003).
+ *
+ * The dispatch rule is the same for all three and is the key to progressive,
+ * surface-by-surface migration: **a v1 artifact always wins.** During migration a
+ * node's instruction carries both generations — its own legacy artifact and the
+ * modern loader it inherits when the v1 instruction `extends` its v2 counterpart.
+ * Keeping the legacy artifact is the opt-out signal ("this surface is not switched
+ * to v2 yet"), so the legacy canvas keeps rendering it; only when a node DROPS its
+ * legacy artifact (but still inherits the loader) does that one surface render via
+ * v2. The three surfaces switch independently — a node can move its card to v2
+ * while its drawer stays on Formily, or vice-versa.
+ *
+ *   card:   `Component`       ⟶ falls back to `ComponentLoader`        (this card)
+ *   drawer: `fieldset`        ⟶ falls back to `FieldsetLoader`         (this drawer)
+ *   preset: `presetFieldset`  ⟶ falls back to `PresetFieldsetLoader`   (this preset)
+ *
+ * A legacy *schema* artifact (`fieldset` / `presetFieldset`) counts only when it
+ * actually has entries — an inherited-but-empty `{}` is treated as absent, so it
+ * does not pin a node that meant to drop it.
+ *
+ * Pure decisions (no JSX, no hooks) so they are unit-testable and shared; the
+ * legacy callers read the verdict and render accordingly. The modern canvas does
+ * NOT use these — it always renders via the loaders (it never had the legacy
+ * artifacts).
+ */
+type RenderableInstruction = {
+    Component?: unknown;
+    ComponentLoader?: unknown;
+};
+type ConfigurableInstruction = {
+    fieldset?: unknown;
+    FieldsetLoader?: unknown;
+};
+type PresettableInstruction = {
+    presetFieldset?: unknown;
+    PresetFieldsetLoader?: unknown;
+};
+export type LegacyNodeRenderMode = 
+/** Render the legacy Formily `Component` (still on v1, or no v2 loader). */
+'legacy-component'
+/** Render fully via the modern `ComponentLoader` (v1 dropped its `Component`). */
+ | 'modern-loader'
+/** Neither renderer — the legacy canvas falls back to its default card. */
+ | 'default-card';
+export type LegacyFieldsetRenderMode = 
+/** Render the legacy Formily schema (`fieldset` / `presetFieldset` has entries). */
+'legacy-fieldset'
+/** Render via the modern loader (the legacy schema was dropped). */
+ | 'modern-loader'
+/** Neither — caller applies its own no-config fallback. */
+ | 'none';
+export declare function resolveLegacyNodeRenderMode(instruction: RenderableInstruction | undefined): LegacyNodeRenderMode;
+/** Config-drawer dispatch: legacy `fieldset` (with entries) wins, else the modern
+ *  `FieldsetLoader`, else neither (caller opens its empty Formily drawer). */
+export declare function resolveLegacyConfigRenderMode(instruction: ConfigurableInstruction | undefined): LegacyFieldsetRenderMode;
+/** Add-time preset dispatch: legacy `presetFieldset` (with entries) wins, else the
+ *  modern `PresetFieldsetLoader`, else neither (caller applies its preset/branch
+ *  fallback). */
+export declare function resolveLegacyPresetRenderMode(instruction: PresettableInstruction | undefined): LegacyFieldsetRenderMode;
+/**
+ * The stable `workflow-node-type-<type>` hook applied to a node's inner card
+ * (`nodeClass`), matching the live `next` DOM. It carries no CSS of its own — it
+ * lets external code, tests, and debugging target a node by type. Shared so every
+ * card stamps it identically regardless of which renderer (Formily `Component`,
+ * the v2 default card, or a v2 `ComponentLoader`) draws the node.
+ */
+export declare function nodeTypeClassName(type: string | undefined): string;
+export {};

package/dist/client-v2/canvas/nodeTree.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ */
+/**
+ * Pure node-tree helpers shared by the legacy and modern canvases (ADR-0003).
+ *
+ * Relocated verbatim from `src/client/utils.ts` — Formily-free, hook-free,
+ * no `ctx` reads — so both canvases share one copy. v1 re-exports these from
+ * here via the allowed `v1 → v2` import direction; the v1 golden-baseline tests
+ * re-run unchanged against this copy.
+ */
+/**
+ * Wire live `upstream`/`downstream` object refs onto each node from the flat
+ * `flow_nodes` list (by `upstreamId`/`downstreamId`). Mutates in place.
+ */
+export declare function linkNodes(nodes: any): void;

package/dist/client-v2/canvas/nodeVariableUtils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 function extractDependencyKeys(config: Record<string, any>): Set<string>;
+export declare function stripVariableReferences(value: any, keysToRemove: Set<string>): {
+    value: any;
+    changed: boolean;
+};
+export declare function collectUpstreams(node: any): Set<number>;

package/dist/client-v2/canvas/removeNodeUtils.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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.
+ */
+/**
+ * Collect a branch subtree: every node reachable from `branchHead` following the
+ * `downstream` chain, descending into each node's nested branches (children whose
+ * `upstream` is that node and which carry a `branchIndex`). Keyed by node id.
+ *
+ * Verbatim port of v1's `findBranchNodes` (`client/RemoveNodeContext.tsx`). The
+ * linked-list fields (`upstream`/`downstream`) are assumed already wired by
+ * `linkNodes`.
+ */
+export declare function collectBranchNodes(nodes: any[], branchHead: any): Map<any, any>;
+/**
+ * Find the nodes (excluding the target itself) that reference `target`'s output —
+ * the set v1 blocks deletion on ("The result of this node has been referenced by
+ * other nodes …"). `candidates` is the pool to scan: for a **leaf** node delete
+ * it's all other nodes (`$jobsMapByNodeKey` only, `includeScopes: false`); for a
+ * **branching** node delete it's the related/downstream subtree
+ * (`includeScopes: true`).
+ */
+export declare function findNodesReferencing(candidates: any[], target: {
+    key: string;
+}, { includeScopes }?: {
+    includeScopes?: boolean;
+}): any[];

package/dist/client-v2/canvas/style.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ */
+declare const useStyles: (props?: unknown) => import("antd-style").ReturnStyles<{
+    workflowPageClass: import("antd-style").SerializedStyles;
+    dropdownClass: import("antd-style").SerializedStyles;
+    workflowVersionDropdownClass: import("antd-style").SerializedStyles;
+    executionsDropdownRowClass: import("antd-style").SerializedStyles;
+    workflowDetailsDescriptionClass: import("antd-style").SerializedStyles;
+    branchBlockClass: import("antd-style").SerializedStyles;
+    branchClass: import("antd-style").SerializedStyles;
+    nodeBlockClass: import("antd-style").SerializedStyles;
+    nodeClass: import("antd-style").SerializedStyles;
+    nodeCardClass: import("antd-style").SerializedStyles;
+    nodeJobButtonClass: import("antd-style").SerializedStyles;
+    nodeHeaderClass: import("antd-style").SerializedStyles;
+    nodeMetaClass: import("antd-style").SerializedStyles;
+    nodeTitleClass: import("antd-style").SerializedStyles;
+    nodeSubtreeClass: import("antd-style").SerializedStyles;
+    nodeJobResultClass: import("antd-style").SerializedStyles;
+    addButtonClass: import("antd-style").SerializedStyles;
+    dropZoneClass: import("antd-style").SerializedStyles;
+    pasteButtonClass: import("antd-style").SerializedStyles;
+    dragPreviewClass: import("antd-style").SerializedStyles;
+    clipboardPreviewClass: import("antd-style").SerializedStyles;
+    conditionClass: import("antd-style").SerializedStyles;
+    loopLineClass: import("antd-style").SerializedStyles;
+    terminalClass: import("antd-style").SerializedStyles;
+}>;
+export default useStyles;

package/dist/client-v2/canvas/textAreaInsertion.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 function insertTextAtSelection(value: string, insertText: string, start: number, end: number): {
+    nextValue: string;
+    nextSelectionStart: number;
+    nextSelectionEnd: number;
+};
+export declare function setNativeTextAreaValue(input: HTMLTextAreaElement, value: string): void;

package/dist/client-v2/canvas/useWorkflowInstruction.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 { Instruction } from './Instruction';
+/** The slice of the workflow client plugin the canvas card needs — the
+ *  `instructions` registry shared by v1 `PluginWorkflowClient` and v2
+ *  `PluginWorkflowClientV2`. */
+export type WorkflowInstructionPlugin = {
+    instructions: {
+        get(type: string): Instruction | undefined;
+    };
+};
+/** Resolve the current runtime's workflow client plugin via the neutral
+ *  `'workflow'` alias — v1's or v2's, whichever this runtime loaded. */
+export declare function useWorkflowPlugin(): WorkflowInstructionPlugin | undefined;
+/** Resolve a node type's instruction in a runtime-neutral way. Uses the shared
+ *  `instructions` registry (present on both plugins), not v2-only `getInstruction`. */
+export declare function useInstruction(type?: string): Instruction | undefined;

package/dist/client-v2/canvas/useWorkflowVariableOptions.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 { MetaTreeNode } from '@nocobase/flow-engine';
+export type UseWorkflowVariableOptions = {
+    types?: any[];
+    fieldNames?: {
+        label?: string;
+        value?: string;
+        children?: string;
+    };
+    appends?: string[] | null;
+    depth?: number;
+    /**
+     * Include the `$scopes` root. Scope providers (loop / parallel) building
+     * their own local variables must disable this when they call back into the
+     * workflow aggregator, otherwise the scope chain recursively nests itself.
+     */
+    includeScopes?: boolean;
+};
+/**
+ * Build the workflow variable MetaTree for the current node's config form.
+ * Aggregates every scope in v1's display order, dropping the ones that
+ * contribute nothing.
+ *
+ * The result is **referentially stable** across re-renders for the same inputs
+ * (memoized on the current node + upstream/scope node keys + workflow id). This
+ * is load-bearing for lazy relation expansion: `TypedVariableInput.loadData`
+ * resolves a node's children and mutates them onto the meta node in place, then
+ * forces a re-render — if this hook returned a brand-new tree each render, that
+ * mutated (resolved) child list would be discarded and the cascader column would
+ * spin forever. Memoizing keeps the same tree objects alive so the resolved
+ * children survive the re-render.
+ */
+export declare function useWorkflowVariableOptions(options?: UseWorkflowVariableOptions): MetaTreeNode[];

package/dist/client-v2/canvas/workflowVariableConverters.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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, VariableHybridInputConverters } from '@nocobase/flow-engine';
+export declare const WORKFLOW_VARIABLE_REGEXP: RegExp;
+export declare function formatWorkflowPathToValue(item?: MetaTreeNode): string;
+export declare function parseWorkflowValueToPath(value?: string): string[];
+export declare const workflowVariableConverters: VariableHybridInputConverters;

package/dist/client-v2/components/Calculation.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 } from '@nocobase/flow-engine';
+import React from 'react';
+export declare const calculators: any;
+export interface CalculationConfigProps {
+    value?: any;
+    onChange?: (value: any) => void;
+    useVariableHook?: () => MetaTreeNode[];
+}
+export declare function CalculationConfig({ value, onChange, useVariableHook, }: CalculationConfigProps): React.JSX.Element;
+export default CalculationConfig;

package/dist/client-v2/components/ExecutionStatusIcon.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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';
+/**
+ * Compact, circular status indicator (icon-only Tag) used where a full status
+ * label would be too wide — e.g. the execution-switcher dropdown rows. Mirrors
+ * v1's `StatusButton`.
+ */
+export declare function ExecutionStatusIcon({ value }: {
+    value: number | null;
+}): React.JSX.Element;
+export default ExecutionStatusIcon;

package/dist/{client/triggers/schedule/RepeatField.d.ts → client-v2/components/ExecutionStatusTag.d.ts}

@@ -7,8 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import React from 'react';
-export declare function RepeatField({ value, onChange, disabled }: {
-    value?: any;
-    onChange: any;
-    disabled: any;
+export declare function ExecutionStatusTag({ value }: {
+    value: number | null;
 }): React.JSX.Element;
+export default ExecutionStatusTag;

package/dist/client-v2/components/ExecutionViewHeader.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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';
+type ExecutionWorkflow = {
+    id?: number | string;
+    key?: string;
+    title?: string;
+};
+type ExecutionViewRecord = {
+    id?: number | string;
+    key?: string;
+    status?: number | null;
+    reason?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    workflow?: ExecutionWorkflow;
+};
+export declare function ExecutionViewHeader({ execution, resource, refresh, }: {
+    execution: ExecutionViewRecord;
+    resource: any;
+    refresh: () => void;
+}): React.JSX.Element;
+export default ExecutionViewHeader;

package/dist/client-v2/components/ExecutionsDropdown.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 type ExecutionRecord = {
+    id?: number | string;
+    key?: string;
+    status?: number | null;
+    createdAt?: string;
+};
+/**
+ * Switch between executions of the same workflow. Loads a window of the
+ * executions immediately before and after the current one (by id), mirroring
+ * v1's prev/next loading.
+ */
+export declare function ExecutionsDropdown({ execution, refresh }: {
+    execution: ExecutionRecord;
+    refresh?: () => void;
+}): React.JSX.Element;
+export default ExecutionsDropdown;