@workbench-kit/field-remap 0.0.1-prototype.0 → 0.0.2-prototype.0.2.10

package/src/domain/shapes/conversionDefinition.ts

@@ -1,95 +1,95 @@
-import {
-  createFieldRemapDocument,
-  normalizeFieldRemapDocument,
-} from '../document/fieldRemapDocument.js';
-import type { MappingEdge, FieldRemapDocument } from '../types.js';
-
-/**
- * Managed conversion between one or more source shapes and a target shape.
- * Edges live in `document`; runtime uses `convertToShape` (not a method on a shape).
- */
-export interface ConversionDefinition {
-  readonly id: string;
-  readonly label?: string;
-  /** One or more managed source shape ids (multi-input). */
-  readonly sourceShapeIds: readonly string[];
-  readonly targetShapeId: string;
-  readonly document: FieldRemapDocument;
-}
-
-export interface ConversionRegistry {
-  register(conversion: ConversionDefinition): void;
-  get(id: string): ConversionDefinition | undefined;
-  list(): readonly ConversionDefinition[];
-}
-
-export interface DefineConversionInput {
-  readonly id: string;
-  readonly label?: string;
-  readonly sourceShapeIds: readonly string[];
-  readonly targetShapeId: string;
-  readonly document?: FieldRemapDocument;
-  readonly edges?: readonly MappingEdge[];
-}
-
-export function defineConversion(input: DefineConversionInput): ConversionDefinition {
-  const id = input.id.trim();
-  if (!id) {
-    throw new Error('ConversionDefinition.id must be a non-empty string.');
-  }
-  const sourceShapeIds = input.sourceShapeIds.map((item) => item.trim()).filter(Boolean);
-  if (sourceShapeIds.length === 0) {
-    throw new Error('ConversionDefinition.sourceShapeIds must include at least one shape id.');
-  }
-  const targetShapeId = input.targetShapeId.trim();
-  if (!targetShapeId) {
-    throw new Error('ConversionDefinition.targetShapeId must be a non-empty string.');
-  }
-
-  const document = input.document
-    ? normalizeFieldRemapDocument(input.document)
-    : createFieldRemapDocument(input.edges ?? []);
-
-  return {
-    id,
-    ...(input.label?.trim() ? { label: input.label.trim() } : {}),
-    sourceShapeIds,
-    targetShapeId,
-    document,
-  };
-}
-
-export function createConversionRegistry(
-  initial: readonly ConversionDefinition[] = [],
-): ConversionRegistry {
-  const byId = new Map<string, ConversionDefinition>();
-
-  const api: ConversionRegistry = {
-    register(conversion) {
-      const defined = defineConversion(conversion);
-      byId.set(defined.id, defined);
-    },
-    get(id) {
-      return byId.get(id.trim());
-    },
-    list() {
-      return [...byId.values()];
-    },
-  };
-
-  for (const conversion of initial) {
-    api.register(conversion);
-  }
-  return api;
-}
-
-/** Replace edges on a conversion (immutable). */
-export function withConversionEdges(
-  conversion: ConversionDefinition,
-  edges: readonly MappingEdge[],
-): ConversionDefinition {
-  return {
-    ...conversion,
-    document: createFieldRemapDocument(edges),
-  };
-}
+import {
+  createFieldRemapDocument,
+  normalizeFieldRemapDocument,
+} from '../document/fieldRemapDocument.js';
+import type { MappingEdge, FieldRemapDocument } from '../types.js';
+
+/**
+ * Managed conversion between one or more source shapes and a target shape.
+ * Edges live in `document`; runtime uses `convertToShape` (not a method on a shape).
+ */
+export interface ConversionDefinition {
+  readonly id: string;
+  readonly label?: string;
+  /** One or more managed source shape ids (multi-input). */
+  readonly sourceShapeIds: readonly string[];
+  readonly targetShapeId: string;
+  readonly document: FieldRemapDocument;
+}
+
+export interface ConversionRegistry {
+  register(conversion: ConversionDefinition): void;
+  get(id: string): ConversionDefinition | undefined;
+  list(): readonly ConversionDefinition[];
+}
+
+export interface DefineConversionInput {
+  readonly id: string;
+  readonly label?: string;
+  readonly sourceShapeIds: readonly string[];
+  readonly targetShapeId: string;
+  readonly document?: FieldRemapDocument;
+  readonly edges?: readonly MappingEdge[];
+}
+
+export function defineConversion(input: DefineConversionInput): ConversionDefinition {
+  const id = input.id.trim();
+  if (!id) {
+    throw new Error('ConversionDefinition.id must be a non-empty string.');
+  }
+  const sourceShapeIds = input.sourceShapeIds.map((item) => item.trim()).filter(Boolean);
+  if (sourceShapeIds.length === 0) {
+    throw new Error('ConversionDefinition.sourceShapeIds must include at least one shape id.');
+  }
+  const targetShapeId = input.targetShapeId.trim();
+  if (!targetShapeId) {
+    throw new Error('ConversionDefinition.targetShapeId must be a non-empty string.');
+  }
+
+  const document = input.document
+    ? normalizeFieldRemapDocument(input.document)
+    : createFieldRemapDocument(input.edges ?? []);
+
+  return {
+    id,
+    ...(input.label?.trim() ? { label: input.label.trim() } : {}),
+    sourceShapeIds,
+    targetShapeId,
+    document,
+  };
+}
+
+export function createConversionRegistry(
+  initial: readonly ConversionDefinition[] = [],
+): ConversionRegistry {
+  const byId = new Map<string, ConversionDefinition>();
+
+  const api: ConversionRegistry = {
+    register(conversion) {
+      const defined = defineConversion(conversion);
+      byId.set(defined.id, defined);
+    },
+    get(id) {
+      return byId.get(id.trim());
+    },
+    list() {
+      return [...byId.values()];
+    },
+  };
+
+  for (const conversion of initial) {
+    api.register(conversion);
+  }
+  return api;
+}
+
+/** Replace edges on a conversion (immutable). */
+export function withConversionEdges(
+  conversion: ConversionDefinition,
+  edges: readonly MappingEdge[],
+): ConversionDefinition {
+  return {
+    ...conversion,
+    document: createFieldRemapDocument(edges),
+  };
+}

