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

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);
+}

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),
+  };
+}