@fudanda/workflow 0.0.0-stage → 2.20261024.1-beta.1

package/dist/coze/compat/base.d.ts

@@ -0,0 +1,116 @@
+import type { CSSProperties, ReactNode } from 'react';
+export declare const PublicScopeProvider: ({ children }: {
+    children: ReactNode;
+}) => ReactNode;
+export declare const EmptyFunction: () => void;
+export declare const useNodeTestId: () => {
+    getNodeSetterId: (name: string) => string;
+    getNodeTestId: () => string;
+    concatTestId: (...parts: unknown[]) => string;
+};
+export type WithCustomStyle<T = object> = T & {
+    className?: string;
+    style?: CSSProperties;
+};
+export type ViewVariableMeta = {
+    name: string;
+    type?: string;
+};
+export type RecursedParamDefinition = {
+    name: string;
+    type: ViewVariableType;
+    isQuote?: boolean;
+    fixedValue?: unknown;
+    quotedValue?: unknown;
+    fieldRandomKey?: string;
+};
+export declare enum ResponseFormat {
+    JSON = 0,
+    Text = 1,
+    Markdown = 2
+}
+export declare enum GenerationDiversity {
+    Customize = "default_val",
+    Creative = "creative",
+    Balance = "balance",
+    Precise = "precise"
+}
+export declare const RESPONSE_FORMAT_NAME = "response_format";
+export declare enum ViewVariableType {
+    String = "string",
+    Integer = "integer",
+    Number = "number",
+    Boolean = "boolean",
+    Object = "object",
+    ArrayString = "array-string",
+    ArrayInteger = "array-integer",
+    ArrayNumber = "array-number",
+    ArrayBoolean = "array-boolean",
+    ArrayObject = "array-object",
+    ArrayFile = "array-file",
+    File = "file",
+    Image = "image",
+    Video = "video",
+    Svg = "svg",
+    Txt = "txt",
+    Doc = "doc",
+    Excel = "excel",
+    Ppt = "ppt",
+    Zip = "zip",
+    Code = "code",
+    Audio = "audio",
+    Voice = "voice",
+    Time = "time",
+    ArrayImage = "array-image",
+    ArrayDoc = "array-doc",
+    ArrayCode = "array-code",
+    ArrayPpt = "array-ppt",
+    ArrayTxt = "array-txt",
+    ArrayExcel = "array-excel",
+    ArrayAudio = "array-audio",
+    ArrayZip = "array-zip",
+    ArrayVideo = "array-video",
+    ArraySvg = "array-svg",
+    ArrayVoice = "array-voice",
+    ArrayTime = "array-time"
+}
+export declare const VARIABLE_TYPE_ALIAS_MAP: Record<string, string>;
+export declare const FILE_TYPES: ViewVariableType[];
+export declare namespace ViewVariableType {
+    const getComplement: (types: ViewVariableType[]) => ViewVariableType[];
+    const isArrayType: (value: ViewVariableType) => boolean;
+    const getArraySubType: (value: ViewVariableType) => ViewVariableType;
+    const isJSONInputType: (value: ViewVariableType) => boolean;
+    const isFileType: (value: ViewVariableType) => boolean;
+}
+export declare enum ValueExpressionType {
+    LITERAL = "literal",
+    REF = "ref"
+}
+export type RefExpression = {
+    type: ValueExpressionType.REF;
+    content: {
+        keyPath: string[];
+    };
+};
+export type ValueExpression = RefExpression | {
+    type: ValueExpressionType.LITERAL;
+    content: unknown;
+};
+export type LiteralExpression = Extract<ValueExpression, {
+    type: ValueExpressionType.LITERAL;
+}>;
+export declare const ValueExpression: {
+    isRef: (value: ValueExpression) => value is RefExpression;
+    isLiteral: (value: ValueExpression) => value is LiteralExpression;
+};
+export type InputTypeValueVO = {
+    name: string;
+    type?: ViewVariableType;
+    input?: ValueExpression;
+};
+export type InputValueVO = InputTypeValueVO;
+export type ConditionType = 'eq' | 'ne' | 'lt' | 'lte' | 'gt' | 'gte' | 'contains' | 'empty' | 'exists';
+export declare enum StandardNodeType {
+    Api = "core.http"
+}

package/dist/coze/control-icon.d.ts

@@ -0,0 +1,15 @@
+declare const icons: {
+    layout: string;
+    fit: string;
+    copy: string;
+    remove: string;
+    more: string;
+    add: string;
+    back: string;
+    play: string;
+    workflow: string;
+};
+export declare function ControlIcon({ name }: {
+    name: keyof typeof icons;
+}): import("react").JSX.Element;
+export {};

