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

package/src/domain/mapping/resolveMappedValue.ts

@@ -1,96 +1,98 @@
-import type {
-  MappingEdge,
-  SourceField,
-  TransformContext,
-  ValueTransformRegistry,
-} from '../types.js';
-import { edgeItemTransformIds, edgeTransformIds } from '../document/mappingEdge.js';
-import { projectCollectionItems } from './pathUtils.js';
-import { applyTransformChain } from '../../registry/createValueTransformRegistry.js';
-import { BUILTIN_TRANSFORM_IDS } from '../../registry/builtinTransforms.js';
-import { resolveOptionSteps } from './transformOptions.js';
-import { flattenSourceFields } from './treeUtils.js';
-
-export { findTargetSlot, flattenSourceFields, flattenTargetSlots } from './treeUtils.js';
-
-export { projectCollectionItems, readObjectPath } from './pathUtils.js';
-
-export function findSourceField(
-  fields: readonly SourceField[],
-  fieldId: string,
-): SourceField | undefined {
-  return flattenSourceFields(fields).find((field) => field.id === fieldId);
-}
-
-/**
- * Resolve an edge against a live / sample source value.
- *
- * Apply order:
- * 1. Optional `itemSourcePath` projection (array of objects → projected array)
- * 2. Optional `itemTransformIds` per element (when the value is still an array)
- * 3. `transformIds` / legacy `transformId` on the whole value (including array reduces)
- *
- * Per-step options (`transformOptionSteps` / `itemTransformOptionSteps`) win when
- * present; otherwise shared `transformOptions` / `itemTransformOptions` apply to all steps.
- */
-export function resolveMappedValue(
-  edge: MappingEdge,
-  sourceValue: unknown,
-  registry: ValueTransformRegistry,
-  context: TransformContext = {},
-): unknown {
-  let current = edge.itemSourcePath
-    ? projectCollectionItems(sourceValue, edge.itemSourcePath)
-    : sourceValue;
-
-  const itemChain = edgeItemTransformIds(edge);
-  const itemSteps = resolveOptionSteps(
-    itemChain,
-    edge.itemTransformOptionSteps,
-    edge.itemTransformOptions,
-  );
-
-  if (itemChain.length > 0 && Array.isArray(current)) {
-    current = current.map((item) =>
-      applyTransformChain(registry, itemChain, item, context, itemSteps),
-    );
-  }
-
-  const chain = edgeTransformIds(edge);
-  if (chain.length === 0) {
-    const identity = registry.get(BUILTIN_TRANSFORM_IDS.identity);
-    return identity ? identity.apply(current, context) : current;
-  }
-
-  const valueSteps = resolveOptionSteps(chain, edge.transformOptionSteps, edge.transformOptions);
-  return applyTransformChain(registry, chain, current, context, valueSteps);
-}
-
-export function resolveEdgePreview(
-  edge: MappingEdge,
-  sources: readonly SourceField[],
-  registry: ValueTransformRegistry,
-  context: TransformContext = {},
-): unknown {
-  const field = findSourceField(sources, edge.sourceFieldId);
-  const sample =
-    context.sampleValue !== undefined ? context.sampleValue : (field?.sampleValue ?? context.now);
-  return resolveMappedValue(edge, sample, registry, {
-    ...context,
-    sampleValue: sample,
-  });
-}
-
-/** Resolve every edge into `{ targetSlotId, value }` for live preview panels. */
-export function resolveAllEdgePreviews(
-  edges: readonly MappingEdge[],
-  sources: readonly SourceField[],
-  registry: ValueTransformRegistry,
-  context: TransformContext = {},
-): ReadonlyArray<{ edgeId: string; targetSlotId: string; value: unknown }> {
-  return edges.map((edge) => ({
-    edgeId: edge.id,
-    targetSlotId: edge.targetSlotId,
-    value: resolveEdgePreview(edge, sources, registry, context),
-  }));
-}
+import type {
+  MappingEdge,
+  SourceField,
+  TransformContext,
+  ValueTransformRegistry,
+} from '../types.js';
+import { edgeItemTransformIds, edgeTransformIds } from '../document/mappingEdge.js';
+import { projectCollectionItems } from './pathUtils.js';
+import { applyTransformChain } from '../../registry/createValueTransformRegistry.js';
+import { BUILTIN_TRANSFORM_IDS } from '../../registry/builtinTransforms.js';
+import { resolveOptionSteps } from './transformOptions.js';
+import { flattenSourceFields } from './treeUtils.js';
+
+export { findTargetSlot, flattenSourceFields, flattenTargetSlots } from './treeUtils.js';
+
+export { projectCollectionItems, readObjectPath } from './pathUtils.js';
+
+export function findSourceField(
+  fields: readonly SourceField[],
+  fieldId: string,
+): SourceField | undefined {
+  return flattenSourceFields(fields).find((field) => field.id === fieldId);
+}
+
+/**
+ * Resolve an edge against a live / sample source value.
+ *
+ * Apply order:
+ * 1. Optional `itemSourcePath` projection (array of objects → projected array)
+ * 2. Optional `itemTransformIds` per element (when the value is still an array)
+ * 3. `transformIds` / legacy `transformId` on the whole value (including array reduces)
+ *
+ * Per-step options (`transformOptionSteps` / `itemTransformOptionSteps`) win when
+ * present; otherwise shared `transformOptions` / `itemTransformOptions` apply to all steps.
+ */
+export async function resolveMappedValue(
+  edge: MappingEdge,
+  sourceValue: unknown,
+  registry: ValueTransformRegistry,
+  context: TransformContext = {},
+): Promise<unknown> {
+  let current = edge.itemSourcePath
+    ? projectCollectionItems(sourceValue, edge.itemSourcePath)
+    : sourceValue;
+
+  const itemChain = edgeItemTransformIds(edge);
+  const itemSteps = resolveOptionSteps(
+    itemChain,
+    edge.itemTransformOptionSteps,
+    edge.itemTransformOptions,
+  );
+
+  if (itemChain.length > 0 && Array.isArray(current)) {
+    current = await Promise.all(
+      current.map((item) => applyTransformChain(registry, itemChain, item, context, itemSteps)),
+    );
+  }
+
+  const chain = edgeTransformIds(edge);
+  if (chain.length === 0) {
+    const identity = registry.get(BUILTIN_TRANSFORM_IDS.identity);
+    return identity ? await identity.apply(current, context) : current;
+  }
+
+  const valueSteps = resolveOptionSteps(chain, edge.transformOptionSteps, edge.transformOptions);
+  return applyTransformChain(registry, chain, current, context, valueSteps);
+}
+
+export async function resolveEdgePreview(
+  edge: MappingEdge,
+  sources: readonly SourceField[],
+  registry: ValueTransformRegistry,
+  context: TransformContext = {},
+): Promise<unknown> {
+  const field = findSourceField(sources, edge.sourceFieldId);
+  const sample =
+    context.sampleValue !== undefined ? context.sampleValue : (field?.sampleValue ?? context.now);
+  return resolveMappedValue(edge, sample, registry, {
+    ...context,
+    sampleValue: sample,
+  });
+}
+
+/** Resolve every edge into `{ targetSlotId, value }` for live preview panels. */
+export async function resolveAllEdgePreviews(
+  edges: readonly MappingEdge[],
+  sources: readonly SourceField[],
+  registry: ValueTransformRegistry,
+  context: TransformContext = {},
+): Promise<ReadonlyArray<{ edgeId: string; targetSlotId: string; value: unknown }>> {
+  return Promise.all(
+    edges.map(async (edge) => ({
+      edgeId: edge.id,
+      targetSlotId: edge.targetSlotId,
+      value: await resolveEdgePreview(edge, sources, registry, context),
+    })),
+  );
+}