package/src/domain/shapes/convertMappedInputs.ts

@@ -0,0 +1,158 @@
+import { applyMappingOperators, normalizeMappingOperators } from '../mapping/mappingOperators.js';
+import { flattenSourceFields } from '../mapping/treeUtils.js';
+import type {
+  MappingEdge,
+  MappingOperator,
+  SourceField,
+  TargetSlot,
+  ValueTransformRegistry,
+} from '../types.js';
+import { defineConversion, withConversionEdges } from './conversionDefinition.js';
+import { attachShapeIdToSourceFields, defineDataShape } from './dataShape.js';
+import { convertToShape, type ConvertToShapeResult } from './convertToShape.js';
+
+export interface ConvertMappedInputsInput {
+  readonly sources: readonly SourceField[];
+  readonly targets: readonly TargetSlot[];
+  readonly edges: readonly MappingEdge[];
+  readonly operators?: readonly MappingOperator[];
+  /**
+   * Named input bags keyed by source shape id (same contract as `convertToShape`).
+   * When sources omit `shapeId`, bags should use the resolved primary source shape id
+   * (default `source`).
+   */
+  readonly inputs: Readonly<Record<string, unknown>>;
+  readonly transforms: ValueTransformRegistry;
+  readonly signal?: AbortSignal;
+  /** Override inferred source shape ids (order preserved for conversion). */
+  readonly sourceShapeIds?: readonly string[];
+  readonly targetShapeId?: string;
+  readonly sourceLabel?: string;
+  readonly targetLabel?: string;
+}
+
+function collectSourceShapeIds(sources: readonly SourceField[]): string[] {
+  const ids: string[] = [];
+  const seen = new Set<string>();
+  for (const field of flattenSourceFields(sources)) {
+    const shapeId = field.shapeId?.trim();
+    if (!shapeId || seen.has(shapeId)) {
+      continue;
+    }
+    seen.add(shapeId);
+    ids.push(shapeId);
+  }
+  return ids;
+}
+
+function filterSourceTreeByShapeId(
+  fields: readonly SourceField[],
+  shapeId: string,
+  treatMissingAsMatch: boolean,
+): SourceField[] {
+  const next: SourceField[] = [];
+  for (const field of fields) {
+    const fieldShapeId = field.shapeId?.trim();
+    const children = field.children
+      ? filterSourceTreeByShapeId(field.children, shapeId, treatMissingAsMatch)
+      : undefined;
+    const selfMatches =
+      fieldShapeId === shapeId ||
+      (treatMissingAsMatch && (fieldShapeId === undefined || fieldShapeId === ''));
+    if (selfMatches || (children && children.length > 0)) {
+      next.push({
+        ...field,
+        shapeId,
+        ...(children ? { children } : {}),
+      });
+    }
+  }
+  return next;
+}
+
+/**
+ * Host-friendly evaluate path for persisted `MappingEdge` graphs (including transform
+ * chains and optional n→m operators) without requiring a full `FieldRemapDocument`.
+ *
+ * Same semantics as the shell panel preview: `convertToShape` then
+ * `applyMappingOperators`. Prefer this when the host catalog stores edges (+ optional
+ * operators) separately from kit document JSON.
+ */
+export async function convertMappedInputs(
+  input: ConvertMappedInputsInput,
+): Promise<ConvertToShapeResult> {
+  const inferredSourceIds = collectSourceShapeIds(input.sources);
+  const sourceShapeIds =
+    input.sourceShapeIds && input.sourceShapeIds.length > 0
+      ? [...input.sourceShapeIds]
+      : inferredSourceIds.length > 0
+        ? inferredSourceIds
+        : ['source'];
+  const targetShapeId = input.targetShapeId?.trim() || 'target';
+  const primarySourceId = sourceShapeIds[0]!;
+  const needsStamp = inferredSourceIds.length === 0;
+
+  const stampedSources = needsStamp
+    ? attachShapeIdToSourceFields(input.sources, primarySourceId)
+    : input.sources;
+
+  const sourceShapes = sourceShapeIds.map((shapeId) =>
+    defineDataShape({
+      id: shapeId,
+      label: input.sourceLabel ?? shapeId,
+      role: 'source',
+      fields:
+        sourceShapeIds.length === 1
+          ? stampedSources
+          : filterSourceTreeByShapeId(stampedSources, shapeId, shapeId === primarySourceId),
+    }),
+  );
+
+  const shapes = [
+    ...sourceShapes,
+    defineDataShape({
+      id: targetShapeId,
+      label: input.targetLabel ?? targetShapeId,
+      role: 'target',
+      fields: input.targets,
+    }),
+  ];
+
+  const conversion = withConversionEdges(
+    defineConversion({
+      id: `${primarySourceId}→${targetShapeId}`,
+      sourceShapeIds,
+      targetShapeId,
+      edges: [],
+    }),
+    input.edges,
+  );
+
+  const converted = await convertToShape({
+    conversion,
+    shapes,
+    inputs: input.inputs,
+    transforms: input.transforms,
+    signal: input.signal,
+  });
+
+  const operators = normalizeMappingOperators(input.operators);
+  if (!operators?.length) {
+    return converted;
+  }
+
+  const merged = await applyMappingOperators({
+    operators,
+    sources: stampedSources,
+    targets: input.targets,
+    inputs: input.inputs,
+    transforms: input.transforms,
+    output: converted.output,
+    signal: input.signal,
+  });
+
+  return {
+    output: merged.output,
+    slots: converted.slots,
+  };
+}