package/dist/coze/execution-panel.d.ts

@@ -0,0 +1,8 @@
+import { type ReactNode } from 'react';
+import './execution-panel.css';
+/** Pinned Coze BottomPanel; the host supplies authenticated run records. */
+export declare function WorkflowExecutionPanel({ header, children, onClose }: {
+    header: ReactNode;
+    children: ReactNode;
+    onClose: () => void;
+}): import("react").JSX.Element;

package/dist/coze/schema-tree.d.ts

@@ -0,0 +1,9 @@
+import type { TreeNodeCustomData } from './source/form-extensions/components/output-tree/components/custom-tree-node/type';
+type Schema = Record<string, unknown>;
+export declare function schemaToTree(schema: Schema, path?: string): TreeNodeCustomData[];
+export declare function treeIssues(rows: TreeNodeCustomData[], path?: string): {
+    path: string;
+    message: string;
+}[];
+export declare function treeToSchema(rows: TreeNodeCustomData[], base: Schema): Schema;
+export {};

package/dist/coze/side-panel.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from 'react';
+export declare function WorkflowSidePanel({ title, header, tabs, footer, children, onClose, className, focusKey, onFocusRestore }: {
+    title?: string;
+    header?: ReactNode;
+    tabs?: ReactNode;
+    footer?: ReactNode;
+    children: ReactNode;
+    onClose?: () => void;
+    className?: string;
+    focusKey?: string;
+    onFocusRestore?: (target: HTMLElement) => void;
+}): import("react").JSX.Element;

package/dist/coze/source/form-extensions/components/output-tree/components/custom-tree-node/constants.d.ts

@@ -0,0 +1,13 @@
+import { ViewVariableType } from '../../../../../../compat/base';
+export declare const ObjectLikeTypes: ViewVariableType[];
+export declare enum ChangeMode {
+    Update = 0,
+    Delete = 1,
+    Append = 2,
+    DeleteChildren = 3
+}
+export declare enum DescriptionLine {
+    Single = "singleline",
+    Multi = "multiline"
+}
+export declare const MAX_NAME_LENGTH = 20;

package/dist/coze/source/form-extensions/components/output-tree/components/custom-tree-node/type.d.ts

@@ -0,0 +1,34 @@
+import { type RecursedParamDefinition } from '../../../../../../compat/base';
+import { type TreeNodeData } from '@douyinfe/semi-ui/lib/es/tree';
+import { type ChangeMode } from './constants';
+export type DefaultValueType = string | number | boolean | null;
+export type TreeNodeCustomData = TreeNodeData & Pick<RecursedParamDefinition, 'name' | 'type' | 'isQuote' | 'fixedValue' | 'quotedValue' | 'fieldRandomKey'> & {
+    key: string;
+    field: string;
+    isFirst: boolean;
+    isLast: boolean;
+    isSingle: boolean;
+    level: number;
+    helpLineShow: Array<boolean>;
+    children?: Array<TreeNodeCustomData>;
+    description?: string;
+    required?: boolean;
+    isPreset?: boolean;
+    enabled?: boolean;
+    defaultValue?: DefaultValueType;
+    schema?: Record<string, unknown>;
+};
+export interface CustomTreeNodeFuncRef {
+    data: TreeNodeCustomData;
+    level: number;
+    readonly: boolean;
+    onChange: (mode: ChangeMode, param: TreeNodeCustomData) => void;
+    onAppend: () => void;
+    onDelete: () => void;
+    onDeleteChildren: () => void;
+    onSelectChange: (val?: string | number | Array<unknown> | Record<string, unknown>) => void;
+}
+export interface ActiveMultiInfo {
+    activeMultiKey: string;
+    withNameError?: boolean;
+}

package/dist/coze/start-form.d.ts

@@ -0,0 +1,9 @@
+export declare function NodeStartForm({ schema, readOnly, onChange, onValidation }: {
+    schema: Record<string, unknown>;
+    readOnly?: boolean;
+    onChange?: (schema: Record<string, unknown>) => void;
+    onValidation?: (issues: {
+        path: string;
+        message: string;
+    }[]) => void;
+}): import("react").JSX.Element;

package/dist/coze/test-input.d.ts

@@ -0,0 +1,9 @@
+import { type Schema } from '../test-input-validation';
+export declare function WorkflowTestInput({ value, schema, onChange, onValidityChange, description, visibleFields }: {
+    value: string;
+    schema: Schema;
+    onChange: (value: string) => void;
+    onValidityChange?: (valid: boolean) => void;
+    description?: string;
+    visibleFields?: readonly string[];
+}): import("react").JSX.Element;