package/src/domain/mapping/transformOptions.ts

@@ -1,184 +1,184 @@
-import type { TransformContext, TransformOptionField, ValueTransformRegistry } from '../types.js';
-
-/** Merge edge-local options over host `context.options` (edge wins). */
-export function contextWithEdgeOptions(
-  context: TransformContext,
-  edgeOptions: Readonly<Record<string, unknown>> | undefined,
-): TransformContext {
-  if (!edgeOptions || Object.keys(edgeOptions).length === 0) {
-    return context;
-  }
-  return {
-    ...context,
-    options: {
-      ...context.options,
-      ...edgeOptions,
-    },
-  };
-}
-
-/** Collect unique `optionFields` declared by transforms in a chain (later ids win per key). */
-export function collectOptionFields(
-  registry: ValueTransformRegistry,
-  transformIds: readonly string[],
-): TransformOptionField[] {
-  const byKey = new Map<string, TransformOptionField>();
-  for (const id of transformIds) {
-    const fields = registry.get(id)?.optionFields;
-    if (!fields) {
-      continue;
-    }
-    for (const field of fields) {
-      byKey.set(field.key, field);
-    }
-  }
-  return [...byKey.values()];
-}
-
-/** Option fields for a single chain step. */
-export function optionFieldsForStep(
-  registry: ValueTransformRegistry,
-  transformId: string | undefined,
-): TransformOptionField[] {
-  if (!transformId) {
-    return [];
-  }
-  return [...(registry.get(transformId)?.optionFields ?? [])];
-}
-
-/** Drop empty / undefined option bags when persisting edges. */
-export function sanitizeOptionRecord(
-  options: Readonly<Record<string, unknown>> | undefined,
-): Readonly<Record<string, unknown>> | undefined {
-  if (!options) {
-    return undefined;
-  }
-  const next: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(options)) {
-    if (value === undefined) {
-      continue;
-    }
-    next[key] = value;
-  }
-  return Object.keys(next).length > 0 ? next : undefined;
-}
-
-export function patchOptionRecord(
-  previous: Readonly<Record<string, unknown>> | undefined,
-  key: string,
-  value: unknown,
-): Readonly<Record<string, unknown>> | undefined {
-  return sanitizeOptionRecord({
-    ...previous,
-    [key]: value,
-  });
-}
-
-/**
- * Align / sanitize per-step option bags to `length`.
- * Returns `undefined` when every step is empty.
- */
-export function sanitizeOptionSteps(
-  steps: readonly (Readonly<Record<string, unknown>> | undefined)[] | undefined,
-  length: number,
-): readonly (Readonly<Record<string, unknown>> | undefined)[] | undefined {
-  if (length <= 0) {
-    return undefined;
-  }
-  const next: (Readonly<Record<string, unknown>> | undefined)[] = [];
-  let any = false;
-  for (let index = 0; index < length; index += 1) {
-    const sanitized = sanitizeOptionRecord(steps?.[index]);
-    next.push(sanitized);
-    if (sanitized) {
-      any = true;
-    }
-  }
-  return any ? next : undefined;
-}
-
-/**
- * Resolve per-step options for a transform chain.
- * Prefers `steps`; otherwise expands shared `transformOptions` to every step (apply-to-all).
- */
-export function resolveOptionSteps(
-  transformIds: readonly string[],
-  steps: readonly (Readonly<Record<string, unknown>> | undefined)[] | undefined,
-  shared: Readonly<Record<string, unknown>> | undefined,
-): (Readonly<Record<string, unknown>> | undefined)[] {
-  const length = transformIds.length;
-  if (length === 0) {
-    return [];
-  }
-  if (steps && steps.length > 0) {
-    return Array.from({ length }, (_, index) => sanitizeOptionRecord(steps[index]));
-  }
-  const bag = sanitizeOptionRecord(shared);
-  if (!bag) {
-    return Array.from({ length }, () => undefined);
-  }
-  return Array.from({ length }, () => bag);
-}
-
-/** Back-compat summary: first non-empty step bag (else undefined). */
-export function sharedOptionsFromSteps(
-  steps: readonly (Readonly<Record<string, unknown>> | undefined)[] | undefined,
-): Readonly<Record<string, unknown>> | undefined {
-  if (!steps) {
-    return undefined;
-  }
-  for (const step of steps) {
-    const sanitized = sanitizeOptionRecord(step);
-    if (sanitized) {
-      return sanitized;
-    }
-  }
-  return undefined;
-}
-
-/** Merge all step bags (later steps win) — useful for live format-sample chips. */
-export function mergeOptionSteps(
-  steps: readonly (Readonly<Record<string, unknown>> | undefined)[] | undefined,
-): Readonly<Record<string, unknown>> | undefined {
-  if (!steps || steps.length === 0) {
-    return undefined;
-  }
-  const merged: Record<string, unknown> = {};
-  for (const step of steps) {
-    if (!step) {
-      continue;
-    }
-    Object.assign(merged, step);
-  }
-  return sanitizeOptionRecord(merged);
-}
-
-export function patchOptionStep(
-  steps: readonly (Readonly<Record<string, unknown>> | undefined)[] | undefined,
-  length: number,
-  index: number,
-  key: string,
-  value: unknown,
-  sharedFallback?: Readonly<Record<string, unknown>>,
-): readonly (Readonly<Record<string, unknown>> | undefined)[] | undefined {
-  const base = resolveOptionSteps(
-    Array.from({ length }, () => ''),
-    steps,
-    sharedFallback,
-  );
-  const next = base.map((step, stepIndex) =>
-    stepIndex === index ? patchOptionRecord(step, key, value) : step,
-  );
-  return sanitizeOptionSteps(next, length);
-}
-
-export function resizeOptionSteps(
-  steps: readonly (Readonly<Record<string, unknown>> | undefined)[] | undefined,
-  length: number,
-): readonly (Readonly<Record<string, unknown>> | undefined)[] | undefined {
-  if (length <= 0) {
-    return undefined;
-  }
-  const next = Array.from({ length }, (_, index) => sanitizeOptionRecord(steps?.[index]));
-  return sanitizeOptionSteps(next, length);
-}
+import type { TransformContext, TransformOptionField, ValueTransformRegistry } from '../types.js';
+
+/** Merge edge-local options over host `context.options` (edge wins). */
+export function contextWithEdgeOptions(
+  context: TransformContext,
+  edgeOptions: Readonly<Record<string, unknown>> | undefined,
+): TransformContext {
+  if (!edgeOptions || Object.keys(edgeOptions).length === 0) {
+    return context;
+  }
+  return {
+    ...context,
+    options: {
+      ...context.options,
+      ...edgeOptions,
+    },
+  };
+}
+
+/** Collect unique `optionFields` declared by transforms in a chain (later ids win per key). */
+export function collectOptionFields(
+  registry: ValueTransformRegistry,
+  transformIds: readonly string[],
+): TransformOptionField[] {
+  const byKey = new Map<string, TransformOptionField>();
+  for (const id of transformIds) {
+    const fields = registry.get(id)?.optionFields;
+    if (!fields) {
+      continue;
+    }
+    for (const field of fields) {
+      byKey.set(field.key, field);
+    }
+  }
+  return [...byKey.values()];
+}
+
+/** Option fields for a single chain step. */
+export function optionFieldsForStep(
+  registry: ValueTransformRegistry,
+  transformId: string | undefined,
+): TransformOptionField[] {
+  if (!transformId) {
+    return [];
+  }
+  return [...(registry.get(transformId)?.optionFields ?? [])];
+}
+
+/** Drop empty / undefined option bags when persisting edges. */
+export function sanitizeOptionRecord(
+  options: Readonly<Record<string, unknown>> | undefined,
+): Readonly<Record<string, unknown>> | undefined {
+  if (!options) {
+    return undefined;
+  }
+  const next: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(options)) {
+    if (value === undefined) {
+      continue;
+    }
+    next[key] = value;
+  }
+  return Object.keys(next).length > 0 ? next : undefined;
+}
+
+export function patchOptionRecord(
+  previous: Readonly<Record<string, unknown>> | undefined,
+  key: string,
+  value: unknown,
+): Readonly<Record<string, unknown>> | undefined {
+  return sanitizeOptionRecord({
+    ...previous,
+    [key]: value,
+  });
+}
+
+/**
+ * Align / sanitize per-step option bags to `length`.
+ * Returns `undefined` when every step is empty.
+ */
+export function sanitizeOptionSteps(
+  steps: readonly (Readonly<Record<string, unknown>> | undefined)[] | undefined,
+  length: number,
+): readonly (Readonly<Record<string, unknown>> | undefined)[] | undefined {
+  if (length <= 0) {
+    return undefined;
+  }
+  const next: (Readonly<Record<string, unknown>> | undefined)[] = [];
+  let any = false;
+  for (let index = 0; index < length; index += 1) {
+    const sanitized = sanitizeOptionRecord(steps?.[index]);
+    next.push(sanitized);
+    if (sanitized) {
+      any = true;
+    }
+  }
+  return any ? next : undefined;
+}
+
+/**
+ * Resolve per-step options for a transform chain.
+ * Prefers `steps`; otherwise expands shared `transformOptions` to every step (apply-to-all).
+ */
+export function resolveOptionSteps(
+  transformIds: readonly string[],
+  steps: readonly (Readonly<Record<string, unknown>> | undefined)[] | undefined,
+  shared: Readonly<Record<string, unknown>> | undefined,
+): (Readonly<Record<string, unknown>> | undefined)[] {
+  const length = transformIds.length;
+  if (length === 0) {
+    return [];
+  }
+  if (steps && steps.length > 0) {
+    return Array.from({ length }, (_, index) => sanitizeOptionRecord(steps[index]));
+  }
+  const bag = sanitizeOptionRecord(shared);
+  if (!bag) {
+    return Array.from({ length }, () => undefined);
+  }
+  return Array.from({ length }, () => bag);
+}
+
+/** Back-compat summary: first non-empty step bag (else undefined). */
+export function sharedOptionsFromSteps(
+  steps: readonly (Readonly<Record<string, unknown>> | undefined)[] | undefined,
+): Readonly<Record<string, unknown>> | undefined {
+  if (!steps) {
+    return undefined;
+  }
+  for (const step of steps) {
+    const sanitized = sanitizeOptionRecord(step);
+    if (sanitized) {
+      return sanitized;
+    }
+  }
+  return undefined;
+}
+
+/** Merge all step bags (later steps win) — useful for live format-sample chips. */
+export function mergeOptionSteps(
+  steps: readonly (Readonly<Record<string, unknown>> | undefined)[] | undefined,
+): Readonly<Record<string, unknown>> | undefined {
+  if (!steps || steps.length === 0) {
+    return undefined;
+  }
+  const merged: Record<string, unknown> = {};
+  for (const step of steps) {
+    if (!step) {
+      continue;
+    }
+    Object.assign(merged, step);
+  }
+  return sanitizeOptionRecord(merged);
+}
+
+export function patchOptionStep(
+  steps: readonly (Readonly<Record<string, unknown>> | undefined)[] | undefined,
+  length: number,
+  index: number,
+  key: string,
+  value: unknown,
+  sharedFallback?: Readonly<Record<string, unknown>>,
+): readonly (Readonly<Record<string, unknown>> | undefined)[] | undefined {
+  const base = resolveOptionSteps(
+    Array.from({ length }, () => ''),
+    steps,
+    sharedFallback,
+  );
+  const next = base.map((step, stepIndex) =>
+    stepIndex === index ? patchOptionRecord(step, key, value) : step,
+  );
+  return sanitizeOptionSteps(next, length);
+}
+
+export function resizeOptionSteps(
+  steps: readonly (Readonly<Record<string, unknown>> | undefined)[] | undefined,
+  length: number,
+): readonly (Readonly<Record<string, unknown>> | undefined)[] | undefined {
+  if (length <= 0) {
+    return undefined;
+  }
+  const next = Array.from({ length }, (_, index) => sanitizeOptionRecord(steps?.[index]));
+  return sanitizeOptionSteps(next, length);
+}

