@workbench-kit/shell-react 0.0.2-prototype.0.2.40 → 0.0.2-prototype.0.2.43

package/src/field-remap/flow-adapter.ts

@@ -204,6 +204,8 @@ export function mappingToFlowGraph(input: {
     readonly sourceFieldId?: string;
     readonly targetSlotId?: string;
   }[];
+  /** Mapper-local positions for ephemeral drafts created by canvas drop. */
+  readonly draftPositions?: ReadonlyMap<string, { readonly x: number; readonly y: number }>;
   /** Document v2 n→m operators (display / multi-port Flow nodes). */
   readonly operators?: readonly MappingOperator[];
 }): { nodes: Node<FieldRemapFlowNodeData>[]; edges: Edge<FieldRemapFlowEdgeData>[] } {
@@ -221,7 +223,6 @@ export function mappingToFlowGraph(input: {
         schemaRole: 'Source schema',
         ports: sourcePorts,
       },
-      draggable: true,
     },
     {
       id: TARGET_OBJECT_NODE_ID,
@@ -233,7 +234,6 @@ export function mappingToFlowGraph(input: {
         schemaRole: 'Target schema',
         ports: targetPorts,
       },
-      draggable: true,
     },
   ];
 
@@ -272,7 +272,6 @@ export function mappingToFlowGraph(input: {
           transformId,
           label: definition?.label ?? transformId,
         },
-        draggable: true,
       });
     });
 