package/dist/coze/test-run-button.d.ts

@@ -0,0 +1,4 @@
+export declare function WorkflowTestRunButton({ disabled, onClick }: {
+    disabled?: boolean;
+    onClick: () => void;
+}): import("react").JSX.Element;

package/dist/coze/workflow-header.d.ts

@@ -0,0 +1,5 @@
+import type { ReactNode } from 'react';
+export declare function WorkflowHeader({ info, actions }: {
+    info: ReactNode;
+    actions: ReactNode;
+}): import("react").JSX.Element;

package/dist/designer.d.ts

@@ -0,0 +1,2 @@
+export { ArcBaseWorkflowDesigner } from './flowgram-designer';
+export type { ArcBaseWorkflowDesignerProps, WorkflowCanvasViewport } from './flowgram-designer';

package/dist/flowgram-designer.d.ts

@@ -0,0 +1,63 @@
+import type { NodeRunObservation as AutomationNodeRun } from './observation-types';
+import { type WorkflowThemeColors } from './theme';
+import { type ReactNode } from 'react';
+import type { WorkflowGraph, AutomationNodeSpec, WorkflowValidationIssue, AutomationModel } from '@fudanda/shared/automation';
+import { type WorkflowPromptKit } from './prompt-kit';
+import './styles.css';
+import './coze/styles.css';
+export interface ArcBaseWorkflowDesignerProps {
+    value: WorkflowGraph;
+    catalog: readonly AutomationNodeSpec[];
+    models?: readonly AutomationModel[];
+    onChange?: (graph: WorkflowGraph) => void;
+    readOnly?: boolean;
+    nodeRuns?: readonly AutomationNodeRun[];
+    sources?: readonly string[];
+    sourceSchemas?: Readonly<Record<string, Record<string, unknown>>>;
+    /** API/schedule trigger schema edited through props. Registered event schemas remain host-owned. */
+    onInputSchemaChange?: (schema: Record<string, unknown>) => void;
+    credentials?: readonly {
+        id: number;
+        name: string;
+        kind?: 'hmac' | 'bearer';
+    }[];
+    theme?: 'light' | 'dark';
+    /** Semantic palette from the host; isolated to this instance and its popups. */
+    themeColors?: WorkflowThemeColors;
+    height?: number | string;
+    /** Optional host-owned canvas preference; the designer never persists browser state. */
+    minimapVisible?: boolean;
+    onMinimapVisibleChange?: (visible: boolean) => void;
+    initialViewport?: WorkflowCanvasViewport;
+    onViewportChange?: (viewport: WorkflowCanvasViewport) => void;
+    interactionMode?: 'MOUSE' | 'PAD';
+    onInteractionModeChange?: (mode: 'MOUSE' | 'PAD') => void;
+    onNodeSelect?: (nodeId: string | null) => void;
+    /** Emits the durable record ID when a node/iteration with a result is selected. */
+    onNodeRunSelect?: (recordId: string) => void;
+    selectedNodeId?: string | null;
+    diagnostics?: readonly WorkflowValidationIssue[];
+    onValidationChange?: (issues: readonly WorkflowValidationIssue[]) => void;
+    toolbarExtra?: ReactNode;
+    /** Optional host test panel; supplied UI remains inside this instance's theme and popup boundary. */
+    sidePanel?: ReactNode;
+    /** Close host-supplied panels on Escape; no host state is read by the editor. */
+    onSidePanelClose?: () => void;
+    /** Host handles authenticated execution; independent designer only emits the selected node. */
+    onNodeTest?: (nodeId: string, iterations?: Readonly<Record<string, number>>) => void;
+    /** Request omitted durable data through the host; the designer never fetches. */
+    onNodeResultRequest?: (recordId: string) => void | Promise<void>;
+    promptKit?: WorkflowPromptKit;
+    breakpoints?: readonly string[];
+    breakpointPaths?: readonly (readonly string[])[];
+    onBreakpointChange?: (nodeId: string, enabled: boolean) => void;
+}
+export interface WorkflowCanvasViewport {
+    zoom: number;
+    scrollX: number;
+    scrollY: number;
+}
+export declare function NodeGlyph({ kind }: {
+    kind: string;
+}): import("react").JSX.Element;
+export declare function ArcBaseWorkflowDesigner(props: ArcBaseWorkflowDesignerProps): import("react").JSX.Element;

package/dist/graph-scope.d.ts

