Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

feat(grid): add cell value conversion previews

二丫讲梵6299d6212556
diff --git a/apps/desktop/src/components/grid/DataGrid.vue b/apps/desktop/src/components/grid/DataGrid.vue
index baa6158c25..a859d61db5 100644
--- a/apps/desktop/src/components/grid/DataGrid.vue
+++ b/apps/desktop/src/components/grid/DataGrid.vue
@@ -67,6 +67,7 @@ import { Tabs, TabsContent } from "@/components/ui/tabs";
import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
import ErrorBanner from "@/components/ui/ErrorBanner.vue";
import DangerConfirmDialog from "@/components/editor/DangerConfirmDialog.vue";
+import DataGridValueTransform from "@/components/grid/DataGridValueTransform.vue";
import DataGridCellDetailPanel from "@/components/grid/DataGridCellDetailPanel.vue";
import DataGridPagination from "@/components/grid/DataGridPagination.vue";
import DataGridSearchBar from "@/components/grid/DataGridSearchBar.vue";
@@ -5782,6 +5783,10 @@ const showCompactDetailJson = computed(() => {
// CodeMirror-based cell detail editors
const valueEditorContainer = ref<HTMLElement>();
+const detailTransformOpen = ref(false);
+watch([showCellDetail, activeCellDetailTab, () => activeCellDetail.value?.rowId, () => activeCellDetail.value?.colIndex], () => {
+ detailTransformOpen.value = false;
+});
let valueDetailEditor: UseCellDetailEditorReturn | null = null;
const editorThemeAccessor = () => settingsStore.editorSettings.theme;
@@ -5812,7 +5817,7 @@ watch(valueEditorContainer, async (el) => {
},
onEscape: () => restoreDetailOriginalValue(),
onBlur: () => {
- if (!detailValueDiffOpen.value) commitValueEditorEdit();
+ if (!detailValueDiffOpen.value && !detailTransformOpen.value) commitValueEditorEdit();
},
editorTheme: editorThemeAccessor,
appAppearance: editorAppAppearance,
@@ -13204,6 +13209,14 @@ useUpdateBlocker(() => (hasPendingChanges.value || hasPendingDataEditorDraft.val
<div v-else ref="valueEditorContainer" data-cell-detail-editor-root class="min-h-0 min-w-0 flex-1 w-full rounded border overflow-auto" />
</div>
<div class="min-w-0 flex flex-wrap gap-1 mt-2 shrink-0">
+ <DataGridValueTransform
+ v-if="activeCellDetail && !isBinaryCellColumnType(activeCellDetail.type)"
+ v-model:open="detailTransformOpen"
+ :source="isEditingDetail && !((activeCellDetail.isNull ?? activeCellDetail.value === null) && detailEditValue === detailEditOriginalValue) ? detailEditValue : null"
+ :identity="`${activeCellDetail.rowId}:${activeCellDetail.colIndex}:${activeCellDetailTab}`"
+ :incomplete="activeCellDetail.isSourceTruncated"
+ :unsafe-number="typeof activeCellDetail.value === 'number' && Number.isInteger(activeCellDetail.value) && !Number.isSafeInteger(activeCellDetail.value) && detailEditValue === activeCellDetail.rawValue"
+ />
<DropdownMenu v-if="activeCellDetail?.isEditable">
<DropdownMenuTrigger as-child>
<Button variant="outline" size="sm" class="h-6 gap-1 text-xs" @mousedown.prevent>
diff --git a/apps/desktop/src/components/grid/DataGridCellDetailDialog.vue b/apps/desktop/src/components/grid/DataGridCellDetailDialog.vue
index 05ce03f866..39abb4c8d5 100644
--- a/apps/desktop/src/components/grid/DataGridCellDetailDialog.vue
+++ b/apps/desktop/src/components/grid/DataGridCellDetailDialog.vue
@@ -1,4 +1,5 @@
<script setup lang="ts">
+import DataGridValueTransform from "@/components/grid/DataGridValueTransform.vue";
import { computed, nextTick, ref, watch } from "vue";
import { Code2, Copy, Download, Eye, FileUp, Info, Pencil } from "@lucide/vue";
import { useI18n } from "vue-i18n";
@@ -9,7 +10,7 @@ import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover
import { useCellDetailEditor, type UseCellDetailEditorReturn } from "@/composables/useCellDetailEditor";
import { useTheme } from "@/composables/useTheme";
import { useSettingsStore } from "@/stores/settingsStore";
-import { BINARY_CELL_DOWNLOAD_MODES, binaryCellUtf8Text, isBlobCellColumnType, type BinaryCellDownloadMode } from "@/lib/dataGrid/binaryCellDownload";
+import { BINARY_CELL_DOWNLOAD_MODES, isBinaryCellColumnType, binaryCellUtf8Text, isBlobCellColumnType, type BinaryCellDownloadMode } from "@/lib/dataGrid/binaryCellDownload";
import { isGeometryColumnType } from "@/lib/dataGrid/cellDetailPresentation";
import { isHexGeometry, renderWktOnCanvas } from "@/lib/dataGrid/geometryPreview";
import type { DataGridCellDetail } from "@/lib/dataGrid/dataGridDetail";
@@ -149,6 +150,13 @@ watch(
<div class="flex items-center justify-between gap-2">
<div class="text-muted-foreground">{{ t("grid.cellValue") }}</div>
<div class="flex items-center gap-1">
+ <DataGridValueTransform
+ v-if="open && !isBinaryCellColumnType(detail.type)"
+ :source="(detail.isNull ?? detail.value === null) ? null : detail.rawValue"
+ :identity="`${detail.rowId}:${detail.colIndex}`"
+ :incomplete="detail.isSourceTruncated"
+ :unsafe-number="typeof detail.value === 'number' && Number.isInteger(detail.value) && !Number.isSafeInteger(detail.value)"
+ />
<Button v-if="detail.formattedJson" :variant="jsonView ? 'secondary' : 'ghost'" size="sm" class="h-6 gap-1 px-2 text-xs" :title="t('grid.formattedJson')" @click="toggleJsonFormatted">
<Code2 class="h-3 w-3" />
{{ t("grid.formattedJson") }}
diff --git a/apps/desktop/src/components/grid/DataGridCellDetailPanel.vue b/apps/desktop/src/components/grid/DataGridCellDetailPanel.vue
index cc6a8d210f..90deaecfd5 100644
--- a/apps/desktop/src/components/grid/DataGridCellDetailPanel.vue
+++ b/apps/desktop/src/components/grid/DataGridCellDetailPanel.vue
@@ -1,4 +1,5 @@
<script setup lang="ts">
+import DataGridValueTransform from "@/components/grid/DataGridValueTransform.vue";
import { computed, toRef } from "vue";
import { Code2, Copy, Download, Eye, FileDiff, FileUp, Pencil, X } from "@lucide/vue";
import { useI18n } from "vue-i18n";
@@ -8,7 +9,7 @@ import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover
import { TabsContent } from "@/components/ui/tabs";
import TemporalCellEditor from "@/components/grid/TemporalCellEditor.vue";
import { useDataGridCellDetail } from "@/composables/useDataGridCellDetail";
-import { BINARY_CELL_DOWNLOAD_MODES, binaryCellUtf8Text, isBlobCellColumnType, type BinaryCellDownloadMode } from "@/lib/dataGrid/binaryCellDownload";
+import { BINARY_CELL_DOWNLOAD_MODES, isBinaryCellColumnType, binaryCellUtf8Text, isBlobCellColumnType, type BinaryCellDownloadMode } from "@/lib/dataGrid/binaryCellDownload";
import { isGeometryColumnType } from "@/lib/dataGrid/cellDetailPresentation";
import { isHexGeometry } from "@/lib/dataGrid/geometryPreview";
import type { DataGridCellDetail } from "@/lib/dataGrid/dataGridDetail";
@@ -141,6 +142,13 @@ defineExpose({ openSearch });
<div class="flex min-h-5 min-w-0 flex-wrap items-center justify-between gap-2">
<div class="shrink-0 text-muted-foreground">{{ t("grid.cellValue") }}</div>
<div class="min-w-0 flex flex-1 flex-wrap items-center justify-end gap-1">
+ <DataGridValueTransform
+ v-if="!isBinaryCellColumnType(detail.type)"
+ :source="(detail.isNull ?? detail.value === null) && (!editing || !detailEditValue || detailEditValue === detail.rawValue) ? null : editing ? detailEditValue : detail.rawValue"
+ :identity="`${detail.rowId}:${detail.colIndex}:${editing}`"
+ :incomplete="detail.isSourceTruncated"
+ :unsafe-number="typeof detail.value === 'number' && Number.isInteger(detail.value) && !Number.isSafeInteger(detail.value) && (!editing || detailEditValue === detail.rawValue)"
+ />
<Button v-if="editing && showCompareJson" variant="ghost" size="sm" class="h-5 gap-1 px-1.5 text-xs" :disabled="!canCompareJson" :title="t('grid.compareJson')" @mousedown.prevent @click="emit('compareJson')"><FileDiff class="h-3 w-3" />{{ t("grid.compareJson") }}</Button>
<Button v-if="showCompactJson" variant="ghost" size="sm" class="h-5 gap-1 px-1.5 text-xs" :disabled="!canCompactJson" :title="t('grid.compactJson')" @click="emit('compactJson')"><Code2 class="h-3 w-3" />{{ t("grid.compactJson") }}</Button>
<Button v-if="!editing && detail.formattedJson" :variant="sideJsonView ? 'secondary' : 'ghost'" size="sm" class="h-5 gap-1 px-1.5 text-xs" :title="t('grid.formattedJson')" @click="emit('toggleFormatted')"><Code2 class="h-3 w-3" />{{ t("grid.formattedJson") }}</Button>
diff --git a/apps/desktop/src/components/grid/DataGridValueTransform.vue b/apps/desktop/src/components/grid/DataGridValueTransform.vue
new file mode 100644
index 0000000000..0c5f0ea472
--- /dev/null
+++ b/apps/desktop/src/components/grid/DataGridValueTransform.vue
@@ -0,0 +1,162 @@
+<script setup lang="ts">
+import { computed, ref, useId, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import { useToast } from "@/composables/useToast";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle, DialogTrigger } from "@/components/ui/dialog";
+import { CELL_TRANSFORM_KINDS, CELL_TRANSFORM_MAX_INPUT, CELL_TRANSFORM_MAX_OUTPUT, CELL_TRANSFORM_MAX_RADIX_DIGITS, transformCellValue, type CellTransformKind, type CellTransformResult } from "@/lib/dataGrid/cellValueTransform";
+import { DataGridDateTimePatterns, getSupportedTimeZoneOptions } from "@/lib/dataGrid/columnFormatter";
+
+const props = defineProps<{
+ source: string | null;
+ identity: string;
+ incomplete?: boolean;
+ unsafeNumber?: boolean;
+}>();
+const { t } = useI18n();
+const { toast } = useToast();
+const id = useId();
+const open = defineModel<boolean>("open", { default: false });
+const kind = ref<CellTransformKind>("timestamp");
+const unit = ref<"auto" | "seconds" | "milliseconds">("auto");
+const timezone = ref(Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC");
+const zones = [...new Set(["UTC", timezone.value, ...getSupportedTimeZoneOptions(Intl as unknown as { supportedValuesOf?: (key: "timeZone") => string[] }, timezone.value)])];
+const pattern = ref("YYYY-MM-DD HH:mm:ss");
+const fromBase = ref(10);
+const toBase = ref(16);
+const result = ref<CellTransformResult | null>(null);
+let previousEditorFocus: HTMLElement | null = null;
+let previousEditorIdentity = "";
+
+function rememberEditorFocus() {
+ const active = document.activeElement;
+ previousEditorFocus = active instanceof HTMLElement && active.closest("[data-cell-detail-editor-root]") ? active : null;
+ previousEditorIdentity = props.identity;
+}
+
+function restoreEditorFocus(event: Event) {
+ const target = previousEditorFocus;
+ previousEditorFocus = null;
+ if (!target?.isConnected || previousEditorIdentity !== props.identity) return;
+ // Opening the preview skips the editor's blur commit. Restore its focus so
+ // the next deliberate departure still commits the untouched editing draft.
+ event.preventDefault();
+ target.focus({ preventScroll: true });
+}
+
+const blockedReason = computed(() => {
+ if (props.source === null) return "nullSource";
+ if (props.incomplete) return "incomplete";
+ if (props.unsafeNumber) return "unsafeNumber";
+ if (props.source.length > CELL_TRANSFORM_MAX_INPUT) return "tooLarge";
+ return "";
+});
+
+// Locale messages only interpolate the grouped limit digits, so translations keep their wording.
+const errorLimits = {
+ maxInput: new Intl.NumberFormat("en-US").format(CELL_TRANSFORM_MAX_INPUT),
+ maxOutput: new Intl.NumberFormat("en-US").format(CELL_TRANSFORM_MAX_OUTPUT),
+ maxRadixDigits: new Intl.NumberFormat("en-US").format(CELL_TRANSFORM_MAX_RADIX_DIGITS),
+};
+
+// Keep only options between cells. Results must always belong to the current source.
+watch(
+ () => props.identity,
+ () => {
+ open.value = false;
+ result.value = null;
+ },
+ { flush: "sync" },
+);
+watch(
+ [() => props.source, () => props.incomplete, () => props.unsafeNumber, kind, unit, timezone, pattern, fromBase, toBase, open],
+ () => {
+ result.value = null;
+ },
+ { flush: "sync" },
+);
+
+function convert() {
+ if (blockedReason.value || props.source === null) return;
+ result.value = transformCellValue(props.source, { kind: kind.value, unit: unit.value, timezone: timezone.value, pattern: pattern.value, fromBase: fromBase.value, toBase: toBase.value });
+}
+async function copyResult() {
+ if (!result.value?.ok) return;
+ try {
+ await copyToClipboard(result.value.text);
+ toast(t("grid.cellValueCopied"), 2000);
+ } catch (error) {
+ toast(error instanceof Error ? error.message : String(error), 5000);
+ }
+}
+</script>
+
+<template>
+ <Dialog v-model:open="open">
+ <DialogTrigger as-child>
+ <Button variant="outline" size="sm" class="h-6 px-2 text-xs" @mousedown.prevent>{{ t("cellTransform.title") }}</Button>
+ </DialogTrigger>
+ <DialogContent class="flex max-h-[85vh] flex-col overflow-y-auto sm:max-w-2xl" data-native-clipboard @open-auto-focus="rememberEditorFocus" @close-auto-focus="restoreEditorFocus">
+ <DialogHeader>
+ <DialogTitle>{{ t("cellTransform.title") }}</DialogTitle>
+ <DialogDescription>{{ t("cellTransform.description") }}</DialogDescription>
+ </DialogHeader>
+ <div class="flex flex-wrap items-end gap-3 text-xs">
+ <label class="flex flex-col gap-1">
+ {{ t("cellTransform.format") }}
+ <select v-model="kind" class="h-8 rounded border bg-background px-2">
+ <option v-for="item in CELL_TRANSFORM_KINDS" :key="item" :value="item">{{ t(`cellTransform.kinds.${item}`) }}</option>
+ </select>
+ </label>
+ <template v-if="kind === 'timestamp'">
+ <label class="flex flex-col gap-1">
+ {{ t("cellTransform.unit") }}
+ <select v-model="unit" class="h-8 rounded border bg-background px-2">
+ <option v-for="item in ['auto', 'seconds', 'milliseconds']" :key="item" :value="item">{{ t(`cellTransform.units.${item}`) }}</option>
+ </select>
+ </label>
+ <label class="flex flex-col gap-1">
+ {{ t("cellTransform.timezone") }}
+ <input v-model="timezone" :list="`${id}-zones`" class="h-8 rounded border bg-background px-2" />
+ <datalist :id="`${id}-zones`"><option v-for="zone in zones" :key="zone" :value="zone" /></datalist>
+ </label>
+ <label class="flex min-w-0 flex-col gap-1">
+ {{ t("cellTransform.pattern") }}
+ <select v-model="pattern" class="h-8 max-w-full rounded border bg-background px-2">
+ <option v-for="item in DataGridDateTimePatterns" :key="item" :value="item">{{ item }}</option>
+ </select>
+ </label>
+ </template>
+ <template v-if="kind === 'radix'">
+ <label class="flex flex-col gap-1">
+ {{ t("cellTransform.fromBase") }}
+ <select v-model="fromBase" class="h-8 rounded border bg-background px-2">
+ <option v-for="base in [2, 8, 10, 16]" :key="base" :value="base">{{ base }}</option>
+ </select>
+ </label>
+ <label class="flex flex-col gap-1">
+ {{ t("cellTransform.toBase") }}
+ <select v-model="toBase" class="h-8 rounded border bg-background px-2">
+ <option v-for="base in [2, 8, 10, 16]" :key="base" :value="base">{{ base }}</option>
+ </select>
+ </label>
+ </template>
+ <Button size="sm" class="h-8" :disabled="!!blockedReason" @click="convert">{{ t("cellTransform.convert") }}</Button>
+ </div>
+ <p v-if="kind === 'radix'" class="text-xs text-muted-foreground">{{ t("cellTransform.radixHint") }}</p>
+ <p v-if="kind === 'urlEncode' || kind === 'urlDecode'" class="text-xs text-muted-foreground">{{ t("cellTransform.urlHint") }}</p>
+ <p v-if="blockedReason" role="status" class="text-xs text-muted-foreground">{{ t(`cellTransform.errors.${blockedReason}`, errorLimits) }}</p>
+ <p v-else-if="result && !result.ok" role="alert" class="text-xs text-destructive">{{ t(`cellTransform.errors.${result.error}`, errorLimits) }}</p>
+ <template v-if="result?.ok">
+ <div class="flex items-center justify-between gap-2 text-xs">
+ <span
+ >{{ t("cellTransform.result") }}<template v-if="result.unit"> · {{ t(`cellTransform.units.${result.unit}`) }}</template></span
+ >
+ <Button variant="outline" size="sm" class="h-6 text-xs" @click="copyResult">{{ t("cellTransform.copy") }}</Button>
+ </div>
+ <textarea :value="result.text" :aria-label="t('cellTransform.result')" readonly class="dbx-data-grid-value-font h-64 min-h-24 w-full resize-y rounded border bg-muted/20 p-3 text-xs" spellcheck="false" />
+ </template>
+ </DialogContent>
+ </Dialog>
+</template>
diff --git a/apps/desktop/src/components/grid/__tests__/DataGridSurfaces.spec.ts b/apps/desktop/src/components/grid/__tests__/DataGridSurfaces.spec.ts
index f3189fa6fd..fdbcff4a78 100644
--- a/apps/desktop/src/components/grid/__tests__/DataGridSurfaces.spec.ts
+++ b/apps/desktop/src/components/grid/__tests__/DataGridSurfaces.spec.ts
@@ -76,6 +76,7 @@ vi.mock("@/components/ui/label", async () => ({ Label: (await import("./vueHostH
vi.mock("@/components/ui/LightDropdown.vue", async () => ({ default: (await import("./vueHostHarness")).createPassthroughStub("LightDropdown") }));
vi.mock("@/components/ui/LightTooltip.vue", async () => ({ default: (await import("./vueHostHarness")).createPassthroughStub("LightTooltip") }));
vi.mock("@/components/grid/TemporalCellEditor.vue", async () => ({ default: (await import("./vueHostHarness")).createPassthroughStub("TemporalCellEditor") }));
+vi.mock("@/components/grid/DataGridValueTransform.vue", async () => ({ default: (await import("./vueHostHarness")).createPassthroughStub("DataGridValueTransform") }));
vi.mock("@/composables/useCellDetailEditor", () => ({ useCellDetailEditor: () => mocks.editor }));
vi.mock("@/composables/useTheme", () => ({ useTheme: () => ({ isDark: { value: false }, themePalette: { value: {} } }) }));
vi.mock("@/stores/settingsStore", () => ({ useSettingsStore: () => ({ editorSettings: { cellDetailJsonFormatted: true, theme: "default", fontSize: 13, fontFamily: "monospace" }, updateEditorSettings: mocks.updateSettings }) }));
@@ -1686,7 +1687,7 @@ describe("cell detail surfaces", () => {
it("snapshots comparison values before opening and suppresses modal-induced blur commits", () => {
expect(dataGridCellDetailEditSource).toContain("detailValueDiffSnapshot.value = snapshot;");
expect(dataGridCellDetailEditSource).toContain("detailValueDiffOpen.value = true;");
- expect(dataGridSource).toContain("if (!detailValueDiffOpen.value) commitValueEditorEdit();");
+ expect(dataGridSource).toContain("if (!detailValueDiffOpen.value && !detailTransformOpen.value) commitValueEditorEdit();");
expect(dataGridSource).toContain(':disabled="!canCompareDetailJson" @mousedown.prevent @click="openDetailJsonCompare"');
expect(dataGridSource).toContain('v-model:open="detailValueDiffOpen" :snapshot="detailValueDiffSnapshot"');
});
diff --git a/apps/desktop/src/i18n/locales/az.ts b/apps/desktop/src/i18n/locales/az.ts
index 7e64238f3d..9a4e049e45 100644
--- a/apps/desktop/src/i18n/locales/az.ts
+++ b/apps/desktop/src/i18n/locales/az.ts
@@ -80,6 +80,48 @@ const consul = {
};
export default withEnglishFallback({
+ cellTransform: {
+ title: "Çevirmə önizləməsi",
+ description: "Cari dəyəri baxmaq və ya köçürmək üçün çevirir. İlkin dəyər və redaktə qaralaması dəyişmir.",
+ format: "Çevirmə",
+ unit: "Zaman damğasının vahidi",
+ timezone: "Saat qurşağı",
+ pattern: "Tarix formatı",
+ fromBase: "Mənbə say sistemi",
+ toBase: "Hədəf say sistemi",
+ convert: "Çevir",
+ result: "Nəticə",
+ copy: "Nəticəni köçür",
+ radixHint: "Yalnız tam ədədlər. 0x, 0o və ya 0b prefiksi olmadan rəqəmlər daxil edin; işarə istifadə oluna bilər.",
+ urlHint: "URL komponentləri UTF-8 ilə kodlanır və ya dekodlaşdırılır. Dekodlaşdırma + işarəsini boşluğa çevirmir.",
+ kinds: {
+ timestamp: "Zaman damğası → tarix/saat",
+ json: "JSON formatla",
+ jsonCompact: "JSON sıxlaşdır",
+ xml: "XML formatla",
+ base64Encode: "Mətn → Base64 (UTF-8)",
+ base64Decode: "Base64 → mətn (UTF-8)",
+ urlEncode: "URL komponentini kodla",
+ urlDecode: "URL komponentini dekodlaşdır",
+ radix: "Tam ədədin say sistemini çevir",
+ },
+ units: {
+ auto: "Avtomatik (10/13 rəqəm)",
+ seconds: "Saniyə",
+ milliseconds: "Millisaniyə",
+ },
+ errors: {
+ nullSource: "NULL çevriləcək mətn ehtiva etmir.",
+ incomplete: "Tam dəyər hələ yüklənməyib. Gözləyin və ya xana təfərrüatlarını yenidən açın.",
+ unsafeNumber: "Bu ədəd dəqiq təqdim edilə bilmir. Dəqiqliyi qorumaq üçün onu mətn kimi sorğulayın.",
+ tooLarge: "Çevirmə həddi aşılıb: giriş {maxInput} simvol, çıxış {maxOutput} simvol və ya tam ədəd girişi {maxRadixDigits} simvol.",
+ invalid: "Çevirmək mümkün deyil. Giriş formatını və çevirmə seçimlərini yoxlayın.",
+ invalidTimestamp: "Dəstəklənən tarix aralığında tam ədəd zaman damğası daxil edin.",
+ ambiguousUnit: "Vahidi müəyyən etmək mümkün deyil. Saniyə və ya millisaniyə seçin.",
+ invalidInteger: "Mənbə say sisteminə uyğun tam ədədi prefikssiz daxil edin.",
+ invalidBase64: "Etibarlı UTF-8 mətni olan standart doldurmalı Base64 daxil edin.",
+ },
+ },
customType: {
kinds: {
base: "Əsas",
diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts
index fee47fda34..7fd6e00e74 100644
--- a/apps/desktop/src/i18n/locales/en.ts
+++ b/apps/desktop/src/i18n/locales/en.ts
@@ -80,6 +80,48 @@ const consul = {
};
export default {
+ cellTransform: {
+ title: "Convert preview",
+ description: "Convert the current value for viewing or copying. The source value and editor draft stay unchanged.",
+ format: "Conversion",
+ unit: "Timestamp unit",
+ timezone: "Time zone",
+ pattern: "Date format",
+ fromBase: "Source base",
+ toBase: "Target base",
+ convert: "Convert",
+ result: "Result",
+ copy: "Copy result",
+ radixHint: "Integers only. Enter digits without a 0x, 0o or 0b prefix; an optional sign is supported.",
+ urlHint: "URL component encoding (UTF-8). Decoding preserves + as a literal plus sign.",
+ kinds: {
+ timestamp: "Timestamp → date/time",
+ json: "Format JSON",
+ jsonCompact: "Compact JSON",
+ xml: "Format XML",
+ base64Encode: "Text → Base64 (UTF-8)",
+ base64Decode: "Base64 → text (UTF-8)",
+ urlEncode: "URL component encode",
+ urlDecode: "URL component decode",
+ radix: "Integer base conversion",
+ },
+ units: {
+ auto: "Auto (10/13 digits)",
+ seconds: "Seconds",
+ milliseconds: "Milliseconds",
+ },
+ errors: {
+ nullSource: "NULL has no text to convert.",
+ incomplete: "The full value has not loaded. Wait for it to load or reopen the cell details.",
+ unsafeNumber: "This numeric value cannot be represented safely. Retrieve it as text to preserve precision.",
+ tooLarge: "Conversion limit exceeded: {maxInput} input characters, {maxOutput} output characters, or {maxRadixDigits} integer characters.",
+ invalid: "Unable to convert. Check the input format and conversion options.",
+ invalidTimestamp: "Enter an integer timestamp within the supported date range.",
+ ambiguousUnit: "Cannot determine the timestamp unit. Select seconds or milliseconds explicitly.",
+ invalidInteger: "Enter an integer with digits valid for the selected source base, without a base prefix.",
+ invalidBase64: "Enter standard padded Base64 containing valid UTF-8 text.",
+ },
+ },
redisGrouping,
customType: {
kinds: {
diff --git a/apps/desktop/src/i18n/locales/es.ts b/apps/desktop/src/i18n/locales/es.ts
index 6fcfa2c46f..7d0131849d 100644
--- a/apps/desktop/src/i18n/locales/es.ts
+++ b/apps/desktop/src/i18n/locales/es.ts
@@ -83,6 +83,48 @@ const consul = {
};
export default withEnglishFallback({
+ cellTransform: {
+ title: "Vista previa de conversión",
+ description: "Convierte el valor actual para verlo o copiarlo. El valor original y el borrador no cambian.",
+ format: "Conversión",
+ unit: "Unidad de la marca de tiempo",
+ timezone: "Zona horaria",
+ pattern: "Formato de fecha",
+ fromBase: "Base de origen",
+ toBase: "Base de destino",
+ convert: "Convertir",
+ result: "Resultado",
+ copy: "Copiar resultado",
+ radixHint: "Solo enteros. Introduce dígitos sin los prefijos 0x, 0o o 0b; se admite un signo opcional.",
+ urlHint: "Codificación de componentes URL en UTF-8. La decodificación conserva + como signo más.",
+ kinds: {
+ timestamp: "Marca de tiempo → fecha/hora",
+ json: "Formatear JSON",
+ jsonCompact: "Compactar JSON",
+ xml: "Formatear XML",
+ base64Encode: "Texto → Base64 (UTF-8)",
+ base64Decode: "Base64 → texto (UTF-8)",
+ urlEncode: "Codificar componente URL",
+ urlDecode: "Decodificar componente URL",
+ radix: "Conversión de base de enteros",
+ },
+ units: {
+ auto: "Automática (10/13 dígitos)",
+ seconds: "Segundos",
+ milliseconds: "Milisegundos",
+ },
+ errors: {
+ nullSource: "NULL no contiene texto para convertir.",
+ incomplete: "El valor completo aún no se ha cargado. Espera o vuelve a abrir los detalles de la celda.",
+ unsafeNumber: "Este número no se puede representar con precisión. Consúltalo como texto para conservarla.",
+ tooLarge: "Límite de conversión superado: {maxInput} caracteres de entrada, {maxOutput} de salida o {maxRadixDigits} para enteros.",
+ invalid: "No se puede convertir. Revisa el formato de entrada y las opciones.",
+ invalidTimestamp: "Introduce una marca de tiempo entera dentro del intervalo de fechas admitido.",
+ ambiguousUnit: "No se puede determinar la unidad. Selecciona segundos o milisegundos.",
+ invalidInteger: "Introduce un entero válido para la base de origen, sin prefijo.",
+ invalidBase64: "Introduce Base64 estándar con relleno que contenga texto UTF-8 válido.",
+ },
+ },
customType: {
kinds: {
base: "Base",
diff --git a/apps/desktop/src/i18n/locales/it.ts b/apps/desktop/src/i18n/locales/it.ts
index 6d6c377aa0..075b749a16 100644
--- a/apps/desktop/src/i18n/locales/it.ts
+++ b/apps/desktop/src/i18n/locales/it.ts
@@ -82,6 +82,48 @@ const consul = {
};
export default withEnglishFallback({
+ cellTransform: {
+ title: "Anteprima conversione",
+ description: "Converte il valore corrente per visualizzarlo o copiarlo. Il valore originale e la bozza restano invariati.",
+ format: "Conversione",
+ unit: "Unità del timestamp",
+ timezone: "Fuso orario",
+ pattern: "Formato data",
+ fromBase: "Base di origine",
+ toBase: "Base di destinazione",
+ convert: "Converti",
+ result: "Risultato",
+ copy: "Copia risultato",
+ radixHint: "Solo interi. Inserisci cifre senza prefissi 0x, 0o o 0b; è ammesso un segno facoltativo.",
+ urlHint: "Codifica dei componenti URL in UTF-8. La decodifica mantiene + come segno più.",
+ kinds: {
+ timestamp: "Timestamp → data/ora",
+ json: "Formatta JSON",
+ jsonCompact: "Compatta JSON",
+ xml: "Formatta XML",
+ base64Encode: "Testo → Base64 (UTF-8)",
+ base64Decode: "Base64 → testo (UTF-8)",
+ urlEncode: "Codifica componente URL",
+ urlDecode: "Decodifica componente URL",
+ radix: "Conversione di base degli interi",
+ },
+ units: {
+ auto: "Automatica (10/13 cifre)",
+ seconds: "Secondi",
+ milliseconds: "Millisecondi",
+ },
+ errors: {
+ nullSource: "NULL non contiene testo da convertire.",
+ incomplete: "Il valore completo non è ancora stato caricato. Attendi o riapri i dettagli della cella.",
+ unsafeNumber: "Questo numero non può essere rappresentato con precisione. Recuperalo come testo per conservarla.",
+ tooLarge: "Limite di conversione superato: {maxInput} caratteri in ingresso, {maxOutput} in uscita o {maxRadixDigits} per gli interi.",
+ invalid: "Impossibile convertire. Controlla il formato di ingresso e le opzioni.",
+ invalidTimestamp: "Inserisci un timestamp intero nell’intervallo di date supportato.",
+ ambiguousUnit: "Impossibile determinare l’unità. Seleziona secondi o millisecondi.",
+ invalidInteger: "Inserisci un intero valido per la base di origine, senza prefisso.",
+ invalidBase64: "Inserisci Base64 standard con padding contenente testo UTF-8 valido.",
+ },
+ },
customType: {
kinds: {
base: "Base",
diff --git a/apps/desktop/src/i18n/locales/ja.ts b/apps/desktop/src/i18n/locales/ja.ts
index 96418b1925..b5b1e2dcc9 100644
--- a/apps/desktop/src/i18n/locales/ja.ts
+++ b/apps/desktop/src/i18n/locales/ja.ts
@@ -83,6 +83,48 @@ const consul = {
};
export default withEnglishFallback({
+ cellTransform: {
+ title: "変換プレビュー",
+ description: "現在の値を変換して表示またはコピーします。元の値と編集中の内容は変更されません。",
+ format: "変換方法",
+ unit: "タイムスタンプの単位",
+ timezone: "タイムゾーン",
+ pattern: "日付形式",
+ fromBase: "変換元の基数",
+ toBase: "変換先の基数",
+ convert: "変換",
+ result: "変換結果",
+ copy: "結果をコピー",
+ radixHint: "整数のみ対応します。0x、0o、0b 接頭辞は不要です。正負の符号を使用できます。",
+ urlHint: "URL コンポーネントを UTF-8 でエンコード・デコードします。デコード時に + は空白に変換されません。",
+ kinds: {
+ timestamp: "タイムスタンプ → 日時",
+ json: "JSON 整形",
+ jsonCompact: "JSON 圧縮",
+ xml: "XML 整形",
+ base64Encode: "テキスト → Base64(UTF-8)",
+ base64Decode: "Base64 → テキスト(UTF-8)",
+ urlEncode: "URL コンポーネントのエンコード",
+ urlDecode: "URL コンポーネントのデコード",
+ radix: "整数の基数変換",
+ },
+ units: {
+ auto: "自動(10/13 桁)",
+ seconds: "秒",
+ milliseconds: "ミリ秒",
+ },
+ errors: {
+ nullSource: "NULL には変換できるテキストがありません。",
+ incomplete: "値全体がまだ読み込まれていません。読み込みを待つか、セルの詳細を開き直してください。",
+ unsafeNumber: "この数値は安全に表現できません。精度を保つためテキストとして取得してください。",
+ tooLarge: "変換上限を超えました。入力 {maxInput} 文字、出力 {maxOutput} 文字、整数入力 {maxRadixDigits} 文字です。",
+ invalid: "変換できません。入力形式と変換オプションを確認してください。",
+ invalidTimestamp: "対応する日付範囲内の整数タイムスタンプを入力してください。",
+ ambiguousUnit: "単位を判定できません。秒またはミリ秒を選択してください。",
+ invalidInteger: "選択した基数に対応する整数を、接頭辞なしで入力してください。",
+ invalidBase64: "有効な UTF-8 テキストを含む、標準のパディング付き Base64 を入力してください。",
+ },
+ },
customType: {
kinds: {
base: "基本型",
diff --git a/apps/desktop/src/i18n/locales/ko.ts b/apps/desktop/src/i18n/locales/ko.ts
index b902514ca5..09aae5b801 100644
--- a/apps/desktop/src/i18n/locales/ko.ts
+++ b/apps/desktop/src/i18n/locales/ko.ts
@@ -82,6 +82,48 @@ const consul = {
};
export default withEnglishFallback({
+ cellTransform: {
+ title: "변환 미리보기",
+ description: "현재 값을 변환하여 보거나 복사합니다. 원래 값과 편집 초안은 변경되지 않습니다.",
+ format: "변환 방식",
+ unit: "타임스탬프 단위",
+ timezone: "시간대",
+ pattern: "날짜 형식",
+ fromBase: "원본 진법",
+ toBase: "대상 진법",
+ convert: "변환",
+ result: "변환 결과",
+ copy: "결과 복사",
+ radixHint: "정수만 지원합니다. 0x, 0o, 0b 접두사 없이 입력하세요. 부호는 사용할 수 있습니다.",
+ urlHint: "URL 구성 요소를 UTF-8로 인코딩하거나 디코딩합니다. 디코딩 시 +를 공백으로 바꾸지 않습니다.",
+ kinds: {
+ timestamp: "타임스탬프 → 날짜/시간",
+ json: "JSON 서식 지정",
+ jsonCompact: "JSON 압축",
+ xml: "XML 서식 지정",
+ base64Encode: "텍스트 → Base64(UTF-8)",
+ base64Decode: "Base64 → 텍스트(UTF-8)",
+ urlEncode: "URL 구성 요소 인코딩",
+ urlDecode: "URL 구성 요소 디코딩",
+ radix: "정수 진법 변환",
+ },
+ units: {
+ auto: "자동(10/13자리)",
+ seconds: "초",
+ milliseconds: "밀리초",
+ },
+ errors: {
+ nullSource: "NULL에는 변환할 텍스트가 없습니다.",
+ incomplete: "전체 값을 아직 불러오지 못했습니다. 기다리거나 셀 상세 정보를 다시 여세요.",
+ unsafeNumber: "이 숫자는 안전하게 표현할 수 없습니다. 정밀도를 유지하려면 텍스트로 조회하세요.",
+ tooLarge: "변환 한도 초과: 입력 {maxInput}자, 출력 {maxOutput}자, 정수 입력 {maxRadixDigits}자입니다.",
+ invalid: "변환할 수 없습니다. 입력 형식과 변환 옵션을 확인하세요.",
+ invalidTimestamp: "지원하는 날짜 범위 내의 정수 타임스탬프를 입력하세요.",
+ ambiguousUnit: "단위를 확인할 수 없습니다. 초 또는 밀리초를 선택하세요.",
+ invalidInteger: "선택한 원본 진법에 맞는 정수를 접두사 없이 입력하세요.",
+ invalidBase64: "유효한 UTF-8 텍스트를 포함하는 표준 패딩 Base64를 입력하세요.",
+ },
+ },
customType: {
kinds: {
base: "기본형",
diff --git a/apps/desktop/src/i18n/locales/pt-BR.ts b/apps/desktop/src/i18n/locales/pt-BR.ts
index 931ffb3c50..9e33fd5788 100644
--- a/apps/desktop/src/i18n/locales/pt-BR.ts
+++ b/apps/desktop/src/i18n/locales/pt-BR.ts
@@ -83,6 +83,48 @@ const consul = {
};
export default withEnglishFallback({
+ cellTransform: {
+ title: "Prévia da conversão",
+ description: "Converte o valor atual para visualizar ou copiar. O valor original e o rascunho permanecem inalterados.",
+ format: "Conversão",
+ unit: "Unidade do timestamp",
+ timezone: "Fuso horário",
+ pattern: "Formato de data",
+ fromBase: "Base de origem",
+ toBase: "Base de destino",
+ convert: "Converter",
+ result: "Resultado",
+ copy: "Copiar resultado",
+ radixHint: "Somente inteiros. Insira dígitos sem os prefixos 0x, 0o ou 0b; um sinal opcional é permitido.",
+ urlHint: "Codificação de componentes URL em UTF-8. A decodificação preserva + como sinal de adição.",
+ kinds: {
+ timestamp: "Timestamp → data/hora",
+ json: "Formatar JSON",
+ jsonCompact: "Compactar JSON",
+ xml: "Formatar XML",
+ base64Encode: "Texto → Base64 (UTF-8)",
+ base64Decode: "Base64 → texto (UTF-8)",
+ urlEncode: "Codificar componente URL",
+ urlDecode: "Decodificar componente URL",
+ radix: "Conversão de base de inteiros",
+ },
+ units: {
+ auto: "Automática (10/13 dígitos)",
+ seconds: "Segundos",
+ milliseconds: "Milissegundos",
+ },
+ errors: {
+ nullSource: "NULL não contém texto para converter.",
+ incomplete: "O valor completo ainda não foi carregado. Aguarde ou reabra os detalhes da célula.",
+ unsafeNumber: "Este número não pode ser representado com precisão. Consulte-o como texto para preservá-la.",
+ tooLarge: "Limite de conversão excedido: {maxInput} caracteres de entrada, {maxOutput} de saída ou {maxRadixDigits} para inteiros.",
+ invalid: "Não foi possível converter. Verifique o formato de entrada e as opções.",
+ invalidTimestamp: "Insira um timestamp inteiro dentro do intervalo de datas compatível.",
+ ambiguousUnit: "Não foi possível determinar a unidade. Selecione segundos ou milissegundos.",
+ invalidInteger: "Insira um inteiro válido para a base de origem, sem prefixo.",
+ invalidBase64: "Insira Base64 padrão com preenchimento contendo texto UTF-8 válido.",
+ },
+ },
customType: {
kinds: {
base: "Base",
diff --git a/apps/desktop/src/i18n/locales/tr.ts b/apps/desktop/src/i18n/locales/tr.ts
index 8bac4995aa..3cdca0a18e 100644
--- a/apps/desktop/src/i18n/locales/tr.ts
+++ b/apps/desktop/src/i18n/locales/tr.ts
@@ -82,6 +82,48 @@ const consul = {
};
export default withEnglishFallback({
+ cellTransform: {
+ title: "Dönüştürme önizlemesi",
+ description: "Geçerli değeri görüntülemek veya kopyalamak için dönüştürür. Özgün değer ve düzenleme taslağı değişmez.",
+ format: "Dönüştürme",
+ unit: "Zaman damgası birimi",
+ timezone: "Saat dilimi",
+ pattern: "Tarih biçimi",
+ fromBase: "Kaynak taban",
+ toBase: "Hedef taban",
+ convert: "Dönüştür",
+ result: "Sonuç",
+ copy: "Sonucu kopyala",
+ radixHint: "Yalnızca tam sayılar. 0x, 0o veya 0b öneki olmadan rakam girin; isteğe bağlı işaret kullanılabilir.",
+ urlHint: "URL bileşenleri UTF-8 ile kodlanır veya çözülür. Çözme işlemi + işaretini boşluğa dönüştürmez.",
+ kinds: {
+ timestamp: "Zaman damgası → tarih/saat",
+ json: "JSON biçimlendir",
+ jsonCompact: "JSON sıkıştır",
+ xml: "XML biçimlendir",
+ base64Encode: "Metin → Base64 (UTF-8)",
+ base64Decode: "Base64 → metin (UTF-8)",
+ urlEncode: "URL bileşenini kodla",
+ urlDecode: "URL bileşeninin kodunu çöz",
+ radix: "Tam sayı taban dönüşümü",
+ },
+ units: {
+ auto: "Otomatik (10/13 hane)",
+ seconds: "Saniye",
+ milliseconds: "Milisaniye",
+ },
+ errors: {
+ nullSource: "NULL dönüştürülebilecek metin içermez.",
+ incomplete: "Değerin tamamı henüz yüklenmedi. Bekleyin veya hücre ayrıntılarını yeniden açın.",
+ unsafeNumber: "Bu sayı güvenli biçimde temsil edilemiyor. Hassasiyeti korumak için metin olarak sorgulayın.",
+ tooLarge: "Dönüştürme sınırı aşıldı: girdi {maxInput} karakter, çıktı {maxOutput} karakter veya tam sayı girdisi {maxRadixDigits} karakter.",
+ invalid: "Dönüştürülemiyor. Girdi biçimini ve dönüştürme seçeneklerini kontrol edin.",
+ invalidTimestamp: "Desteklenen tarih aralığında bir tam sayı zaman damgası girin.",
+ ambiguousUnit: "Birim belirlenemiyor. Saniye veya milisaniyeyi seçin.",
+ invalidInteger: "Kaynak tabana uygun bir tam sayıyı öneksiz girin.",
+ invalidBase64: "Geçerli UTF-8 metni içeren standart dolgulu Base64 girin.",
+ },
+ },
customType: {
kinds: {
base: "Temel",
diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts
index 1fc83c25b9..41b7ee6c48 100644
--- a/apps/desktop/src/i18n/locales/zh-CN.ts
+++ b/apps/desktop/src/i18n/locales/zh-CN.ts
@@ -5,6 +5,48 @@ import { consul } from "./consulZhCN";
import { meilisearchManagementZhCN } from "./meilisearchManagement";
export default withEnglishFallback({
+ cellTransform: {
+ title: "转换预览",
+ description: "将当前内容转换后查看或复制,不改变原值和编辑草稿。",
+ format: "转换方式",
+ unit: "时间戳单位",
+ timezone: "时区",
+ pattern: "日期格式",
+ fromBase: "原进制",
+ toBase: "目标进制",
+ convert: "转换",
+ result: "转换结果",
+ copy: "复制结果",
+ radixHint: "仅支持整数,请勿输入 0x、0o 或 0b 前缀,可使用正负号。",
+ urlHint: "按 URL 组件进行 UTF-8 编解码,解码时保留加号,不将其替换为空格。",
+ kinds: {
+ timestamp: "时间戳 → 日期时间",
+ json: "JSON 格式化",
+ jsonCompact: "JSON 压缩",
+ xml: "XML 格式化",
+ base64Encode: "文本 → Base64(UTF-8)",
+ base64Decode: "Base64 → 文本(UTF-8)",
+ urlEncode: "URL 组件编码",
+ urlDecode: "URL 组件解码",
+ radix: "整数进制转换",
+ },
+ units: {
+ auto: "自动(10/13 位)",
+ seconds: "秒",
+ milliseconds: "毫秒",
+ },
+ errors: {
+ nullSource: "NULL 没有可转换的文本。",
+ incomplete: "完整值尚未加载,请等待加载完成或重新打开单元格详情。",
+ unsafeNumber: "该数值无法安全表示,请以文本形式查询以保留精度。",
+ tooLarge: "超过转换限制:输入 {maxInput} 字符、输出 {maxOutput} 字符,整数输入 {maxRadixDigits} 字符。",
+ invalid: "无法转换,请检查输入格式和转换选项。",
+ invalidTimestamp: "请输入有效日期范围内的整数时间戳。",
+ ambiguousUnit: "无法确定时间戳单位,请手动选择秒或毫秒。",
+ invalidInteger: "请输入符合原进制的整数,不要包含进制前缀。",
+ invalidBase64: "请输入带标准填充的 Base64,且解码内容必须为有效 UTF-8 文本。",
+ },
+ },
redisGrouping,
customType: {
kinds: {
diff --git a/apps/desktop/src/i18n/locales/zh-TW.ts b/apps/desktop/src/i18n/locales/zh-TW.ts
index 9ee98537ab..b5c513d475 100644
--- a/apps/desktop/src/i18n/locales/zh-TW.ts
+++ b/apps/desktop/src/i18n/locales/zh-TW.ts
@@ -82,6 +82,48 @@ const consul = {
};
export default withEnglishFallback({
+ cellTransform: {
+ title: "轉換預覽",
+ description: "將目前內容轉換後檢視或複製,不改變原值和編輯草稿。",
+ format: "轉換方式",
+ unit: "時間戳記單位",
+ timezone: "時區",
+ pattern: "日期格式",
+ fromBase: "原進位",
+ toBase: "目標進位",
+ convert: "轉換",
+ result: "轉換結果",
+ copy: "複製結果",
+ radixHint: "僅支援整數,請勿輸入 0x、0o 或 0b 前綴,可使用正負號。",
+ urlHint: "按 URL 元件進行 UTF-8 編解碼,解碼時保留加號,不將其替換為空格。",
+ kinds: {
+ timestamp: "時間戳記 → 日期時間",
+ json: "JSON 格式化",
+ jsonCompact: "JSON 壓縮",
+ xml: "XML 格式化",
+ base64Encode: "文字 → Base64(UTF-8)",
+ base64Decode: "Base64 → 文字(UTF-8)",
+ urlEncode: "URL 元件編碼",
+ urlDecode: "URL 元件解碼",
+ radix: "整數進位轉換",
+ },
+ units: {
+ auto: "自動(10/13 位)",
+ seconds: "秒",
+ milliseconds: "毫秒",
+ },
+ errors: {
+ nullSource: "NULL 沒有可轉換的文字。",
+ incomplete: "完整值尚未載入,請等待載入完成或重新開啟儲存格詳細資料。",
+ unsafeNumber: "該數值無法安全表示,請以文字形式查詢以保留精確度。",
+ tooLarge: "超過轉換限制:輸入 {maxInput} 字元、輸出 {maxOutput} 字元,整數輸入 {maxRadixDigits} 字元。",
+ invalid: "無法轉換,請檢查輸入格式和轉換選項。",
+ invalidTimestamp: "請輸入有效日期範圍內的整數時間戳記。",
+ ambiguousUnit: "無法確定時間戳記單位,請手動選擇秒或毫秒。",
+ invalidInteger: "請輸入符合原進位的整數,不要包含進位前綴。",
+ invalidBase64: "請輸入帶標準填補的 Base64,且解碼內容必須為有效 UTF-8 文字。",
+ },
+ },
redisGrouping,
customType: {
kinds: {
diff --git a/apps/desktop/src/lib/dataGrid/cellValueTransform.ts b/apps/desktop/src/lib/dataGrid/cellValueTransform.ts
new file mode 100644
index 0000000000..dd69ba8cd9
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/cellValueTransform.ts
@@ -0,0 +1,114 @@
+import { formatJsonSource } from "@/lib/common/safeJsonFormat";
+import { formatXmlSource } from "@/lib/common/xmlFormat";
+import { applyColumnFormatter, DataGridDateTimePatterns } from "@/lib/dataGrid/columnFormatter";
+
+export const CELL_TRANSFORM_MAX_INPUT = 50_000;
+export const CELL_TRANSFORM_MAX_OUTPUT = 200_000;
+export const CELL_TRANSFORM_MAX_RADIX_DIGITS = 4_096;
+export const CELL_TRANSFORM_KINDS = ["timestamp", "json", "jsonCompact", "xml", "base64Encode", "base64Decode", "urlEncode", "urlDecode", "radix"] as const;
+export type CellTransformKind = (typeof CELL_TRANSFORM_KINDS)[number];
+export type CellTransformError = "tooLarge" | "invalid" | "invalidTimestamp" | "ambiguousUnit" | "invalidInteger" | "invalidBase64";
+export interface CellTransformOptions {
+ kind: CellTransformKind;
+ unit?: "auto" | "seconds" | "milliseconds";
+ timezone?: string;
+ pattern?: string;
+ fromBase?: number;
+ toBase?: number;
+}
+export type CellTransformResult = { ok: true; text: string; unit?: "seconds" | "milliseconds" } | { ok: false; error: CellTransformError };
+
+function fail(error: CellTransformError): never {
+ throw new TransformError(error);
+}
+class TransformError extends Error {
+ constructor(readonly code: CellTransformError) {
+ super(code);
+ }
+}
+
+/** Pure, opt-in text conversion. Never feed this result into the cell commit path. */
+export function transformCellValue(source: string, options: CellTransformOptions): CellTransformResult {
+ if (source.length > CELL_TRANSFORM_MAX_INPUT) return { ok: false, error: "tooLarge" };
+ try {
+ let text: string;
+ let unit: "seconds" | "milliseconds" | undefined;
+ switch (options.kind) {
+ case "timestamp": {
+ const input = source.trim();
+ if (!/^[+-]?\d+$/.test(input)) fail("invalidTimestamp");
+ unit = options.unit === "seconds" || options.unit === "milliseconds" ? options.unit : undefined;
+ if (!unit) {
+ const digits = input.replace(/^[+-]/, "").length;
+ if (digits !== 10 && digits !== 13) fail("ambiguousUnit");
+ unit = digits === 10 ? "seconds" : "milliseconds";
+ }
+ const value = Number(input);
+ const milliseconds = unit === "seconds" ? value * 1000 : value;
+ if (!Number.isSafeInteger(value) || !Number.isSafeInteger(milliseconds) || Math.abs(milliseconds) > 8_640_000_000_000_000) fail("invalidTimestamp");
+ const timezone = options.timezone === undefined ? "UTC" : options.timezone.trim();
+ new Intl.DateTimeFormat("en", { timeZone: timezone }).format(0);
+ const pattern = options.pattern || "YYYY-MM-DD HH:mm:ss";
+ if (!DataGridDateTimePatterns.includes(pattern)) fail("invalidTimestamp");
+ text = applyColumnFormatter(value, { kind: "datetime", unit, timezone, pattern });
+ // Column formatters intentionally fall back to the raw value. A conversion
+ // must surface failure instead of presenting that fallback as a result.
+ if (text === String(value) || text === "Invalid Date") fail("invalidTimestamp");
+ break;
+ }
+ case "json":
+ text = formatJsonSource(source, 2);
+ break;
+ case "jsonCompact":
+ text = formatJsonSource(source);
+ break;
+ case "xml":
+ text = formatXmlSource(source);
+ break;
+ case "urlEncode":
+ text = encodeURIComponent(source);
+ break;
+ case "urlDecode":
+ text = decodeURIComponent(source);
+ break;
+ case "base64Encode": {
+ // Reject lone surrogates rather than silently replacing them during UTF-8 encoding.
+ encodeURIComponent(source);
+ const bytes = new TextEncoder().encode(source);
+ text = btoa(Array.from(bytes, (byte) => String.fromCharCode(byte)).join(""));
+ break;
+ }
+ case "base64Decode": {
+ const input = source.replace(/\s/g, "");
+ if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(input)) fail("invalidBase64");
+ const binary = atob(input);
+ if (btoa(binary) !== input) fail("invalidBase64");
+ try {
+ text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(Uint8Array.from(binary, (character) => character.charCodeAt(0)));
+ } catch {
+ fail("invalidBase64");
+ }
+ break;
+ }
+ case "radix": {
+ const from = options.fromBase ?? 10;
+ const to = options.toBase ?? 16;
+ if (![2, 8, 10, 16].includes(from) || ![2, 8, 10, 16].includes(to)) fail("invalidInteger");
+ const input = source.trim();
+ if (input.length > CELL_TRANSFORM_MAX_RADIX_DIGITS) fail("tooLarge");
+ const sign = input.startsWith("-") ? -1n : 1n;
+ const digits = input.replace(/^[+-]/, "");
+ const valid = from === 2 ? /^[01]+$/ : from === 8 ? /^[0-7]+$/ : from === 10 ? /^\d+$/ : /^[0-9a-f]+$/i;
+ if (!valid.test(digits)) fail("invalidInteger");
+ const prefix = from === 2 ? "0b" : from === 8 ? "0o" : from === 16 ? "0x" : "";
+ text = (sign * BigInt(prefix + digits)).toString(to);
+ break;
+ }
+ default:
+ return { ok: false, error: "invalid" };
+ }
+ return text.length > CELL_TRANSFORM_MAX_OUTPUT ? { ok: false, error: "tooLarge" } : { ok: true, text, ...(unit ? { unit } : {}) };
+ } catch (error) {
+ return { ok: false, error: error instanceof TransformError ? error.code : "invalid" };
+ }
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridDetail.ts b/apps/desktop/src/lib/dataGrid/dataGridDetail.ts
index 051bcc3b99..978f847f10 100644
--- a/apps/desktop/src/lib/dataGrid/dataGridDetail.ts
+++ b/apps/desktop/src/lib/dataGrid/dataGridDetail.ts
@@ -19,6 +19,8 @@ export interface DataGridCellDetail {
displayValue: string;
displayValuePreview: string;
isValuePreviewTruncated: boolean;
+ /** True only while the backend value is incomplete, not when the UI clips its preview. */
+ isSourceTruncated?: boolean;
imagePreviewUrl: string | null;
length: number;
isNull?: boolean;
@@ -119,6 +121,7 @@ export function buildDataGridCellDetail(options: BuildDataGridCellDetailOptions)
rawValuePreview,
displayValue,
displayValuePreview,
+ isSourceTruncated: options.isValuePreviewTruncated === true,
isValuePreviewTruncated: options.isValuePreviewTruncated === true || rawValuePreview.length < rawValue.length || displayValuePreview.length < displayValue.length,
imagePreviewUrl: cellImagePreviewUrl(value, type, {
binary: options.includeBinaryImagePreview !== false,
diff --git a/packages/app-tests/cellValueTransform.test.ts b/packages/app-tests/cellValueTransform.test.ts
new file mode 100644
index 0000000000..be62f9b02b
--- /dev/null
+++ b/packages/app-tests/cellValueTransform.test.ts
@@ -0,0 +1,169 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+
+import { CELL_TRANSFORM_MAX_INPUT, CELL_TRANSFORM_MAX_OUTPUT, transformCellValue } from "../../apps/desktop/src/lib/dataGrid/cellValueTransform.ts";
+
+test("timestamp auto-detects 10-digit values as seconds", () => {
+ assert.deepEqual(transformCellValue("1700000000", { kind: "timestamp" }), { ok: true, text: "2023-11-14 22:13:20", unit: "seconds" });
+});
+
+test("timestamp auto-detects 13-digit values as milliseconds", () => {
+ assert.deepEqual(transformCellValue("1700000000000", { kind: "timestamp" }), { ok: true, text: "2023-11-14 22:13:20", unit: "milliseconds" });
+});
+
+test("timestamp honors an explicit unit regardless of digit count", () => {
+ assert.deepEqual(transformCellValue("1700000000", { kind: "timestamp", unit: "milliseconds" }), { ok: true, text: "1970-01-20 16:13:20", unit: "milliseconds" });
+ assert.deepEqual(transformCellValue("1700000000000", { kind: "timestamp", unit: "seconds" }), { ok: true, text: "55840-11-08 22:13:20", unit: "seconds" });
+});
+
+test("timestamp reports ambiguousUnit when auto mode cannot pick a unit", () => {
+ assert.deepEqual(transformCellValue("17000000000", { kind: "timestamp" }), { ok: false, error: "ambiguousUnit" });
+ assert.deepEqual(transformCellValue("123", { kind: "timestamp" }), { ok: false, error: "ambiguousUnit" });
+});
+
+test("timestamp rejects non-integer input", () => {
+ assert.deepEqual(transformCellValue("not-a-timestamp", { kind: "timestamp" }), { ok: false, error: "invalidTimestamp" });
+ assert.deepEqual(transformCellValue("1700000000.5", { kind: "timestamp", unit: "seconds" }), { ok: false, error: "invalidTimestamp" });
+});
+
+test("timestamp formats in a valid timezone and defaults to UTC", () => {
+ assert.deepEqual(transformCellValue("1700000000", { kind: "timestamp", timezone: "Asia/Shanghai" }), { ok: true, text: "2023-11-15 06:13:20", unit: "seconds" });
+ assert.deepEqual(transformCellValue("1700000000", { kind: "timestamp", timezone: " UTC " }), { ok: true, text: "2023-11-14 22:13:20", unit: "seconds" });
+});
+
+test("timestamp rejects an unknown timezone", () => {
+ assert.deepEqual(transformCellValue("1700000000", { kind: "timestamp", timezone: "Mars/Olympus" }), { ok: false, error: "invalid" });
+});
+
+test("timestamp rejects patterns outside the supported set", () => {
+ assert.deepEqual(transformCellValue("1700000000", { kind: "timestamp", pattern: "DD/MM/YYYY" }), { ok: false, error: "invalidTimestamp" });
+});
+
+test("timestamp formats with an allowed pattern", () => {
+ assert.deepEqual(transformCellValue("0", { kind: "timestamp", unit: "milliseconds", pattern: "YYYY-MM-DDTHH:mm:ssZ" }), { ok: true, text: "1970-01-01T00:00:00+00:00", unit: "milliseconds" });
+});
+
+test("timestamp converts negative epochs before 1970", () => {
+ assert.deepEqual(transformCellValue("-86400", { kind: "timestamp", unit: "seconds" }), { ok: true, text: "1969-12-31 00:00:00", unit: "seconds" });
+ assert.deepEqual(transformCellValue("-1000000000", { kind: "timestamp" }), { ok: true, text: "1938-04-24 22:13:20", unit: "seconds" });
+});
+
+test("timestamp rejects values beyond the supported millisecond range", () => {
+ assert.deepEqual(transformCellValue("8640000000000001", { kind: "timestamp", unit: "milliseconds" }), { ok: false, error: "invalidTimestamp" });
+ assert.deepEqual(transformCellValue("-8640000000000001", { kind: "timestamp", unit: "milliseconds" }), { ok: false, error: "invalidTimestamp" });
+ assert.deepEqual(transformCellValue("100000000000000", { kind: "timestamp", unit: "seconds" }), { ok: false, error: "invalidTimestamp" });
+});
+
+test("timestamp accepts the exact millisecond range boundary", () => {
+ assert.deepEqual(transformCellValue("8640000000000000", { kind: "timestamp", unit: "milliseconds" }), { ok: true, text: "275760-09-13 00:00:00", unit: "milliseconds" });
+});
+
+test("json pretty-prints and preserves large integer literals", () => {
+ const result = transformCellValue('{"id":123456789012345678901234567890,"tags":[1,2]}', { kind: "json" });
+ assert.ok(result.ok);
+ assert.equal(result.text, '{\n "id": 123456789012345678901234567890,\n "tags": [\n 1,\n 2\n ]\n}');
+ assert.equal(result.text.includes('"123456789012345678901234567890"'), false);
+});
+
+test("jsonCompact collapses whitespace while preserving source order", () => {
+ assert.deepEqual(transformCellValue('{ "b" : 1, "a" : [ 1, 2 ] }', { kind: "jsonCompact" }), { ok: true, text: '{"b":1,"a":[1,2]}' });
+});
+
+test("json rejects malformed documents", () => {
+ assert.deepEqual(transformCellValue('{"id":', { kind: "json" }), { ok: false, error: "invalid" });
+ assert.deepEqual(transformCellValue('{"a":1} trailing', { kind: "jsonCompact" }), { ok: false, error: "invalid" });
+});
+
+test("xml reformats markup without touching text nodes", () => {
+ const result = transformCellValue("<a><b>1</b><c><d/></c></a>", { kind: "xml" });
+ assert.ok(result.ok);
+ assert.equal(result.text, "<a>\n <b>1</b>\n <c>\n <d/>\n </c>\n</a>");
+});
+
+test("xml rejects malformed markup", () => {
+ assert.deepEqual(transformCellValue("<a><b>1</b>", { kind: "xml" }), { ok: false, error: "invalid" });
+ assert.deepEqual(transformCellValue("<a></b>", { kind: "xml" }), { ok: false, error: "invalid" });
+});
+
+test("base64 round-trips CJK text and emoji", () => {
+ const encoded = transformCellValue("你好😀", { kind: "base64Encode" });
+ assert.deepEqual(encoded, { ok: true, text: "5L2g5aW98J+YgA==" });
+ const decoded = transformCellValue("5L2g5aW98J+YgA==", { kind: "base64Decode" });
+ assert.deepEqual(decoded, { ok: true, text: "你好😀" });
+});
+
+test("base64Encode rejects lone surrogates instead of replacing them", () => {
+ assert.deepEqual(transformCellValue("\uD800", { kind: "base64Encode" }), { ok: false, error: "invalid" });
+});
+
+test("base64Decode tolerates whitespace inside the alphabet", () => {
+ assert.deepEqual(transformCellValue("5L2g\n 5aW9", { kind: "base64Decode" }), { ok: true, text: "你好" });
+});
+
+test("base64Decode rejects unpadded, url-safe, and non-UTF-8 input", () => {
+ assert.deepEqual(transformCellValue("5L2g5aW", { kind: "base64Decode" }), { ok: false, error: "invalidBase64" });
+ assert.deepEqual(transformCellValue("5L2g5aW-", { kind: "base64Decode" }), { ok: false, error: "invalidBase64" });
+ assert.deepEqual(transformCellValue("5L2g5a_9", { kind: "base64Decode" }), { ok: false, error: "invalidBase64" });
+ // "/w==" decodes to the single byte 0xFF, which is not valid UTF-8.
+ assert.deepEqual(transformCellValue("/w==", { kind: "base64Decode" }), { ok: false, error: "invalidBase64" });
+});
+
+test("url encode and decode round-trip as URL components", () => {
+ const source = "a b/c?x=1&y=中";
+ assert.deepEqual(transformCellValue(source, { kind: "urlEncode" }), { ok: true, text: "a%20b%2Fc%3Fx%3D1%26y%3D%E4%B8%AD" });
+ assert.deepEqual(transformCellValue("a%20b%2Fc%3Fx%3D1%26y%3D%E4%B8%AD", { kind: "urlDecode" }), { ok: true, text: source });
+});
+
+test("urlDecode preserves plus signs instead of mapping them to spaces", () => {
+ assert.deepEqual(transformCellValue("1+1=2", { kind: "urlDecode" }), { ok: true, text: "1+1=2" });
+ assert.deepEqual(transformCellValue("%2B", { kind: "urlDecode" }), { ok: true, text: "+" });
+});
+
+test("urlDecode rejects truncated percent escapes", () => {
+ assert.deepEqual(transformCellValue("100%", { kind: "urlDecode" }), { ok: false, error: "invalid" });
+ assert.deepEqual(transformCellValue("%E4%B8", { kind: "urlDecode" }), { ok: false, error: "invalid" });
+});
+
+test("radix converts between supported bases without prefixes in the output", () => {
+ assert.deepEqual(transformCellValue("255", { kind: "radix", fromBase: 10, toBase: 16 }), { ok: true, text: "ff" });
+ assert.deepEqual(transformCellValue("ff", { kind: "radix", fromBase: 16, toBase: 10 }), { ok: true, text: "255" });
+ assert.deepEqual(transformCellValue("10", { kind: "radix", fromBase: 10, toBase: 2 }), { ok: true, text: "1010" });
+ assert.deepEqual(transformCellValue("777", { kind: "radix", fromBase: 8, toBase: 10 }), { ok: true, text: "511" });
+});
+
+test("radix applies signs and rejects base prefixes in the input", () => {
+ assert.deepEqual(transformCellValue("-ff", { kind: "radix", fromBase: 16, toBase: 10 }), { ok: true, text: "-255" });
+ assert.deepEqual(transformCellValue("+255", { kind: "radix", fromBase: 10, toBase: 16 }), { ok: true, text: "ff" });
+ assert.deepEqual(transformCellValue("0xff", { kind: "radix", fromBase: 16, toBase: 10 }), { ok: false, error: "invalidInteger" });
+ assert.deepEqual(transformCellValue("0b101", { kind: "radix", fromBase: 2, toBase: 10 }), { ok: false, error: "invalidInteger" });
+ assert.deepEqual(transformCellValue("9", { kind: "radix", fromBase: 8, toBase: 10 }), { ok: false, error: "invalidInteger" });
+ assert.deepEqual(transformCellValue("256", { kind: "radix", fromBase: 10, toBase: 3 }), { ok: false, error: "invalidInteger" });
+});
+
+test("radix stays exact beyond Number.MAX_SAFE_INTEGER via BigInt", () => {
+ const decimal = "123456789012345678901234567890";
+ const hex = transformCellValue(decimal, { kind: "radix", fromBase: 10, toBase: 16 });
+ assert.deepEqual(hex, { ok: true, text: "18ee90ff6c373e0ee4e3f0ad2" });
+ const roundTrip = transformCellValue("18ee90ff6c373e0ee4e3f0ad2", { kind: "radix", fromBase: 16, toBase: 10 });
+ assert.deepEqual(roundTrip, { ok: true, text: decimal });
+});
+
+test("radix enforces the integer digit cap", () => {
+ assert.deepEqual(transformCellValue("0".repeat(4097), { kind: "radix", fromBase: 10, toBase: 16 }), { ok: false, error: "tooLarge" });
+ assert.deepEqual(transformCellValue("0".repeat(4096), { kind: "radix", fromBase: 10, toBase: 16 }), { ok: true, text: "0" });
+});
+
+test("inputs beyond the input cap fail closed", () => {
+ assert.equal(CELL_TRANSFORM_MAX_INPUT, 50_000);
+ assert.deepEqual(transformCellValue("a".repeat(CELL_TRANSFORM_MAX_INPUT + 1), { kind: "base64Encode" }), { ok: false, error: "tooLarge" });
+ assert.equal(transformCellValue("a".repeat(CELL_TRANSFORM_MAX_INPUT), { kind: "base64Encode" }).ok, true);
+});
+
+test("outputs beyond the output cap fail closed", () => {
+ assert.equal(CELL_TRANSFORM_MAX_OUTPUT, 200_000);
+ // Each CJK character expands to nine percent-escaped output characters.
+ const justUnder = "中".repeat(22_222); // 199,998 output characters
+ const justOver = "中".repeat(22_223); // 200,007 output characters
+ assert.equal(transformCellValue(justUnder, { kind: "urlEncode" }).ok, true);
+ assert.deepEqual(transformCellValue(justOver, { kind: "urlEncode" }), { ok: false, error: "tooLarge" });
+});
diff --git a/packages/app-tests/dataGridDetail.test.ts b/packages/app-tests/dataGridDetail.test.ts
index 63df7524e9..0d719749e9 100644
--- a/packages/app-tests/dataGridDetail.test.ts
+++ b/packages/app-tests/dataGridDetail.test.ts
@@ -45,6 +45,7 @@ test("buildDataGridCellDetail preserves full value metadata", () => {
rawValuePreview: '{"ok":true,"items":[1,2]}',
displayValue: 'formatted:{"ok":tr',
displayValuePreview: 'formatted:{"ok":tr',
+ isSourceTruncated: false,
isValuePreviewTruncated: false,
imagePreviewUrl: null,
length: 25,