@@ -315,7 +314,7 @@ export function mappingToFlowGraph(input: {
     nodes.push({
       id: nodeId,
       type: 'fieldRemapDraftTransform',
-      position: {
+      position: input.draftPositions?.get(draft.localId) ?? {
         x: TRANSFORM_X,
         y: 40 + (input.edges.length + draftIndex) * TRANSFORM_ROW_GAP,
       },
@@ -327,7 +326,6 @@ export function mappingToFlowGraph(input: {
         sourceFieldId: draft.sourceFieldId,
         targetSlotId: draft.targetSlotId,
       },
-      draggable: true,
     });
 
     if (draft.sourceFieldId) {
@@ -372,7 +370,6 @@ export function mappingToFlowGraph(input: {
           inputFieldIds: operator.inputFieldIds,
           outputSlotId: operator.outputSlotId,
         },
-        draggable: true,
       });
       for (const fieldId of operator.inputFieldIds) {
         flowEdges.push({
@@ -410,7 +407,6 @@ export function mappingToFlowGraph(input: {
         inputFieldId: operator.inputFieldId,
         outputSlotIds: operator.outputSlotIds,
       },
-      draggable: true,
     });
     if (operator.inputFieldId) {
       flowEdges.push({
@@ -443,13 +439,82 @@ export function mappingToFlowGraph(input: {
  * Optional field/slot lookup for type-gated connects.
  * When omitted, only the topology allowlist is applied (tests / callers without shapes).
  */
+export type FieldRemapFlowConnectionInput = {
+  readonly source: string | null | undefined;
+  readonly target: string | null | undefined;
+  readonly sourceHandle?: string | null;
+  readonly targetHandle?: string | null;
+};
+
 export type IsValidFieldRemapFlowConnectionContext = {
   readonly sources: readonly SourceField[];
   readonly targets: readonly TargetSlot[];
   readonly edges: readonly MappingEdge[];
   readonly transforms: ValueTransformRegistry;
+  readonly drafts?: readonly {
+    readonly localId: string;
+    readonly transformId: string;
+    readonly sourceFieldId?: string;
+    readonly targetSlotId?: string;
+  }[];
 };
 
+export type FieldRemapFlowConnectionRejectionReason =
+  | 'incomplete-connection'
+  | 'unsupported-topology'
+  | 'missing-port-endpoint'
+  | 'missing-draft-endpoint'
+  | 'missing-transform-edge'
+  | 'missing-transform-step'
+  | 'missing-transform-definition'
+  | 'same-edge-transform-splice'
+  | 'transform-chain-limit'
+  | 'incompatible-port-types';
+
+export type FieldRemapFlowConnectionEvaluation =
+  | { readonly status: 'accepted' }
+  | { readonly status: 'rewire'; readonly impactedEdgeIds: readonly string[] }
+  | {
+      readonly status: 'rejected';
+      readonly reason: FieldRemapFlowConnectionRejectionReason;
+    };
+
+const acceptedConnection = { status: 'accepted' } as const;
+
+function rejectConnection(
+  reason: FieldRemapFlowConnectionRejectionReason,
+): FieldRemapFlowConnectionEvaluation {
+  return { status: 'rejected', reason };
+}
+
+function acceptOrRewire(impactedEdgeIds: readonly string[]): FieldRemapFlowConnectionEvaluation {
+  return impactedEdgeIds.length > 0 ? { status: 'rewire', impactedEdgeIds } : acceptedConnection;
+}
+
+function evaluatePortCompatibility(
+  context: Pick<IsValidFieldRemapFlowConnectionContext, 'transforms'>,
+  sourceType: SourceField['dataType'],
+  targetType: TargetSlot['dataType'],
+  transformIds: readonly string[],
+): FieldRemapFlowConnectionEvaluation | undefined {
+  if (!transformIds.every((transformId) => context.transforms.get(transformId) !== undefined)) {
+    return rejectConnection('missing-transform-definition');
+  }
+  return arePortsCompatible({ sourceType, targetType, transformIds, registry: context.transforms })
+    ? undefined
+    : rejectConnection('incompatible-port-types');
+}
+
+function targetRewireEdgeIds(
+  edges: readonly MappingEdge[],
+  targetSlotId: string,
+  excludedEdgeId?: string,
+): string[] {
+  return edges
+    .filter((edge) => edge.targetSlotId === targetSlotId && edge.id !== excludedEdgeId)
+    .map((edge) => edge.id);
+}
+
 function resolveConnectionPortIds(connection: {
   readonly source: string | null | undefined;
   readonly target: string | null | undefined;
@@ -490,26 +555,14 @@ function resolveConnectionPortIds(connection: {
  * mismatches (including transform-mediated chains on an existing target edge)
  * are rejected.
  */
-export function isValidFieldRemapFlowConnection(
-  connection: {
-    readonly source: string | null | undefined;
-    readonly target: string | null | undefined;
-    readonly sourceHandle?: string | null;
-    readonly targetHandle?: string | null;
-  },
-  context?: IsValidFieldRemapFlowConnectionContext & {
-    readonly drafts?: readonly {
-      readonly localId: string;
-      readonly transformId: string;
-      readonly sourceFieldId?: string;
-      readonly targetSlotId?: string;
-    }[];
-  },
-): boolean {
+export function evaluateFieldRemapFlowConnection(
+  connection: FieldRemapFlowConnectionInput,
+  context?: IsValidFieldRemapFlowConnectionContext,
+): FieldRemapFlowConnectionEvaluation {
   const source = connection.source;
   const target = connection.target;
   if (!source || !target) {
-    return false;
+    return rejectConnection('incomplete-connection');
   }
 
   const draftTargetId = parseDraftTransformNodeId(target);
@@ -517,39 +570,72 @@ export function isValidFieldRemapFlowConnection(
 
   if (source === SOURCE_OBJECT_NODE_ID && draftTargetId && connection.sourceHandle) {
     if (!context) {
-      return true;
+      return acceptedConnection;
     }
     const draft = context.drafts?.find((item) => item.localId === draftTargetId);
     if (!draft) {
-      return false;
+      return rejectConnection('missing-draft-endpoint');
     }
     const sourceField = findSourceField(context.sources, connection.sourceHandle);
-    return arePortsCompatible({
-      sourceType: sourceField?.dataType,
-      targetType: 'unknown',
-      transformIds: [draft.transformId],
-      registry: context.transforms,
-    });
+    if (!sourceField) {
+      return rejectConnection('missing-port-endpoint');
+    }
+    const targetSlot = draft.targetSlotId
+      ? findTargetSlot(context.targets, draft.targetSlotId)
+      : undefined;
+    if (draft.targetSlotId && !targetSlot) {
+      return rejectConnection('missing-draft-endpoint');
+    }
+    const rejection = evaluatePortCompatibility(
+      context,
+      sourceField.dataType,
+      targetSlot?.dataType ?? 'unknown',
+      [draft.transformId],
+    );
+    if (rejection) {
+      return rejection;
+    }
+    return acceptOrRewire(
+      draft.targetSlotId ? targetRewireEdgeIds(context.edges, draft.targetSlotId) : [],
+    );
+  }
+
+  if (source === SOURCE_OBJECT_NODE_ID && draftTargetId) {
+    return rejectConnection('incomplete-connection');
   }
 
   if (draftSourceId && target === TARGET_OBJECT_NODE_ID && connection.targetHandle) {
     if (!context) {
-      return true;
+      return acceptedConnection;
     }
     const draft = context.drafts?.find((item) => item.localId === draftSourceId);
     if (!draft) {
-      return false;
+      return rejectConnection('missing-draft-endpoint');
     }
-    const sourceType = draft.sourceFieldId
-      ? findSourceField(context.sources, draft.sourceFieldId)?.dataType
-      : undefined;
     const targetSlot = findTargetSlot(context.targets, connection.targetHandle);
-    return arePortsCompatible({
-      sourceType,
-      targetType: targetSlot?.dataType,
-      transformIds: [draft.transformId],
-      registry: context.transforms,
-    });
+    if (!targetSlot) {
+      return rejectConnection('missing-port-endpoint');
+    }
+    const sourceField = draft.sourceFieldId
+      ? findSourceField(context.sources, draft.sourceFieldId)
+      : undefined;
+    if (draft.sourceFieldId && !sourceField) {
+      return rejectConnection('missing-draft-endpoint');
+    }
+    const rejection = evaluatePortCompatibility(
+      context,
+      sourceField?.dataType,
+      targetSlot.dataType,
+      [draft.transformId],
+    );
+    if (rejection) {
+      return rejection;
+    }
+    return acceptOrRewire(targetRewireEdgeIds(context.edges, connection.targetHandle));
+  }
+
+  if (draftSourceId && target === TARGET_OBJECT_NODE_ID) {
+    return rejectConnection('incomplete-connection');
   }
 
   const xfTarget = parseTransformNodeId(target);
@@ -557,80 +643,109 @@ export function isValidFieldRemapFlowConnection(
 
   if (source === SOURCE_OBJECT_NODE_ID && xfTarget && connection.sourceHandle) {
     if (!context) {
-      return true;
+      return acceptedConnection;
     }
     const edge = context.edges.find((item) => item.id === xfTarget.mappingEdgeId);
     if (!edge) {
-      return false;
+      return rejectConnection('missing-transform-edge');
     }
     const chain = edge.transformIds ?? [];
     if (xfTarget.stepIndex >= chain.length) {
-      return false;
+      return rejectConnection('missing-transform-step');
     }
     const sourceField = findSourceField(context.sources, connection.sourceHandle);
     const targetSlot = findTargetSlot(context.targets, edge.targetSlotId);
-    return arePortsCompatible({
-      sourceType: sourceField?.dataType,
-      targetType: targetSlot?.dataType,
-      transformIds: chain.slice(xfTarget.stepIndex),
-      registry: context.transforms,
-    });
+    if (!sourceField || !targetSlot) {
+      return rejectConnection('missing-port-endpoint');
+    }
+    const retainedChain = chain.slice(xfTarget.stepIndex);
+    return (
+      evaluatePortCompatibility(
+        context,
+        sourceField.dataType,
+        targetSlot.dataType,
+        retainedChain,
+      ) ?? acceptedConnection
+    );
+  }
+
+  if (source === SOURCE_OBJECT_NODE_ID && xfTarget) {
+    return rejectConnection('incomplete-connection');
   }
 
   if (xfSource && target === TARGET_OBJECT_NODE_ID && connection.targetHandle) {
     if (!context) {
-      return true;
+      return acceptedConnection;
     }
     const edge = context.edges.find((item) => item.id === xfSource.mappingEdgeId);
     if (!edge) {
-      return false;
+      return rejectConnection('missing-transform-edge');
     }
     const chain = edge.transformIds ?? [];
     if (xfSource.stepIndex >= chain.length) {
-      return false;
+      return rejectConnection('missing-transform-step');
     }
     const sourceField = findSourceField(context.sources, edge.sourceFieldId);
     const targetSlot = findTargetSlot(context.targets, connection.targetHandle);
-    return arePortsCompatible({
-      sourceType: sourceField?.dataType,
-      targetType: targetSlot?.dataType,
-      transformIds: chain.slice(0, xfSource.stepIndex + 1),
-      registry: context.transforms,
-    });
+    if (!sourceField || !targetSlot) {
+      return rejectConnection('missing-port-endpoint');
+    }
+    const retainedChain = chain.slice(0, xfSource.stepIndex + 1);
+    const rejection = evaluatePortCompatibility(
+      context,
+      sourceField.dataType,
+      targetSlot.dataType,
+      retainedChain,
+    );
+    if (rejection) {
+      return rejection;
+    }
+    return acceptOrRewire(targetRewireEdgeIds(context.edges, connection.targetHandle, edge.id));
+  }
+
+  if (xfSource && target === TARGET_OBJECT_NODE_ID) {
+    return rejectConnection('incomplete-connection');
   }
 
   if (xfSource && xfTarget) {
     if (xfSource.mappingEdgeId === xfTarget.mappingEdgeId) {
-      return false;
+      return rejectConnection('same-edge-transform-splice');
     }
     if (!context) {
-      return true;
+      return acceptedConnection;
     }
     const edgeA = context.edges.find((item) => item.id === xfSource.mappingEdgeId);
     const edgeB = context.edges.find((item) => item.id === xfTarget.mappingEdgeId);
     if (!edgeA || !edgeB) {
-      return false;
+      return rejectConnection('missing-transform-edge');
     }
     const chainA = edgeA.transformIds ?? [];
     const chainB = edgeB.transformIds ?? [];
     if (xfSource.stepIndex >= chainA.length || xfTarget.stepIndex >= chainB.length) {
-      return false;
+      return rejectConnection('missing-transform-step');
     }
     const merged = [
       ...chainA.slice(0, xfSource.stepIndex + 1),
       ...chainB.slice(xfTarget.stepIndex),
     ];
     if (merged.length === 0 || merged.length > MAX_TRANSFORM_CHAIN) {
-      return false;
+      return rejectConnection('transform-chain-limit');
     }
     const sourceField = findSourceField(context.sources, edgeA.sourceFieldId);
     const targetSlot = findTargetSlot(context.targets, edgeB.targetSlotId);
-    return arePortsCompatible({
-      sourceType: sourceField?.dataType,
-      targetType: targetSlot?.dataType,
-      transformIds: merged,
-      registry: context.transforms,
-    });
+    if (!sourceField || !targetSlot) {
+      return rejectConnection('missing-port-endpoint');
+    }
+    const rejection = evaluatePortCompatibility(
+      context,
+      sourceField.dataType,
+      targetSlot.dataType,
+      merged,
+    );
+    if (rejection) {
+      return rejection;
+    }
+    return acceptOrRewire([edgeA.id]);
   }
 
   const topologyOk =
@@ -639,28 +754,44 @@ export function isValidFieldRemapFlowConnection(
     Boolean(connection.sourceHandle && connection.targetHandle);
 
   if (!topologyOk) {
-    return false;
+    return source === SOURCE_OBJECT_NODE_ID && target === TARGET_OBJECT_NODE_ID
+      ? rejectConnection('incomplete-connection')
+      : rejectConnection('unsupported-topology');
   }
 
   if (!context) {
-    return true;
+    return acceptedConnection;
   }
 
   const { sourceFieldId, targetSlotId } = resolveConnectionPortIds(connection);
   if (!sourceFieldId || !targetSlotId) {
-    return false;
+    return rejectConnection('incomplete-connection');
   }
 
   const sourceField = findSourceField(context.sources, sourceFieldId);
   const targetSlot = findTargetSlot(context.targets, targetSlotId);
+  if (!sourceField || !targetSlot) {
+    return rejectConnection('missing-port-endpoint');
+  }
   const existing = context.edges.find((edge) => edge.targetSlotId === targetSlotId);
+  const retainedChain = existing?.transformIds ?? [];
+  const rejection = evaluatePortCompatibility(
+    context,
+    sourceField.dataType,
+    targetSlot.dataType,
+    retainedChain,
+  );
+  if (rejection) {
+    return rejection;
+  }
+  return acceptOrRewire(targetRewireEdgeIds(context.edges, targetSlotId));
+}
 
-  return arePortsCompatible({
-    sourceType: sourceField?.dataType,
-    targetType: targetSlot?.dataType,
-    transformIds: existing?.transformIds,
-    registry: context.transforms,
-  });
+export function isValidFieldRemapFlowConnection(
+  connection: FieldRemapFlowConnectionInput,
+  context?: IsValidFieldRemapFlowConnectionContext,
+): boolean {
+  return evaluateFieldRemapFlowConnection(connection, context).status !== 'rejected';
 }
 
 /** Result of a persisted (non-draft) Flow connect that updates mapping edges. */
@@ -690,16 +821,13 @@ export function connectionToMappingEdge(input: {
   }
 
   const existing = input.existing.find((edge) => edge.targetSlotId === targetSlotId);
+  if (existing) {
+    return { ...existing, sourceFieldId, targetSlotId };
+  }
   return {
-    id: existing?.id ?? `e-${sourceFieldId}-${targetSlotId}-${Date.now()}`,
+    id: `e-${sourceFieldId}-${targetSlotId}-${Date.now()}`,
     sourceFieldId,
     targetSlotId,
-    ...(existing?.transformIds ? { transformIds: existing.transformIds } : {}),
-    ...(existing?.transformOptionSteps
-      ? { transformOptionSteps: existing.transformOptionSteps }
-      : {}),
-    ...(existing?.itemSourcePath ? { itemSourcePath: existing.itemSourcePath } : {}),
-    ...(existing?.itemEdges ? { itemEdges: existing.itemEdges } : {}),
   };
 }
 

package/src/field-remap/flow-ops.ts

@@ -28,6 +28,156 @@ export type FieldRemapSelection =
   | { readonly kind: 'operator'; readonly operatorId: string }
   | null;
 
+/** Mapper-local durable membership. It is intentionally not part of the public Flow props. */
+export type FieldRemapBulkSelectionRef =
+  | { readonly kind: 'edge'; readonly edgeId: string }
+  | { readonly kind: 'transformStep'; readonly edgeId: string; readonly stepIndex: number };
+
+export type FieldRemapSelectionGesture = 'plain' | 'toggle' | 'add';
+
+export function fieldRemapBulkSelectionKey(ref: FieldRemapBulkSelectionRef): string {
+  return ref.kind === 'edge'
+    ? `edge:${ref.edgeId}`
+    : `transformStep:${ref.edgeId}:${ref.stepIndex}`;
+}
+
+export function fieldRemapSelectionKey(selection: FieldRemapSelection): string {
+  if (selection === null) {
+    return 'none';
+  }
+  if (selection.kind === 'draft') {
+    return `draft:${selection.localId}`;
+  }
+  if (selection.kind === 'operator') {
+    return `operator:${selection.operatorId}`;
+  }
+  return fieldRemapBulkSelectionKey(selection);
+}
+
+export function asFieldRemapBulkSelectionRef(
+  selection: FieldRemapSelection,
+): FieldRemapBulkSelectionRef | undefined {
+  return selection?.kind === 'edge' || selection?.kind === 'transformStep' ? selection : undefined;
+}
+
+/** One semantic order shared by selection, stale reconciliation, deletion and focus. */
+export function listFieldRemapBulkSelectionRefs(
+  edges: readonly MappingEdge[],
+): FieldRemapBulkSelectionRef[] {
+  const refs: FieldRemapBulkSelectionRef[] = [];
+  for (const edge of edges) {
+    refs.push({ kind: 'edge', edgeId: edge.id });
+    for (let stepIndex = 0; stepIndex < (edge.transformIds?.length ?? 0); stepIndex += 1) {
+      refs.push({ kind: 'transformStep', edgeId: edge.id, stepIndex });
+    }
+  }
+  return refs;
+}
+
+export function normalizeFieldRemapBulkSelection(
+  edges: readonly MappingEdge[],
+  refs: readonly FieldRemapBulkSelectionRef[],
+): FieldRemapBulkSelectionRef[] {
+  const requested = new Set(refs.map(fieldRemapBulkSelectionKey));
+  return listFieldRemapBulkSelectionRefs(edges).filter((ref) =>
+    requested.has(fieldRemapBulkSelectionKey(ref)),
+  );
+}
+
+export function updateFieldRemapBulkSelection(input: {
+  readonly edges: readonly MappingEdge[];
+  readonly membership: readonly FieldRemapBulkSelectionRef[];
+  readonly primary: FieldRemapSelection;
+  readonly target: FieldRemapBulkSelectionRef;
+  readonly gesture: FieldRemapSelectionGesture;
+}): {
+  readonly membership: readonly FieldRemapBulkSelectionRef[];
+  readonly primary: FieldRemapSelection;
+} {
+  const targetKey = fieldRemapBulkSelectionKey(input.target);
+  const canonical = listFieldRemapBulkSelectionRefs(input.edges);
+  if (!canonical.some((ref) => fieldRemapBulkSelectionKey(ref) === targetKey)) {
+    return {
+      membership: normalizeFieldRemapBulkSelection(input.edges, input.membership),
+      primary: input.primary,
+    };
+  }
+
+  const primaryRef = asFieldRemapBulkSelectionRef(input.primary);
+  const primaryKey = primaryRef ? fieldRemapBulkSelectionKey(primaryRef) : undefined;
+  const primaryIsValid = primaryKey
+    ? canonical.some((ref) => fieldRemapBulkSelectionKey(ref) === primaryKey)
+    : false;
+  if (input.gesture === 'plain' || primaryKey === undefined || !primaryIsValid) {
+    return { membership: [input.target], primary: input.target };
+  }
+
+  const membership = normalizeFieldRemapBulkSelection(input.edges, input.membership);
+  const keys = new Set(membership.map(fieldRemapBulkSelectionKey));
+  if (input.gesture === 'add') {
+    keys.add(targetKey);
+  } else if (targetKey !== primaryKey) {
+    if (keys.has(targetKey)) {
+      keys.delete(targetKey);
+    } else {
+      keys.add(targetKey);
+    }
+  }
+  keys.add(primaryKey);
+
+  return {
+    membership: canonical.filter((ref) => keys.has(fieldRemapBulkSelectionKey(ref))),
+    primary: input.primary,
+  };
+}
+
+export type FieldRemapBulkDeletePlan =
+  | { readonly status: 'invalid' | 'unchanged' }
+  | { readonly status: 'changed'; readonly edges: readonly MappingEdge[] };
+
+/** Plan one immutable, all-or-nothing durable removal from one edge snapshot. */
+export function planFieldRemapBulkDelete(
+  edges: readonly MappingEdge[],
+  refs: readonly FieldRemapBulkSelectionRef[],
+): FieldRemapBulkDeletePlan {
+  if (refs.length === 0) {
+    return { status: 'unchanged' };
+  }
+
+  const validKeys = new Set(listFieldRemapBulkSelectionRefs(edges).map(fieldRemapBulkSelectionKey));
+  if (refs.some((ref) => !validKeys.has(fieldRemapBulkSelectionKey(ref)))) {
+    return { status: 'invalid' };
+  }
+
+  const selectedEdges = new Set(refs.filter((ref) => ref.kind === 'edge').map((ref) => ref.edgeId));
+  const selectedSteps = new Map<string, Set<number>>();
+  for (const ref of refs) {
+    if (ref.kind === 'transformStep' && !selectedEdges.has(ref.edgeId)) {
+      const indices = selectedSteps.get(ref.edgeId) ?? new Set<number>();
+      indices.add(ref.stepIndex);
+      selectedSteps.set(ref.edgeId, indices);
+    }
+  }
+
+  const nextEdges = edges
+    .filter((edge) => !selectedEdges.has(edge.id))
+    .map((edge) => {
+      const indices = selectedSteps.get(edge.id);
+      if (!indices) {
+        return edge;
+      }
+      const transformIds = (edge.transformIds ?? []).filter((_, index) => !indices.has(index));
+      const optionSteps = edge.transformOptionSteps?.filter((_, index) => !indices.has(index));
+      return {
+        ...edge,
+        transformIds: transformIds.length > 0 ? transformIds : undefined,
+        transformOptionSteps: resizeOptionSteps(optionSteps, transformIds.length),
+      };
+    });
+
+  return { status: 'changed', edges: nextEdges };
+}
+
 /**
  * Ephemeral place-then-wire transform. Not part of `FieldRemapDocument` until
  * both ports are bound and {@link finalizeDraftTransform} succeeds.