nucleus-core-ts 0.9.795 → 0.9.797

package/dist/fe/components/IntegrationsPage/components/RunPlanIssues.d.ts

@@ -1,4 +1,6 @@
 import type { RunIssueValue } from '../types';
+/** `name: ÜRETİM PLANLAMA, slug: TAT-110` — the mapped values, in column order. */
+export declare function describeRow(row: Record<string, unknown>): string;
 export type RunPlanIssuesProps = {
     issues: RunIssueValue[];
 };

package/dist/fe/components/IntegrationsPage/components/RunPlanIssues.js

@@ -9,6 +9,14 @@ import { integrationsPageTheme } from '../theme';
  * open because the source index is the only way back to the offending record.
  * Messages wrap rather than truncate — a clipped reason is a reason nobody acts on.
  */ const theme = integrationsPageTheme;
+/** Long enough to compare two rows at a glance, short enough to stay one line. */ const MAX_VALUE_LENGTH = 60;
+/** `name: ÜRETİM PLANLAMA, slug: TAT-110` — the mapped values, in column order. */ export function describeRow(row) {
+    return Object.entries(row).map(([column, value])=>{
+        const text = value == null ? '—' : String(value);
+        const shown = text.length > MAX_VALUE_LENGTH ? `${text.slice(0, MAX_VALUE_LENGTH - 1)}…` : text;
+        return `${column}: ${shown}`;
+    }).join(', ');
+}
 export function RunPlanIssues({ issues }) {
     if (issues.length === 0) return null;
     return /*#__PURE__*/ _jsxs("details", {
@@ -34,6 +42,14 @@ export function RunPlanIssues({ issues }) {
                             issue.dedupKey ? /*#__PURE__*/ _jsx("span", {
                                 className: theme.field.hint,
                                 children: `Dedup key: ${issue.dedupKey}`
+                            }) : null,
+                            issue.keptRow ? /*#__PURE__*/ _jsx("span", {
+                                className: theme.field.hint,
+                                children: `Kept — ${describeRow(issue.keptRow)}`
+                            }) : null,
+                            issue.row ? /*#__PURE__*/ _jsx("span", {
+                                className: theme.field.hint,
+                                children: issue.keptRow ? `Skipped — ${describeRow(issue.row)}` : describeRow(issue.row)
                             }) : null
                         ]
                     }, `${issue.sourceIndex}-${issue.kind}-${index}`))

package/dist/fe/components/IntegrationsPage/components/RunPlanIssues.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fe/components/IntegrationsPage/components/RunPlanIssues.test.js

@@ -0,0 +1,44 @@
+import { describe, expect, test } from 'bun:test';
+import { describeRow } from './RunPlanIssues';
+/**
+ * A preview that names the key which collided but not the values behind it
+ * cannot answer the only question worth asking: is this the same record listed
+ * twice, or two records the key cannot tell apart? The first is a skip; the
+ * second means the key is too narrow and rows are being lost.
+ */ describe('describeRow', ()=>{
+    test('lists the mapped columns and their values, in order', ()=>{
+        expect(describeRow({
+            name: 'ÜRETİM PLANLAMA MÜDÜRLÜĞÜ',
+            slug: 'TAT-110'
+        })).toBe('name: ÜRETİM PLANLAMA MÜDÜRLÜĞÜ, slug: TAT-110');
+    });
+    test('an empty column reads as a dash, not as nothing at all', ()=>{
+        expect(describeRow({
+            name: null,
+            slug: 'TAT-110'
+        })).toBe('name: —, slug: TAT-110');
+        expect(describeRow({
+            name: undefined,
+            slug: 'X'
+        })).toBe('name: —, slug: X');
+    });
+    test('a long value is cut rather than allowed to bury the rest', ()=>{
+        const long = 'A'.repeat(200);
+        const described = describeRow({
+            description: long,
+            slug: 'X'
+        });
+        expect(described.length).toBeLessThan(120);
+        expect(described).toContain('…');
+        expect(described).toContain('slug: X');
+    });
+    test('non-string values are shown rather than dropped', ()=>{
+        expect(describeRow({
+            displayOrder: 0,
+            enabled: false
+        })).toBe('displayOrder: 0, enabled: false');
+    });
+    test('an empty row yields an empty description rather than punctuation', ()=>{
+        expect(describeRow({})).toBe('');
+    });
+});

package/dist/fe/components/IntegrationsPage/types/results.d.ts

@@ -8,6 +8,16 @@ export type RunIssueValue = {
     kind: string;
     message: string;
     dedupKey?: string | null;
+    /**
+     * What the skipped record mapped to, when the planner could attach it.
+     *
+     * Two records sharing a key are either the same thing listed twice — skip it
+     * — or two things the key cannot tell apart, which means the key is too
+     * narrow and rows are being lost. The values are the difference.
+     */
+    row?: Record<string, unknown>;
+    /** The record that claimed this key first — what the skipped one lost to. */
+    keptRow?: Record<string, unknown>;
 };
 /** What a run would do, computed without writing. */
 export type RunPlanValue = {