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

package/src/domain/document/mappingEdge.ts

@@ -1,136 +1,136 @@
-import {
-  canonicalizeTransformId,
-  IDENTITY_TRANSFORM_ID,
-  MAX_TRANSFORM_CHAIN,
-} from '../constants.js';
-import {
-  sanitizeOptionRecord,
-  sanitizeOptionSteps,
-  sharedOptionsFromSteps,
-} from '../mapping/transformOptions.js';
-import type { MappingEdge } from '../types.js';
-
-export { MAX_TRANSFORM_CHAIN } from '../constants.js';
-
-function sanitizeTransformIds(ids: readonly string[] | undefined): string[] {
-  const cleaned = ids
-    ?.map((id) => canonicalizeTransformId(id))
-    .filter((id) => id.length > 0 && id !== IDENTITY_TRANSFORM_ID);
-  if (!cleaned || cleaned.length === 0) {
-    return [];
-  }
-  return cleaned.slice(0, MAX_TRANSFORM_CHAIN);
-}
-
-/**
- * Resolve the effective transform chain for an edge.
- * Prefers `transformIds`; falls back to legacy `transformId`.
- * Identity / empty / null → `[]` (pass-through).
- */
-export function edgeTransformIds(edge: MappingEdge): string[] {
-  const fromList = sanitizeTransformIds(edge.transformIds);
-  if (fromList.length > 0) {
-    return fromList;
-  }
-
-  const legacy = edge.transformId ? canonicalizeTransformId(edge.transformId) : '';
-  if (legacy && legacy !== IDENTITY_TRANSFORM_ID) {
-    return [legacy];
-  }
-
-  return [];
-}
-
-/** Per-item transform chain applied after optional `itemSourcePath` projection. */
-export function edgeItemTransformIds(edge: MappingEdge): string[] {
-  return sanitizeTransformIds(edge.itemTransformIds);
-}
-
-/**
- * Normalize an edge to the `transformIds` model while keeping `transformId`
- * as the first chain step (or `null`) for older hosts.
- *
- * Option bags:
- * - Prefer `transformOptionSteps` when present (aligned to chain length).
- * - Keep `transformOptions` as the first non-empty step (or the legacy shared bag).
- * - Same rules for `itemTransformOptionSteps` / `itemTransformOptions`.
- */
-export function normalizeMappingEdge(edge: MappingEdge): MappingEdge {
-  const ids = edgeTransformIds(edge);
-  const itemIds = edgeItemTransformIds(edge);
-  const itemSourcePath = edge.itemSourcePath?.trim() || undefined;
-  const itemEdges =
-    edge.itemEdges && edge.itemEdges.length > 0
-      ? edge.itemEdges.map((child) => {
-          // One collection level — drop nested list contexts on children.
-          const { itemEdges: _nested, ...rest } = child;
-          return normalizeMappingEdge(rest);
-        })
-      : undefined;
-
-  const transformOptionSteps = sanitizeOptionSteps(edge.transformOptionSteps, ids.length);
-  const transformOptions =
-    sharedOptionsFromSteps(transformOptionSteps) ?? sanitizeOptionRecord(edge.transformOptions);
-
-  const itemTransformOptionSteps = sanitizeOptionSteps(
-    edge.itemTransformOptionSteps,
-    itemIds.length,
-  );
-  const itemTransformOptions =
-    sharedOptionsFromSteps(itemTransformOptionSteps) ??
-    sanitizeOptionRecord(edge.itemTransformOptions);
-
-  return {
-    id: edge.id,
-    sourceFieldId: edge.sourceFieldId,
-    targetSlotId: edge.targetSlotId,
-    transformIds: ids.length > 0 ? ids : undefined,
-    transformId: ids[0] ?? null,
-    ...(transformOptionSteps ? { transformOptionSteps } : {}),
-    ...(transformOptions ? { transformOptions } : {}),
-    ...(itemSourcePath && !itemEdges ? { itemSourcePath } : {}),
-    ...(itemIds.length > 0 && !itemEdges ? { itemTransformIds: itemIds } : {}),
-    ...(itemTransformOptionSteps && !itemEdges ? { itemTransformOptionSteps } : {}),
-    ...(itemTransformOptions && !itemEdges ? { itemTransformOptions } : {}),
-    ...(itemEdges ? { itemEdges } : {}),
-  };
-}
-
-export function normalizeMappingEdges(edges: readonly MappingEdge[]): MappingEdge[] {
-  return edges.map(normalizeMappingEdge);
-}
-
-/** Build a normalized edge from wire / assign actions. */
-export function createMappingEdge(input: {
-  readonly id: string;
-  readonly sourceFieldId: string;
-  readonly targetSlotId: string;
-  readonly transformIds?: readonly string[];
-  /** Legacy single id; ignored when `transformIds` is provided. */
-  readonly transformId?: string | null;
-  readonly transformOptionSteps?: readonly (Readonly<Record<string, unknown>> | undefined)[];
-  readonly transformOptions?: Readonly<Record<string, unknown>>;
-  /** Optional per-item projection path for array mappings. */
-  readonly itemSourcePath?: string;
-  /** Optional per-item transform chain after projection. */
-  readonly itemTransformIds?: readonly string[];
-  readonly itemTransformOptionSteps?: readonly (Readonly<Record<string, unknown>> | undefined)[];
-  readonly itemTransformOptions?: Readonly<Record<string, unknown>>;
-  /** List-context child edges for array-of-object → array-of-object. */
-  readonly itemEdges?: readonly MappingEdge[];
-}): MappingEdge {
-  return normalizeMappingEdge({
-    id: input.id,
-    sourceFieldId: input.sourceFieldId,
-    targetSlotId: input.targetSlotId,
-    transformIds: input.transformIds,
-    transformId: input.transformId,
-    transformOptionSteps: input.transformOptionSteps,
-    transformOptions: input.transformOptions,
-    itemSourcePath: input.itemSourcePath,
-    itemTransformIds: input.itemTransformIds,
-    itemTransformOptionSteps: input.itemTransformOptionSteps,
-    itemTransformOptions: input.itemTransformOptions,
-    itemEdges: input.itemEdges,
-  });
-}
+import {
+  canonicalizeTransformId,
+  IDENTITY_TRANSFORM_ID,
+  MAX_TRANSFORM_CHAIN,
+} from '../constants.js';
+import {
+  sanitizeOptionRecord,
+  sanitizeOptionSteps,
+  sharedOptionsFromSteps,
+} from '../mapping/transformOptions.js';
+import type { MappingEdge } from '../types.js';
+
+export { MAX_TRANSFORM_CHAIN } from '../constants.js';
+
+function sanitizeTransformIds(ids: readonly string[] | undefined): string[] {
+  const cleaned = ids
+    ?.map((id) => canonicalizeTransformId(id))
+    .filter((id) => id.length > 0 && id !== IDENTITY_TRANSFORM_ID);
+  if (!cleaned || cleaned.length === 0) {
+    return [];
+  }
+  return cleaned.slice(0, MAX_TRANSFORM_CHAIN);
+}
+
+/**
+ * Resolve the effective transform chain for an edge.
+ * Prefers `transformIds`; falls back to legacy `transformId`.
+ * Identity / empty / null → `[]` (pass-through).
+ */
+export function edgeTransformIds(edge: MappingEdge): string[] {
+  const fromList = sanitizeTransformIds(edge.transformIds);
+  if (fromList.length > 0) {
+    return fromList;
+  }
+
+  const legacy = edge.transformId ? canonicalizeTransformId(edge.transformId) : '';
+  if (legacy && legacy !== IDENTITY_TRANSFORM_ID) {
+    return [legacy];
+  }
+
+  return [];
+}
+
+/** Per-item transform chain applied after optional `itemSourcePath` projection. */
+export function edgeItemTransformIds(edge: MappingEdge): string[] {
+  return sanitizeTransformIds(edge.itemTransformIds);
+}
+
+/**
+ * Normalize an edge to the `transformIds` model while keeping `transformId`
+ * as the first chain step (or `null`) for older hosts.
+ *
+ * Option bags:
+ * - Prefer `transformOptionSteps` when present (aligned to chain length).
+ * - Keep `transformOptions` as the first non-empty step (or the legacy shared bag).
+ * - Same rules for `itemTransformOptionSteps` / `itemTransformOptions`.
+ */
+export function normalizeMappingEdge(edge: MappingEdge): MappingEdge {
+  const ids = edgeTransformIds(edge);
+  const itemIds = edgeItemTransformIds(edge);
+  const itemSourcePath = edge.itemSourcePath?.trim() || undefined;
+  const itemEdges =
+    edge.itemEdges && edge.itemEdges.length > 0
+      ? edge.itemEdges.map((child) => {
+          // One collection level — drop nested list contexts on children.
+          const { itemEdges: _nested, ...rest } = child;
+          return normalizeMappingEdge(rest);
+        })
+      : undefined;
+
+  const transformOptionSteps = sanitizeOptionSteps(edge.transformOptionSteps, ids.length);
+  const transformOptions =
+    sharedOptionsFromSteps(transformOptionSteps) ?? sanitizeOptionRecord(edge.transformOptions);
+
+  const itemTransformOptionSteps = sanitizeOptionSteps(
+    edge.itemTransformOptionSteps,
+    itemIds.length,
+  );
+  const itemTransformOptions =
+    sharedOptionsFromSteps(itemTransformOptionSteps) ??
+    sanitizeOptionRecord(edge.itemTransformOptions);
+
+  return {
+    id: edge.id,
+    sourceFieldId: edge.sourceFieldId,
+    targetSlotId: edge.targetSlotId,
+    transformIds: ids.length > 0 ? ids : undefined,
+    transformId: ids[0] ?? null,
+    ...(transformOptionSteps ? { transformOptionSteps } : {}),
+    ...(transformOptions ? { transformOptions } : {}),
+    ...(itemSourcePath && !itemEdges ? { itemSourcePath } : {}),
+    ...(itemIds.length > 0 && !itemEdges ? { itemTransformIds: itemIds } : {}),
+    ...(itemTransformOptionSteps && !itemEdges ? { itemTransformOptionSteps } : {}),
+    ...(itemTransformOptions && !itemEdges ? { itemTransformOptions } : {}),
+    ...(itemEdges ? { itemEdges } : {}),
+  };
+}
+
+export function normalizeMappingEdges(edges: readonly MappingEdge[]): MappingEdge[] {
+  return edges.map(normalizeMappingEdge);
+}
+
+/** Build a normalized edge from wire / assign actions. */
+export function createMappingEdge(input: {
+  readonly id: string;
+  readonly sourceFieldId: string;
+  readonly targetSlotId: string;
+  readonly transformIds?: readonly string[];
+  /** Legacy single id; ignored when `transformIds` is provided. */
+  readonly transformId?: string | null;
+  readonly transformOptionSteps?: readonly (Readonly<Record<string, unknown>> | undefined)[];
+  readonly transformOptions?: Readonly<Record<string, unknown>>;
+  /** Optional per-item projection path for array mappings. */
+  readonly itemSourcePath?: string;
+  /** Optional per-item transform chain after projection. */
+  readonly itemTransformIds?: readonly string[];
+  readonly itemTransformOptionSteps?: readonly (Readonly<Record<string, unknown>> | undefined)[];
+  readonly itemTransformOptions?: Readonly<Record<string, unknown>>;
+  /** List-context child edges for array-of-object → array-of-object. */
+  readonly itemEdges?: readonly MappingEdge[];
+}): MappingEdge {
+  return normalizeMappingEdge({
+    id: input.id,
+    sourceFieldId: input.sourceFieldId,
+    targetSlotId: input.targetSlotId,
+    transformIds: input.transformIds,
+    transformId: input.transformId,
+    transformOptionSteps: input.transformOptionSteps,
+    transformOptions: input.transformOptions,
+    itemSourcePath: input.itemSourcePath,
+    itemTransformIds: input.itemTransformIds,
+    itemTransformOptionSteps: input.itemTransformOptionSteps,
+    itemTransformOptions: input.itemTransformOptions,
+    itemEdges: input.itemEdges,
+  });
+}

