viur-ui 0.0.1 → 0.0.2

package/src/components/DataTable/ViurDataTable.d.vue.ts

@@ -1,69 +1,69 @@
 import type { DefineComponent, Ref } from "vue"
-import type { Row, RowKey } from "./types"
+import type { Row, RowKey } from "./types.ts"
 
-/** Props von ViurDataTable.vue (siehe defineProps dort). */
+/** Props of ViurDataTable.vue (see defineProps there). */
 export interface ViurDataTableProps {
-  /** Modulname bzw. Punkt-Pfad ("user", "shop.order"). */
+  /** Module name or dot path ("user", "shop.order"). */
   module: string
-  /** Renderer der Requests; Standard: VITE_DEFAULT_RENDERER. */
+  /** Renderer for the requests; default: VITE_DEFAULT_RENDERER. */
   renderer?: string | null
-  /** Untertyp gruppierter Listen (Handler `list.grouped`). */
+  /** Subtype of grouped lists (handler `list.grouped`). */
   group?: string | null
-  /** Zusätzliche Request-Parameter — bei jedem Abruf gespreadet. */
+  /** Additional request parameters — spread into every fetch. */
   params?: Record<string, unknown>
-  /** Spalten; ohne Angabe aus der viewSkel-Struktur abgeleitet. */
+  /** Columns; if not given, derived from the viewSkel structure. */
   columns?: unknown[] | null
-  /** Nur diese Bones als Spalten (bei abgeleiteten Spalten). */
+  /** Only these bones as columns (for derived columns). */
   bones?: string[] | null
   label?: string | null
   selectable?: false | "single" | "multiple"
-  /** Einträge je Nachladen (ViUR `limit`). */
+  /** Entries per load (ViUR `limit`). */
   pageSize?: number
-  /** Obergrenze des Lokal-Modus (alles geladen → Client-Pipeline). */
+  /** Upper limit for local mode (everything loaded → client pipeline). */
   localModeLimit?: number
-  /** X-VIUR-BONELIST senden, wenn Felder abgewählt sind (Server braucht ein "*"-Subskel). */
+  /** Send X-VIUR-BONELIST when fields are deselected (server needs a "*" subskel). */
   bonelist?: boolean
-  /** localStorage-Key der Feld-Sichtbarkeit; null = keine Persistenz. */
+  /** localStorage key for field visibility; null = no persistence. */
   storageKey?: string | null
   language?: string | null
-  /** Steht bei language="*" vorn (üblicherweise die UI-Sprache). */
+  /** Comes first with language="*" (usually the UI language). */
   primaryLanguage?: string | null
   locale?: string | null
-  /** Spaltenbreite ziehbar (Default true — anders als die nackte DataTable). */
+  /** Column width draggable (default true — unlike the bare DataTable). */
   resizable?: boolean
-  /** Spalten per Drag umsortierbar (Default true). */
+  /** Columns reorderable via drag (default true). */
   reorderable?: boolean
-  /** Spalten anpinnbar (Default true). */
+  /** Columns pinnable (default true). */
   pinnable?: boolean
-  /** Wird an die DataTable durchgereicht. */
+  /** Passed through to the DataTable. */
   tableProps?: Record<string, unknown>
 }
 
 export interface ViurDataTableEmitProps<R extends Row = Row> {
-  /** Doppelklick auf eine Zeile. */
+  /** Double-click on a row. */
   onOpen?: (payload: { row: R; key: RowKey }) => void
   /** v-model:selectedKeys */
   "onUpdate:selectedKeys"?: (value: RowKey[]) => void
 }
 