@@ -0,0 +1,78 @@
+import type { NodeRunObservation as AutomationNodeRun } from './observation-types';
+import type { WorkflowGraph, WorkflowNode, AutomationRun } from '@fudanda/shared/automation';
+/** Canvas IDs are transient. Persisted node IDs and references remain local to their graph. */
+export declare const canvasNodeId: (path: readonly string[], id: string) => string;
+export declare const bodyCanvasId: (id: string) => string;
+export declare const bodyCanvasType = "arcbase.body";
+export declare const annotationCanvasType = "arcbase.comment";
+export declare const annotationCanvasId: (path: readonly string[], id: string) => string;
+export declare function localNodeId(id: string): string;
+export declare const iterationSchema: {
+    type: string;
+    properties: {
+        item: {};
+        index: {
+            type: string;
+        };
+        variables: {
+            type: string;
+        };
+    };
+};
+export declare function nodeBody(node: WorkflowNode): WorkflowGraph | undefined;
+export declare function graphScopes(graph: WorkflowGraph, path?: readonly string[]): {
+    graph: WorkflowGraph;
+    path: readonly string[];
+}[];
+export declare function locateCanvasNode(graph: WorkflowGraph, id: string): {
+    graph: WorkflowGraph;
+    path: readonly string[];
+    node: WorkflowNode;
+} | undefined;
+export declare function runtimeNodeId(path: readonly string[], id: string, iterations: Readonly<Record<string, number>>): string;
+export declare function findNodeRun(runs: readonly AutomationNodeRun[] | undefined, id: string): AutomationNodeRun | undefined;
+export declare function replaceGraphScope(graph: WorkflowGraph, path: readonly string[], value: WorkflowGraph): WorkflowGraph;
+export declare function scopedNodeRuns(runs: readonly AutomationNodeRun[] | undefined, path: readonly string[], iterations: Readonly<Record<string, number>>): readonly AutomationNodeRun[] | undefined;
+/** DBOS record names locate a visible node and each enclosing iteration. */
+export declare function selectionFromRun(graph: WorkflowGraph, runId: string, path?: readonly string[], iterations?: Record<string, number>): {
+    nodeId: string;
+    iterations: Record<string, number>;
+} | undefined;
+export declare function resolveWorkflowSelection(graph: WorkflowGraph, id: string): {
+    graph: WorkflowGraph;
+    path: readonly string[];
+    node: WorkflowNode;
+} | undefined;
+/** Resolve a visible nested test target without executing its original predecessors. */
+export declare function workflowNodeTestTarget(graph: WorkflowGraph, id: string, iterations?: Readonly<Record<string, number>>, runs?: readonly AutomationNodeRun[]): {
+    graph: WorkflowGraph;
+    path: readonly string[];
+    node: WorkflowNode;
+    selection: {
+        nodeId: string;
+        path: string[];
+        iterationPath?: number[] | undefined;
+        context?: {
+            index: number;
+            item?: unknown;
+            variables: Record<string, unknown>;
+        } | undefined;
+    };
+    input: Record<string, unknown>;
+} | undefined;
+/** Only the selected isolated result belongs on the original draft canvas. */
+export declare function workflowNodeTestRuns(run?: {
+    nodes: AutomationNodeRun[];
+    nodeTest?: AutomationRun['nodeTest'];
+}): {
+    attempts: number;
+    dataOmitted?: boolean;
+    durationMs: number;
+    error: string;
+    preview?: import("@fudanda/shared/automation").AutomationRunPreview;
+    status: "pending" | "running" | "paused" | "succeeded" | "failed" | "skipped";
+    timing?: import("@fudanda/shared/automation").AutomationNodeTiming;
+    input: Record<string, unknown>;
+    output: Record<string, unknown>;
+    nodeId: string;
+}[] | undefined;

package/dist/header-shortcuts-BQZuNfpA.js

@@ -0,0 +1,6 @@
+//#region src/coze/compat/header-shortcuts.ts
+var e = class {
+	static action = "copy";
+}, t = class {};
+//#endregion
+export { e as WorkflowCopyShortcutsContribution, t as WorkflowPasteShortcutsContribution };

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { ArcBaseWorkflowDesigner } from './designer';
+export type { ArcBaseWorkflowDesignerProps, WorkflowCanvasViewport } from './designer';
+export { inventoryThresholdGraph } from './templates';
+export { resolveWorkflowSelection, workflowNodeTestTarget } from './graph-scope';
+export type { WorkflowPromptKit } from './prompt-kit';
+export type { WorkflowThemeColors } from './theme';