package/src/domain/ingest/sourceFieldsFromPlainObject.ts

@@ -1,103 +1,103 @@
-import { isPlainObject } from '../mapping/pathUtils.js';
-import type { FieldDataType, SourceField } from '../types.js';
-
-export interface SourceFieldsFromPlainObjectOptions {
-  /** Prefix for generated field ids (default `src`). */
-  readonly idPrefix?: string;
-  /** Max nesting depth for object children (default 4). */
-  readonly maxDepth?: number;
-}
-
-function inferDataType(value: unknown): FieldDataType {
-  if (value === null || value === undefined) {
-    return 'unknown';
-  }
-  if (typeof value === 'string') {
-    return 'string';
-  }
-  if (typeof value === 'number' && Number.isFinite(value)) {
-    return 'number';
-  }
-  if (typeof value === 'boolean') {
-    return 'boolean';
-  }
-  if (value instanceof Date && !Number.isNaN(value.getTime())) {
-    return 'datetime';
-  }
-  if (Array.isArray(value)) {
-    return 'array';
-  }
-  if (isPlainObject(value)) {
-    return 'object';
-  }
-  return 'unknown';
-}
-
-function fieldFromEntry(
-  key: string,
-  value: unknown,
-  path: string,
-  idPrefix: string,
-  depth: number,
-  maxDepth: number,
-): SourceField {
-  const id = path ? `${idPrefix}.${path}` : `${idPrefix}.${key}`;
-  const dataType = inferDataType(value);
-  const base: SourceField = {
-    id,
-    label: key,
-    path,
-    dataType,
-    sampleValue: value,
-  };
-
-  if (depth >= maxDepth) {
-    return base;
-  }
-
-  if (isPlainObject(value)) {
-    const children = Object.entries(value).map(([childKey, childValue]) =>
-      fieldFromEntry(
-        childKey,
-        childValue,
-        path ? `${path}.${childKey}` : childKey,
-        idPrefix,
-        depth + 1,
-        maxDepth,
-      ),
-    );
-    return children.length > 0 ? { ...base, children } : base;
-  }
-
-  if (Array.isArray(value) && value.length > 0 && isPlainObject(value[0])) {
-    const sampleItem = value[0] as Record<string, unknown>;
-    const children = Object.entries(sampleItem).map(([childKey, childValue]) =>
-      fieldFromEntry(childKey, childValue, childKey, `${id}.item`, depth + 1, maxDepth),
-    );
-    return children.length > 0 ? { ...base, children } : base;
-  }
-
-  return base;
-}
-
-/**
- * Infer a shallow/nested `SourceField` tree from a plain sample object.
- * Useful for demos and hosts that have a sample payload but no formal schema.
- *
- * - Top-level keys become root fields.
- * - Nested plain objects become `children` (up to `maxDepth`).
- * - Arrays of objects expose item-key children for projection pickers.
- */
-export function sourceFieldsFromPlainObject(
-  sample: unknown,
-  options: SourceFieldsFromPlainObjectOptions = {},
-): SourceField[] {
-  if (!isPlainObject(sample)) {
-    return [];
-  }
-  const idPrefix = options.idPrefix?.trim() || 'src';
-  const maxDepth = Math.max(0, options.maxDepth ?? 4);
-  return Object.entries(sample).map(([key, value]) =>
-    fieldFromEntry(key, value, key, idPrefix, 0, maxDepth),
-  );
-}
+import { isPlainObject } from '../mapping/pathUtils.js';
+import type { FieldDataType, SourceField } from '../types.js';
+
+export interface SourceFieldsFromPlainObjectOptions {
+  /** Prefix for generated field ids (default `src`). */
+  readonly idPrefix?: string;
+  /** Max nesting depth for object children (default 4). */
+  readonly maxDepth?: number;
+}
+
+function inferDataType(value: unknown): FieldDataType {
+  if (value === null || value === undefined) {
+    return 'unknown';
+  }
+  if (typeof value === 'string') {
+    return 'string';
+  }
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return 'number';
+  }
+  if (typeof value === 'boolean') {
+    return 'boolean';
+  }
+  if (value instanceof Date && !Number.isNaN(value.getTime())) {
+    return 'datetime';
+  }
+  if (Array.isArray(value)) {
+    return 'array';
+  }
+  if (isPlainObject(value)) {
+    return 'object';
+  }
+  return 'unknown';
+}
+
+function fieldFromEntry(
+  key: string,
+  value: unknown,
+  path: string,
+  idPrefix: string,
+  depth: number,
+  maxDepth: number,
+): SourceField {
+  const id = path ? `${idPrefix}.${path}` : `${idPrefix}.${key}`;
+  const dataType = inferDataType(value);
+  const base: SourceField = {
+    id,
+    label: key,
+    path,
+    dataType,
+    sampleValue: value,
+  };
+
+  if (depth >= maxDepth) {
+    return base;
+  }
+
+  if (isPlainObject(value)) {
+    const children = Object.entries(value).map(([childKey, childValue]) =>
+      fieldFromEntry(
+        childKey,
+        childValue,
+        path ? `${path}.${childKey}` : childKey,
+        idPrefix,
+        depth + 1,
+        maxDepth,
+      ),
+    );
+    return children.length > 0 ? { ...base, children } : base;
+  }
+
+  if (Array.isArray(value) && value.length > 0 && isPlainObject(value[0])) {
+    const sampleItem = value[0] as Record<string, unknown>;
+    const children = Object.entries(sampleItem).map(([childKey, childValue]) =>
+      fieldFromEntry(childKey, childValue, childKey, `${id}.item`, depth + 1, maxDepth),
+    );
+    return children.length > 0 ? { ...base, children } : base;
+  }
+
+  return base;
+}
+
+/**
+ * Infer a shallow/nested `SourceField` tree from a plain sample object.
+ * Useful for demos and hosts that have a sample payload but no formal schema.
+ *
+ * - Top-level keys become root fields.
+ * - Nested plain objects become `children` (up to `maxDepth`).
+ * - Arrays of objects expose item-key children for projection pickers.
+ */
+export function sourceFieldsFromPlainObject(
+  sample: unknown,
+  options: SourceFieldsFromPlainObjectOptions = {},
+): SourceField[] {
+  if (!isPlainObject(sample)) {
+    return [];
+  }
+  const idPrefix = options.idPrefix?.trim() || 'src';
+  const maxDepth = Math.max(0, options.maxDepth ?? 4);
+  return Object.entries(sample).map(([key, value]) =>
+    fieldFromEntry(key, value, key, idPrefix, 0, maxDepth),
+  );
+}