-/** Was ViurDataTable per defineExpose freigibt. */
+/** What ViurDataTable exposes via defineExpose. */
 export interface ViurDataTableApi<R extends Row = Row> {
-  /** Der ListRequest (useListFetch): data, structure, cursor, execute, … */
+  /** The ListRequest (useListFetch): data, structure, cursor, execute, … */
   list: Record<string, unknown>
-  /** Template-Ref auf die DataTable (DataTableApi). */
+  /** Template ref to the DataTable (DataTableApi). */
   table: Ref<unknown>
-  /** Von vorn laden — mit den aktuellen props.params. */
+  /** Load from the start — with the current props.params. */
   refresh: () => Promise<unknown>
-  /** Suche: serverseitig (ViUR `search`) bzw. lokal, wenn alles geladen. */
+  /** Search: server-side (ViUR `search`) or local, if everything is loaded. */
   search: (term: string) => void
-  /** Feld-Sichtbarkeit (z.B. für einen „Felder"-Dialog). */
+  /** Field visibility (e.g. for a "Fields" dialog). */
   columns: {
     all: () => { id: string; label: string; hidden: boolean }[]
     apply: (visibleIds: string[]) => void
   }
-  /** Beschriftung eines Eintrags (erster Textwert seiner Spalten). */
+  /** Label of an entry (first text value of its columns). */
   entryTitle: (key: RowKey) => string
-  /** Alles geladen → Sortieren/Filtern/Suchen laufen lokal. */
+  /** Everything loaded → sorting/filtering/searching run locally. */
   allLoaded: Ref<boolean>
   rows: Ref<R[]>
 }

package/src/components/DataTable/ViurDataTable.vue

@@ -1,7 +1,7 @@
 <template>
   <div class="vi-vdt">
-    <!-- Struktur kam nicht an (Recht fehlt, unerwartete Antwort): Spalten sind
-         dann aus den Daten abgeleitet — Hinweis bleibt stehen. -->
+    <!-- Structure didn't arrive (missing permission, unexpected response): columns
+         are then derived from the data — the notice stays visible. -->
     <wa-callout
       v-if="notice"
       class="vi-vdt-notice"
@@ -53,61 +53,61 @@ import { computed, ref, watch } from "vue"
 import { useListFetch } from "../../request/index.js"
 import { useI18n } from "vue-i18n"
 import DataTable from "./DataTable.vue"
-import { columnsFromStructure } from "./viurColumns"
+import { columnsFromStructure } from "./viurColumns.ts"
 
