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

package/src/domain/mapping/pathUtils.ts

@@ -1,156 +1,156 @@
-/**
- * Lightweight path helpers for collection item projection and safe templates.
- * Supports simple dotted paths (`name`, `meta.label`) on plain objects.
- */
-
-/** Identifier or dotted path: `city`, `a.b` (no expressions / eval). */
-const SAFE_PATH_RE = /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$/;
-
-/** Placeholder matcher: `{city}`, `{a.b}` — rejects expressions / spaces. */
-const TEMPLATE_PLACEHOLDER_RE = /\{([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*)\}/g;
-
-export function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-
-export function isSafeObjectPath(path: string): boolean {
-  return SAFE_PATH_RE.test(path.trim());
-}
-
-/**
- * Fill `{path}` placeholders from a plain object using safe dotted paths only.
- * Unknown / unsafe placeholders become empty strings. No JS eval.
- */
-export function applyStringTemplate(
-  template: string,
-  record: Readonly<Record<string, unknown>> | null | undefined,
-): string {
-  return template.replace(TEMPLATE_PLACEHOLDER_RE, (_match, path: string) => {
-    if (!record || !isSafeObjectPath(path)) {
-      return '';
-    }
-    const resolved = readObjectPath(record, path);
-    if (resolved === null || resolved === undefined) {
-      return '';
-    }
-    if (
-      typeof resolved === 'string' ||
-      typeof resolved === 'number' ||
-      typeof resolved === 'boolean'
-    ) {
-      return String(resolved);
-    }
-    return '';
-  });
-}
-
-export function readObjectPath(value: unknown, path: string): unknown {
-  const parts = path
-    .split('.')
-    .map((part) => part.trim())
-    .filter((part) => part.length > 0);
-  if (parts.length === 0) {
-    return value;
-  }
-
-  let current: unknown = value;
-  for (const part of parts) {
-    if (current === null || current === undefined || typeof current !== 'object') {
-      return undefined;
-    }
-    current = (current as Record<string, unknown>)[part];
-  }
-  return current;
-}
-
-/**
- * Write `value` at a dotted path, creating plain-object parents as needed.
- * Returns a new root object (does not mutate `root`).
- */
-export function writeObjectPath(
-  root: Readonly<Record<string, unknown>> | null | undefined,
-  path: string,
-  value: unknown,
-): Record<string, unknown> {
-  const parts = path
-    .split('.')
-    .map((part) => part.trim())
-    .filter((part) => part.length > 0);
-  if (parts.length === 0) {
-    return isPlainObject(root) ? { ...root } : {};
-  }
-
-  const result: Record<string, unknown> = isPlainObject(root) ? { ...root } : {};
-  let cursor: Record<string, unknown> = result;
-
-  for (let index = 0; index < parts.length - 1; index += 1) {
-    const part = parts[index]!;
-    const existing = cursor[part];
-    const nextChild: Record<string, unknown> = isPlainObject(existing) ? { ...existing } : {};
-    cursor[part] = nextChild;
-    cursor = nextChild;
-  }
-
-  cursor[parts[parts.length - 1]!] = value;
-  return result;
-}
-
-/**
- * Project each array element through `itemSourcePath`.
- * Non-arrays are returned unchanged (callers decide whether that is valid).
- */
-export function projectCollectionItems(value: unknown, itemSourcePath: string): unknown {
-  const path = itemSourcePath.trim();
-  if (!path || !Array.isArray(value)) {
-    return value;
-  }
-  return value.map((item) => readObjectPath(item, path));
-}
-
-export interface ArrayItemProjectionOption {
-  readonly path: string;
-  readonly label: string;
-  readonly dataType?: string;
-}
-
-/**
- * Projection candidates for an array source:
- * 1) explicit item-schema `children` (path / label)
- * 2) else keys of the first object in `sampleValue`
- */
-export function listArrayItemProjectionOptions(source: {
-  readonly children?: readonly {
-    readonly label: string;
-    readonly path?: string;
-    readonly dataType?: string;
-  }[];
-  readonly sampleValue?: unknown;
-}): ArrayItemProjectionOption[] {
-  if (source.children?.length) {
-    const options: ArrayItemProjectionOption[] = [];
-    for (const child of source.children) {
-      const path = (child.path ?? child.label).trim();
-      if (!path) {
-        continue;
-      }
-      options.push({
-        path,
-        label: child.label,
-        dataType: child.dataType,
-      });
-    }
-    return options;
-  }
-
-  if (!Array.isArray(source.sampleValue) || source.sampleValue.length === 0) {
-    return [];
-  }
-  const first = source.sampleValue[0];
-  if (first === null || first === undefined || typeof first !== 'object' || Array.isArray(first)) {
-    return [];
-  }
-  return Object.keys(first as Record<string, unknown>).map((key) => ({
-    path: key,
-    label: key,
-  }));
-}
+/**
+ * Lightweight path helpers for collection item projection and safe templates.
+ * Supports simple dotted paths (`name`, `meta.label`) on plain objects.
+ */
+
+/** Identifier or dotted path: `city`, `a.b` (no expressions / eval). */
+const SAFE_PATH_RE = /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$/;
+
+/** Placeholder matcher: `{city}`, `{a.b}` — rejects expressions / spaces. */
+const TEMPLATE_PLACEHOLDER_RE = /\{([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*)\}/g;
+
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function isSafeObjectPath(path: string): boolean {
+  return SAFE_PATH_RE.test(path.trim());
+}
+
+/**
+ * Fill `{path}` placeholders from a plain object using safe dotted paths only.
+ * Unknown / unsafe placeholders become empty strings. No JS eval.
+ */
+export function applyStringTemplate(
+  template: string,
+  record: Readonly<Record<string, unknown>> | null | undefined,
+): string {
+  return template.replace(TEMPLATE_PLACEHOLDER_RE, (_match, path: string) => {
+    if (!record || !isSafeObjectPath(path)) {
+      return '';
+    }
+    const resolved = readObjectPath(record, path);
+    if (resolved === null || resolved === undefined) {
+      return '';
+    }
+    if (
+      typeof resolved === 'string' ||
+      typeof resolved === 'number' ||
+      typeof resolved === 'boolean'
+    ) {
+      return String(resolved);
+    }
+    return '';
+  });
+}
+
+export function readObjectPath(value: unknown, path: string): unknown {
+  const parts = path
+    .split('.')
+    .map((part) => part.trim())
+    .filter((part) => part.length > 0);
+  if (parts.length === 0) {
+    return value;
+  }
+
+  let current: unknown = value;
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== 'object') {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[part];
+  }
+  return current;
+}
+
+/**
+ * Write `value` at a dotted path, creating plain-object parents as needed.
+ * Returns a new root object (does not mutate `root`).
+ */
+export function writeObjectPath(
+  root: Readonly<Record<string, unknown>> | null | undefined,
+  path: string,
+  value: unknown,
+): Record<string, unknown> {
+  const parts = path
+    .split('.')
+    .map((part) => part.trim())
+    .filter((part) => part.length > 0);
+  if (parts.length === 0) {
+    return isPlainObject(root) ? { ...root } : {};
+  }
+
+  const result: Record<string, unknown> = isPlainObject(root) ? { ...root } : {};
+  let cursor: Record<string, unknown> = result;
+
+  for (let index = 0; index < parts.length - 1; index += 1) {
+    const part = parts[index]!;
+    const existing = cursor[part];
+    const nextChild: Record<string, unknown> = isPlainObject(existing) ? { ...existing } : {};
+    cursor[part] = nextChild;
+    cursor = nextChild;
+  }
+
+  cursor[parts[parts.length - 1]!] = value;
+  return result;
+}
+
+/**
+ * Project each array element through `itemSourcePath`.
+ * Non-arrays are returned unchanged (callers decide whether that is valid).
+ */
+export function projectCollectionItems(value: unknown, itemSourcePath: string): unknown {
+  const path = itemSourcePath.trim();
+  if (!path || !Array.isArray(value)) {
+    return value;
+  }
+  return value.map((item) => readObjectPath(item, path));
+}
+
+export interface ArrayItemProjectionOption {
+  readonly path: string;
+  readonly label: string;
+  readonly dataType?: string;
+}
+
+/**
+ * Projection candidates for an array source:
+ * 1) explicit item-schema `children` (path / label)
+ * 2) else keys of the first object in `sampleValue`
+ */
+export function listArrayItemProjectionOptions(source: {
+  readonly children?: readonly {
+    readonly label: string;
+    readonly path?: string;
+    readonly dataType?: string;
+  }[];
+  readonly sampleValue?: unknown;
+}): ArrayItemProjectionOption[] {
+  if (source.children?.length) {
+    const options: ArrayItemProjectionOption[] = [];
+    for (const child of source.children) {
+      const path = (child.path ?? child.label).trim();
+      if (!path) {
+        continue;
+      }
+      options.push({
+        path,
+        label: child.label,
+        dataType: child.dataType,
+      });
+    }
+    return options;
+  }
+
+  if (!Array.isArray(source.sampleValue) || source.sampleValue.length === 0) {
+    return [];
+  }
+  const first = source.sampleValue[0];
+  if (first === null || first === undefined || typeof first !== 'object' || Array.isArray(first)) {
+    return [];
+  }
+  return Object.keys(first as Record<string, unknown>).map((key) => ({
+    path: key,
+    label: key,
+  }));
+}

package/src/domain/mapping/resolveMappedValue.ts

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