package/src/domain/mapping/treeUtils.ts

@@ -1,32 +1,32 @@
-import type { SourceField, TargetSlot } from '../types.js';
-
-/** Flatten nested source fields depth-first. */
-export function flattenSourceFields(fields: readonly SourceField[]): SourceField[] {
-  const out: SourceField[] = [];
-  for (const field of fields) {
-    out.push(field);
-    if (field.children?.length) {
-      out.push(...flattenSourceFields(field.children));
-    }
-  }
-  return out;
-}
-
-/** Flatten nested target slots depth-first. */
-export function flattenTargetSlots(slots: readonly TargetSlot[]): TargetSlot[] {
-  const out: TargetSlot[] = [];
-  for (const slot of slots) {
-    out.push(slot);
-    if (slot.children?.length) {
-      out.push(...flattenTargetSlots(slot.children));
-    }
-  }
-  return out;
-}
-
-export function findTargetSlot(
-  slots: readonly TargetSlot[],
-  slotId: string,
-): TargetSlot | undefined {
-  return flattenTargetSlots(slots).find((slot) => slot.id === slotId);
-}
+import type { SourceField, TargetSlot } from '../types.js';
+
+/** Flatten nested source fields depth-first. */
+export function flattenSourceFields(fields: readonly SourceField[]): SourceField[] {
+  const out: SourceField[] = [];
+  for (const field of fields) {
+    out.push(field);
+    if (field.children?.length) {
+      out.push(...flattenSourceFields(field.children));
+    }
+  }
+  return out;
+}
+
+/** Flatten nested target slots depth-first. */
+export function flattenTargetSlots(slots: readonly TargetSlot[]): TargetSlot[] {
+  const out: TargetSlot[] = [];
+  for (const slot of slots) {
+    out.push(slot);
+    if (slot.children?.length) {
+      out.push(...flattenTargetSlots(slot.children));
+    }
+  }
+  return out;
+}
+
+export function findTargetSlot(
+  slots: readonly TargetSlot[],
+  slotId: string,
+): TargetSlot | undefined {
+  return flattenTargetSlots(slots).find((slot) => slot.id === slotId);
+}