-// ViurDataTable: dünner ViUR-Wrapper um die DataTable für LIST-Module
-// (Pendant zum ViurBrowser für Baum-Module): `module` rein, fertig. Enthält die komplette
-// Listen-Mechanik — Server-Sortierung/-Suche, Cursor-Nachladen, Lokal-Modus
-// (alles geladen → Sortieren/Filtern/Suchen clientseitig), Spalten aus der
-// Struktur, Feld-Sichtbarkeit inkl. optionaler Persistenz und optionalem
-// X-VIUR-BONELIST (Server serialisiert nur die sichtbaren Felder).
+// ViurDataTable: thin ViUR wrapper around the DataTable for LIST modules
+// (counterpart to ViurBrowser for tree modules): pass `module`, done. Contains the complete
+// list mechanics — server sorting/search, cursor-based loading, local mode
+// (everything loaded → sorting/filtering/searching client-side), columns from the
+// structure, field visibility incl. optional persistence and optional
+// X-VIUR-BONELIST (server serializes only the visible fields).
 
 const props = defineProps({
   module: { type: String, required: true },
   renderer: { type: String, default: null },
-  /** Untertyp gruppierter Listen (Handler `list.grouped`). */
+  /** Subtype of grouped lists (handler `list.grouped`). */
   group: { type: String, default: null },
-  /** Zusätzliche Request-Parameter — bei JEDEM Abruf gespreadet (z.B. der
-   *  Server-Context als @-Parameter). Änderungen greifen ab dem nächsten
-   *  Abruf; sofort neu laden macht `refresh()`. */
+  /** Additional request parameters — spread into EVERY fetch (e.g. the
+   *  server context as @ parameters). Changes take effect from the next
+   *  fetch; `refresh()` reloads immediately. */
   params: { type: Object, default: () => ({}) },
-  /** Spalten; ohne Angabe aus der viewSkel-Struktur abgeleitet. */
+  /** Columns; if not given, derived from the viewSkel structure. */
   columns: { type: Array, default: null },
-  /** Nur diese Bones als Spalten (bei abgeleiteten Spalten). */
+  /** Only these bones as columns (for derived columns). */
   bones: { type: Array, default: null },
-  /** Zugängliche Beschriftung; Standard: Modulname. */
+  /** Accessible label; default: module name. */
   label: { type: String, default: null },
   selectable: { type: [String, Boolean], default: "multiple" },
-  /** Einträge je Nachladen (ViUR `limit`). */
+  /** Entries per load (ViUR `limit`). */
   pageSize: { type: Number, default: 50 },
   /**
-   * Obergrenze für den Lokal-Modus: darüber bleiben Sortieren/Filtern/Suchen
-   * beim Server (der erste lokale Suchlauf schickt jede Zeile durch den
-   * Bone-Formatter — fünfstellig friert das den Main-Thread ein).
+   * Upper limit for local mode: above it, sorting/filtering/searching stay
+   * with the server (the first local search sends every row through the
+   * bone formatter — at five digits that freezes the main thread).
    */
   localModeLimit: { type: Number, default: 5_000 },
-  /** X-VIUR-BONELIST senden, wenn Felder abgewählt sind. NUR aktivieren, wenn
-   *  das Modul es serverseitig trägt ("*"-Subskel) — sonst antwortet der
-   *  Core mit 400. */
+  /** Send X-VIUR-BONELIST when fields are deselected. ONLY enable if
+   *  the module supports it server-side ("*" subskel) — otherwise the
+   *  core responds with 400. */
   bonelist: { type: Boolean, default: false },
-  /** localStorage-Key der Feld-Sichtbarkeit (gespeichert wird die
-   *  HIDDEN-Liste: neue Server-Felder erscheinen automatisch); null = keine
-   *  Persistenz. */
+  /** localStorage key for field visibility (the HIDDEN list is
+   *  stored: new server fields appear automatically); null = no
+   *  persistence. */
   storageKey: { type: String, default: null },
-  /** Sprache/Locale für Bone-Darstellung in den Spalten. */
+  /** Language/locale for bone rendering in the columns. */
   language: { type: String, default: null },
-  /** Steht bei language="*" vorn (üblicherweise die UI-Sprache). */
+  /** Comes first with language="*" (usually the UI language). */
   primaryLanguage: { type: String, default: null },
   locale: { type: String, default: null },
-  /** Spalten per Griff in der Kopfzeile breiter/schmaler ziehen. Anders als
-   *  bei der nackten DataTable (dort Opt-in) hier standardmäßig AN — die
-   *  ViurDataTable ist das Komfort-Widget. */
+  /** Drag columns wider/narrower via a handle in the header. Unlike the
+   *  bare DataTable (opt-in there), ON by default here — the
+   *  ViurDataTable is the convenience widget. */
   resizable: { type: Boolean, default: true },
-  /** Spalten per Drag umsortieren. */
+  /** Reorder columns via drag. */
   reorderable: { type: Boolean, default: true },
-  /** Spalten links/rechts anpinnen. */
+  /** Pin columns left/right. */
   pinnable: { type: Boolean, default: true },
-  /** Wird an die DataTable durchgereicht (überschreibt Einzel-Props). */
+  /** Passed through to the DataTable (overrides individual props). */
   tableProps: { type: Object, default: () => ({}) },
 })
 