package/src/domain/ingest/targetSlotsFromPlainObject.ts

@@ -1,41 +1,41 @@
-import { sourceFieldsFromPlainObject } from './sourceFieldsFromPlainObject.js';
-import type { SourceField, TargetSlot } from '../types.js';
-
-export interface TargetSlotsFromPlainObjectOptions {
-  /** Prefix for generated slot ids (default `tgt`). */
-  readonly idPrefix?: string;
-  /** Max nesting depth for object children (default 4). */
-  readonly maxDepth?: number;
-}
-
-function sourceFieldToTargetSlot(field: SourceField): TargetSlot {
-  const slot: TargetSlot = {
-    id: field.id,
-    label: field.label,
-    ...(field.path ? { path: field.path } : {}),
-    ...(field.dataType ? { dataType: field.dataType } : {}),
-  };
-  if (field.children && field.children.length > 0) {
-    return {
-      ...slot,
-      children: field.children.map(sourceFieldToTargetSlot),
-    };
-  }
-  return slot;
-}
-
-/**
- * Infer a nested `TargetSlot` tree from a plain sample object (or target shape).
- * Mirrors {@link sourceFieldsFromPlainObject}: same nesting / array-of-object rules,
- * keeping `path` for `convertToShape` output assembly (no `sampleValue`).
- */
-export function targetSlotsFromPlainObject(
-  sample: unknown,
-  options: TargetSlotsFromPlainObjectOptions = {},
-): TargetSlot[] {
-  const idPrefix = options.idPrefix?.trim() || 'tgt';
-  return sourceFieldsFromPlainObject(sample, {
-    idPrefix,
-    maxDepth: options.maxDepth,
-  }).map(sourceFieldToTargetSlot);
-}
+import { sourceFieldsFromPlainObject } from './sourceFieldsFromPlainObject.js';
+import type { SourceField, TargetSlot } from '../types.js';
+
+export interface TargetSlotsFromPlainObjectOptions {
+  /** Prefix for generated slot ids (default `tgt`). */
+  readonly idPrefix?: string;
+  /** Max nesting depth for object children (default 4). */
+  readonly maxDepth?: number;
+}
+
+function sourceFieldToTargetSlot(field: SourceField): TargetSlot {
+  const slot: TargetSlot = {
+    id: field.id,
+    label: field.label,
+    ...(field.path ? { path: field.path } : {}),
+    ...(field.dataType ? { dataType: field.dataType } : {}),
+  };
+  if (field.children && field.children.length > 0) {
+    return {
+      ...slot,
+      children: field.children.map(sourceFieldToTargetSlot),
+    };
+  }
+  return slot;
+}
+
+/**
+ * Infer a nested `TargetSlot` tree from a plain sample object (or target shape).
+ * Mirrors {@link sourceFieldsFromPlainObject}: same nesting / array-of-object rules,
+ * keeping `path` for `convertToShape` output assembly (no `sampleValue`).
+ */
+export function targetSlotsFromPlainObject(
+  sample: unknown,
+  options: TargetSlotsFromPlainObjectOptions = {},
+): TargetSlot[] {
+  const idPrefix = options.idPrefix?.trim() || 'tgt';
+  return sourceFieldsFromPlainObject(sample, {
+    idPrefix,
+    maxDepth: options.maxDepth,
+  }).map(sourceFieldToTargetSlot);
+}