@@ -119,12 +119,12 @@ const selectedKeys = defineModel("selectedKeys", { type: Array, default: () => [
 
 const sort = ref([])
 const limit = ref(Math.min(99, Number(props.params?.limit ?? props.pageSize) || 50))
-/** Serverseitiger Suchbegriff (ViUR `search`); leer = aus. */
+/** Server-side search term (ViUR `search`); empty = off. */
 const serverSearch = ref("")
-/** Client-Suche/-Filter — greifen NUR im vollständig geladenen Zustand. */
+/** Client search/filters — apply ONLY in the fully loaded state. */
 const clientSearch = ref("")
 const clientFilters = ref([])
-/** Ausgeblendete Spalten (Feldnamen). */
+/** Hidden columns (field names). */
 const hiddenFields = ref(loadHiddenFields())
 
 const list = useListFetch(props.module, {
@@ -137,7 +137,7 @@ const list = useListFetch(props.module, {
 
 const rows = computed(() => list.data.value)
 
-/** Alles geladen und klein genug → Lokal-Modus (Client-Pipeline der Tabelle). */
+/** Everything loaded and small enough → local mode (the table's client pipeline). */
 const allLoaded = computed(
   () =>
     rows.value.length > 0 &&
@@ -155,6 +155,7 @@ const effectiveColumns = computed(() => {
     ...(props.locale ? { locale: props.locale } : {}),
     exclude: ["key"],
     local: allLoaded.value,
+    boolTexts: [t("bones.bool.true"), t("bones.bool.false")],
   })
   if (derived.length) {
     return derived.map((column) => ({
@@ -171,7 +172,7 @@ const notice = computed(() =>
     : ""
 )
 
-/** Notfall-Spalten: die Felder des ersten Datensatzes, unformatiert. */
+/** Fallback columns: the fields of the first record, unformatted. */
 function fallbackColumns(row) {
   if (!row) return []
   return Object.keys(row)
@@ -179,7 +180,7 @@ function fallbackColumns(row) {
     .map((field) => ({ field, label: field, sortable: false, minWidth: 120, flex: 1 }))
 }
 
-/** Abrufparameter: props.params (Context etc.) + Suche + Sortierung + limit. */
+/** Fetch parameters: props.params (context etc.) + search + sorting + limit. */
 function requestParams(sortEntries = sort.value) {
   const params = { ...props.params, limit: limit.value }
   if (serverSearch.value) params.search = serverSearch.value
@@ -210,9 +211,9 @@ async function onLoadMore({ pages }) {
   await list.next(pages).catch(() => null)
 }
 
-// Zurück im Server-Modus (Reload, neuer Cursor, Server-Suche): lokale
-// Verfeinerungen zurücksetzen und Sortierungen entfernen, die der Server
-// nicht kann (nur indizierte, einwertige Bones).
+// Back in server mode (reload, new cursor, server search): reset local
+// refinements and remove sortings the server can't handle
+// (only indexed, single-valued bones).
 watch(allLoaded, (local) => {
   if (local) return
   clientSearch.value = ""
@@ -223,7 +224,7 @@ watch(allLoaded, (local) => {
   })
 })
 
-// ── Feld-Sichtbarkeit (+ optionale Persistenz, + optionale Bonelist) ─────────
+// ── Field visibility (+ optional persistence, + optional bonelist) ──────────
 function loadHiddenFields() {
   if (!props.storageKey) return []
   try {
@@ -244,7 +245,7 @@ function bonelistHeader() {
 }
 
 const columnsApi = {
-  /** Alle ein-/ausblendbaren Spalten mit aktuellem Zustand. */
+  /** All showable/hideable columns with their current state. */
   all: () =>
     effectiveColumns.value
       .filter((column) => column.hideable !== false)
@@ -253,7 +254,7 @@ const columnsApi = {
         label: String(column.label ?? column.field ?? column.id),
         hidden: column.hidden === true,
       })),
-  /** Sichtbare Spalten setzen (persistiert; mit Bonelist folgt ein Reload). */
+  /** Set visible columns (persisted; with bonelist a reload follows). */
   apply: (visibleIds) => {
     const visible = new Set(visibleIds)
     hiddenFields.value = effectiveColumns.value
@@ -263,14 +264,14 @@ const columnsApi = {
       try {
         localStorage.setItem(props.storageKey, JSON.stringify(hiddenFields.value))
       } catch {
-        // localStorage kann fehlen (Privatmodus) — dann eben nicht persistent.
+        // localStorage may be missing (private mode) — then just not persistent.
       }
     }
     if (props.bonelist) void list.filter(requestParams()).catch(() => null)
   },
 }
 
-/** Serverseitige Suche — bzw. lokal, wenn alles geladen ist. */
+/** Server-side search — or local, if everything is loaded. */
 function search(term) {
   const trimmed = String(term ?? "").trim()
   if (allLoaded.value) {
@@ -281,12 +282,12 @@ function search(term) {
   }
 }
 
-/** Von vorn laden — mit den AKTUELLEN props.params (Context etc.). */
+/** Load from the start — with the CURRENT props.params (context etc.). */
 function refresh() {
   return list.filter(requestParams())
 }
 
-/** Beschriftung eines Eintrags: erster Textwert seiner Spalten, sonst der Key. */
+/** Label of an entry: first text value of its columns, otherwise the key. */
 function entryTitle(key) {
   const row = rows.value.find((entry) => String(entry.key) === String(key))
   if (!row) return String(key)

package/src/components/DataTable/columns.ts

@@ -1,6 +1,6 @@
-// Reine Spalten-/Zell-Logik: Auflösen der Definitionen, Vergleich, Filter,
-// Facetten, Aggregation. Absichtlich frei von Vue — so ist der ganze
-// Datenpfad ohne DOM testbar.
+// Pure column/cell logic: resolving definitions, comparison, filters,
+// facets, aggregation. Deliberately free of Vue — so the whole
+// data path is testable without a DOM.
 
 import type {
   AggregationKind,
@@ -13,9 +13,9 @@ import type {
   Row,
   SortEntry,
   SortMode,
-} from "./types"
+} from "./types.ts"
 
-/** Wert über einen Punktpfad lesen ("user.name"). */
+/** Read a value via a dot path ("user.name"). */
 export function getPath(row: Row, path: string): unknown {
   if (!path.includes(".")) return row[path]
   let current: unknown = row
@@ -75,7 +75,7 @@ export function findColumn<R extends Row>(columns: ResolvedColumn<R>[], id: stri
   return columns.find((column) => column.id === id)
 }
 
-// ── Sortierung ────────────────────────────────────────────────────────
+// ── Sorting ───────────────────────────────────────────────────────────
 
 const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: "base" })
 const collatorCase = new Intl.Collator(undefined, { numeric: true })
@@ -92,11 +92,11 @@ export function isEmptyValue(value: unknown): boolean {
 }
 
 /**
- * Zusammengesetzte Zellwerte aufs Sortier-Atom reduzieren: bei Arrays zählt
- * der ERSTE Eintrag, bei einfachen Objekten der ERSTE Wert — rekursiv, bis ein
- * Primitivwert (oder Date) übrig ist. Damit sortieren `multiple`-Bones,
- * mehrsprachige Werte ({ de: "…" }) und relationale Bones ({ dest: { … } })
- * nach ihrem jeweils ersten Wert statt nach "[object Object]".
+ * Reduce composite cell values to the sort atom: for arrays the FIRST entry
+ * counts, for plain objects the FIRST value — recursively, until a primitive
+ * (or Date) remains. This way `multiple` bones, multilingual values
+ * ({ de: "…" }) and relational bones ({ dest: { … } }) sort by their
+ * respective first value instead of by "[object Object]".
  */
 export function firstValueOf(value: unknown, depth = 0): unknown {
   if (depth > 10 || value === null || value === undefined) return value
@@ -108,7 +108,7 @@ export function firstValueOf(value: unknown, depth = 0): unknown {
   return value
 }
 
-/** Vergleich zweier Zellwerte in einem der eingebauten Modi (aufsteigend). */
+/** Compare two cell values in one of the built-in modes (ascending). */
 export function compareValues(a: unknown, b: unknown, mode: SortMode = "auto"): number {
   switch (mode) {
     case "basic":
@@ -135,7 +135,7 @@ export function compareValues(a: unknown, b: unknown, mode: SortMode = "auto"):
       return collatorCase.compare(defaultText(a), defaultText(b))
     case "auto":
     default: {
-      // Arrays/Objekte: nach dem ersten Wert sortieren (siehe firstValueOf).
+      // Arrays/objects: sort by the first value (see firstValueOf).
       if (a !== null && typeof a === "object" && !(a instanceof Date)) a = firstValueOf(a)
       if (b !== null && typeof b === "object" && !(b instanceof Date)) b = firstValueOf(b)
       if (typeof a === "number" && typeof b === "number") return a - b
@@ -147,8 +147,8 @@ export function compareValues(a: unknown, b: unknown, mode: SortMode = "auto"):
 }
 
 /**
- * Sortiert eine Zeilenliste stabil nach mehreren Spalten. Leere Werte landen
- * gemäß `sortUndefined` der Spalte vorn oder hinten (Default: normal vergleicht).
+ * Stably sorts a row list by multiple columns. Empty values end up at the
+ * front or back according to the column's `sortUndefined` (default: compared normally).
  */
 export function sortRows<R extends Row>(rows: R[], sort: SortEntry[], columns: ResolvedColumn<R>[]): R[] {
   if (!sort.length) return rows
@@ -157,7 +157,7 @@ export function sortRows<R extends Row>(rows: R[], sort: SortEntry[], columns: R
     .filter((item): item is { entry: SortEntry; column: ResolvedColumn<R> } => Boolean(item.column))
   if (!entries.length) return rows
 
-  // Index mitführen → stabile Sortierung unabhängig von der Engine.
+  // Carry the index along → stable sorting regardless of the engine.
   return rows
     .map((row, index) => ({ row, index }))
     .sort((left, right) => {
@@ -181,9 +181,9 @@ export function sortRows<R extends Row>(rows: R[], sort: SortEntry[], columns: R
 }
 
 /**
- * Nächster Sortierzustand beim Klick auf einen Spaltenkopf.
- * asc → desc → aus (bzw. endlos wechselnd bei `withoutSortRemoval`),
- * mit Shift mehrspaltig (begrenzt durch `maxMultiSort`, 0 = unbegrenzt).
+ * Next sort state when clicking a column header.
+ * asc → desc → off (or cycling endlessly with `withoutSortRemoval`),
+ * multi-column with Shift (limited by `maxMultiSort`, 0 = unlimited).
  */
 export function nextSortState(
   current: SortEntry[],
@@ -211,7 +211,7 @@ export function nextSortState(
   return max > 0 ? combined.slice(-max) : combined
 }
 
-// ── Filter & Suche ────────────────────────────────────────────────────
+// ── Filter & search ───────────────────────────────────────────────────
 
 function dayStart(value: unknown): number {
   const time = toTime(value)
@@ -220,7 +220,7 @@ function dayStart(value: unknown): number {
   return new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime()
 }
 
-/** Ist ein Filterwert „leer" (dann filtert die Spalte nicht)? */
+/** Is a filter value "empty" (then the column doesn't filter)? */
 export function isEmptyFilter(value: unknown): boolean {
   if (value === null || value === undefined || value === "") return true
   if (Array.isArray(value)) return value.every((item) => isEmptyFilter(item))
@@ -286,11 +286,11 @@ export function rowMatchesFilters<R extends Row>(
   return true
 }
 
-// Suchtext-Cache je (Spalte, Zeile): `column.text` läuft durch den Formatter
-// (bei ViUR-Spalten Sprachauflösung, multiple-Joins, Format-Strings) — ohne
-// Cache friert die Suche über einen großen, voll geladenen Datensatz den
-// Browser ein (Zeilen × Spalten × Tastendruck). WeakMaps: der Cache lebt so
-// lange wie Spalte bzw. Zeile und räumt sich selbst ab.
+// Search text cache per (column, row): `column.text` runs through the formatter
+// (for ViUR columns: language resolution, multiple joins, format strings) — without
+// a cache, searching a large, fully loaded dataset freezes the
+// browser (rows × columns × keystroke). WeakMaps: the cache lives as
+// long as the column or row and cleans up after itself.
 const searchTextCache = new WeakMap<object, WeakMap<object, string>>()
 
 function searchTextOf<R extends Row>(column: ResolvedColumn<R>, row: R): string {
@@ -323,9 +323,9 @@ export function rowMatchesSearch<R extends Row>(
 }
 
 /**
- * Facetten einer Spalte: verschiedene Werte mit Trefferzahl und numerischer
- * Spanne — berechnet über die Zeilen, die alle ANDEREN Filter (und die Suche)
- * passieren. Genau das braucht ein set-Filter, damit er sich nicht selbst leert.
+ * Facets of a column: distinct values with hit count and numeric
+ * range — computed over the rows that pass all OTHER filters (and the search).
+ * That's exactly what a set filter needs so it doesn't empty itself.
  */
 export function computeFacets<R extends Row>(rows: R[], column: ResolvedColumn<R>): ColumnFacets {
   const counts = new Map<string, number>()
@@ -354,7 +354,7 @@ export function computeFacets<R extends Row>(rows: R[], column: ResolvedColumn<R
   return { values, min, max }
 }
 
-// ── Aggregation (Gruppenzeilen) ───────────────────────────────────────
+// ── Aggregation (group rows) ──────────────────────────────────────────
 
 function numbers(values: unknown[]): number[] {
   return values.map((value) => Number(value)).filter((value) => !Number.isNaN(value))

package/src/components/DataTable/index.ts

@@ -1,7 +1,7 @@
-// Öffentliche Oberfläche des DataTable-Widgets.
+// Public surface of the DataTable widget.
 export { default as DataTable } from "./DataTable.vue"
 export { default as ColumnFilterPanel } from "./ColumnFilterPanel.vue"
-export * from "./types"
+export * from "./types.ts"
 export {
   aggregate,
   aggregateColumn,
@@ -19,7 +19,7 @@ export {
   rowMatchesFilters,
   rowMatchesSearch,
   sortRows,
-} from "./columns"
+} from "./columns.ts"
 export {
   buildRows,
   collectKeys,
@@ -37,10 +37,10 @@ export {
   type NodeLocation,
   type OrderValue,
   type SelectionState,
-} from "./rows"
-export { useColumnLayout, type ColumnLayout, type LayoutColumn } from "./useColumnLayout"
-export { useGridNavigation } from "./useGridNavigation"
-export { useVirtualRows } from "./useVirtualRows"
+} from "./rows.ts"
+export { useColumnLayout, type ColumnLayout, type LayoutColumn } from "./useColumnLayout.ts"
+export { useGridNavigation } from "./useGridNavigation.ts"
+export { useVirtualRows } from "./useVirtualRows.ts"
 export {
   badgesForBone,
   boneFamily,
@@ -52,9 +52,9 @@ export {
   type BoneDescription,
   type BoneStructure,
   type ColumnsFromStructureOptions,
-} from "./viurColumns"
-// ViurDataTable ist (wie ViurBrowser) ein JS-SFC — seine Typen liegen in
-// ViurDataTable.d.vue.ts (Import: ".../DataTable/ViurDataTable.d.vue", wie
-// bei ViForm).
-// @ts-expect-error — JS-SFC ohne eingebettetes Typing
+} from "./viurColumns.ts"
+// ViurDataTable is (like ViurBrowser) a JS SFC — its types live in
+// ViurDataTable.d.vue.ts (import: ".../DataTable/ViurDataTable.d.vue", as
+// with ViForm).
+// @ts-expect-error — JS SFC without embedded typing
 export { default as ViurDataTable } from "./ViurDataTable.vue"