@brftech/filex-core 0.1.56

package/src/composables/useUploadChunked.ts

@@ -0,0 +1,250 @@
+/**
+ * useUploadChunked — S3 multipart upload orchestrator for the browser.
+ *
+ * Contract (matches the standard /api/files/upload/{init,finalize,abort}):
+ *   1. POST init  {path, filename, size, mime}
+ *        → {uploadId, parts: [{partNumber, presignedUrl}], chunkBytes, totalParts}
+ *   2. For each part: PUT <presignedUrl> <chunk bytes>, collect ETag header
+ *   3. POST finalize {uploadId, parts: [{partNumber, etag}]}
+ *        → {s3Key, url, size}
+ *   Abort path: POST abort {uploadId} any time.
+ *
+ * We parallelize up to `parallelChunks` uploads (default 4). Progress is
+ * reported as an aggregate percentage across all parts — individual part
+ * percentages are tracked internally and summed.
+ */
+
+import type { ExplorerConfig } from '../types/ExplorerConfig';
+import type { FileApi } from './useFileApi';
+import type { UploadInitResponse, UploadFinalizeResponse } from '../types/FileNode';
+
+export interface UploadJob {
+  id: string; // local uuid
+  file: File;
+  path: string;
+  uploadId?: string;
+  totalBytes: number;
+  uploadedBytes: number;
+  percent: number;
+  status: 'pending' | 'initializing' | 'uploading' | 'finalizing' | 'done' | 'error' | 'aborted';
+  error?: string;
+  cancel(): void;
+}
+
+export interface UploadOptions {
+  path: string;
+  file: File;
+  chunkSize?: number;
+  parallelChunks?: number;
+  onProgress?: (job: UploadJob) => void;
+  onDone?: (job: UploadJob, result: UploadFinalizeResponse) => void;
+  onError?: (job: UploadJob, err: Error) => void;
+}
+
+export function useUploadChunked(config: ExplorerConfig, api: FileApi) {
+  const DEFAULT_CHUNK = config.chunkSize ?? 5 * 1024 * 1024;
+  const DEFAULT_PARALLEL = Math.max(1, Math.min(8, config.parallelChunks ?? 4));
+
+  async function uploadFile(opts: UploadOptions): Promise<UploadFinalizeResponse> {
+    const chunkSize = opts.chunkSize ?? DEFAULT_CHUNK;
+    const parallel = opts.parallelChunks ?? DEFAULT_PARALLEL;
+
+    const job: UploadJob = {
+      id: crypto.randomUUID(),
+      file: opts.file,
+      path: opts.path,
+      totalBytes: opts.file.size,
+      uploadedBytes: 0,
+      percent: 0,
+      status: 'initializing',
+      cancel: () => {}, // rebound below
+    };
+
+    let cancelled = false;
+    const aborters: AbortController[] = [];
+    job.cancel = () => {
+      cancelled = true;
+      for (const a of aborters) a.abort();
+    };
+
+    function report() {
+      job.percent =
+        job.totalBytes > 0
+          ? Math.min(100, Math.round((job.uploadedBytes / job.totalBytes) * 100))
+          : 0;
+      opts.onProgress?.(job);
+    }
+
+    try {
+      if (!api.endpoints.uploadInit) throw new Error('uploadInit not configured');
+      // 1) init
+      const init = await api.jsonFetch<UploadInitResponse & { chunkBytes?: number; totalParts?: number }>(
+        api.endpoints.uploadInit,
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            path: opts.path,
+            filename: opts.file.name,
+            size: opts.file.size,
+            mime: opts.file.type || 'application/octet-stream',
+          }),
+        },
+      );
+      job.uploadId = init.uploadId;
+      job.status = 'uploading';
+      report();
+
+      const actualChunk = init.chunkBytes ?? chunkSize;
+      void actualChunk; // referenced below — keep TS happy with `chunkSize` shadow
+      const partProgress = new Map<number, number>();
+
+      // 2) upload parts in parallel windows
+      const completed: Array<{ partNumber: number; etag: string }> = [];
+      let cursor = 0;
+
+      async function uploadPart(entry: { partNumber: number; presignedUrl: string }): Promise<void> {
+        const idx = entry.partNumber - 1;
+        const start = idx * (init.chunkBytes ?? chunkSize);
+        const end = Math.min(start + (init.chunkBytes ?? chunkSize), opts.file.size);
+        const blob = opts.file.slice(start, end);
+
+        const ctl = new AbortController();
+        aborters.push(ctl);
+
+        await new Promise<void>((resolve, reject) => {
+          const xhr = new XMLHttpRequest();
+          xhr.open('PUT', entry.presignedUrl);
+          xhr.upload.onprogress = (ev) => {
+            if (ev.lengthComputable) {
+              const prev = partProgress.get(entry.partNumber) ?? 0;
+              const delta = ev.loaded - prev;
+              partProgress.set(entry.partNumber, ev.loaded);
+              job.uploadedBytes += delta;
+              report();
+            }
+          };
+          xhr.onload = () => {
+            if (xhr.status >= 200 && xhr.status < 300) {
+              const etag = (xhr.getResponseHeader('ETag') || xhr.getResponseHeader('etag') || '').trim();
+              if (!etag) {
+                reject(new Error('Missing ETag on S3 response'));
+                return;
+              }
+              // Top off in case the last progress event under-reported.
+              const blobSize = end - start;
+              const prev = partProgress.get(entry.partNumber) ?? 0;
+              if (prev < blobSize) {
+                job.uploadedBytes += blobSize - prev;
+                partProgress.set(entry.partNumber, blobSize);
+              }
+              completed.push({ partNumber: entry.partNumber, etag });
+              resolve();
+            } else {
+              reject(
+                new Error(`S3 PUT ${entry.partNumber} → ${xhr.status}: ${xhr.responseText.slice(0, 200)}`),
+              );
+            }
+          };
+          xhr.onerror = () => reject(new Error(`S3 PUT ${entry.partNumber} network error`));
+          xhr.onabort = () => reject(new DOMException('Aborted', 'AbortError'));
+          ctl.signal.addEventListener('abort', () => xhr.abort());
+          xhr.send(blob);
+        });
+      }
+
+      /**
+       * Wrap `uploadPart` in a tiny exponential-backoff retry so a
+       * single hiccup on the edge (intermittent TCP RST, transient
+       * 5xx) doesn't kill the whole multipart session. Counter is
+       * per-part — a flaky one doesn't burn the budget for healthy
+       * neighbours. We DON'T retry user cancellations or AbortError.
+       */
+      const MAX_RETRIES = 2;
+      async function uploadPartWithRetry(
+        entry: { partNumber: number; presignedUrl: string },
+        attempt = 0,
+      ): Promise<void> {
+        try {
+          await uploadPart(entry);
+        } catch (err) {
+          if (cancelled) throw err;
+          const e = err instanceof Error ? err : new Error(String(err));
+          if (e.name === 'AbortError') throw e;
+          if (attempt >= MAX_RETRIES) throw e;
+
+          // Roll back any partial uploadedBytes so progress doesn't
+          // double-count after the retry succeeds.
+          const leaked = partProgress.get(entry.partNumber) ?? 0;
+          if (leaked > 0) {
+            job.uploadedBytes = Math.max(0, job.uploadedBytes - leaked);
+            partProgress.delete(entry.partNumber);
+            report();
+          }
+
+          // Exponential backoff with jitter — 500ms, 1s, 1.5s …
+          const delay = 500 * (attempt + 1) + Math.floor(Math.random() * 250);
+          await new Promise((r) => setTimeout(r, delay));
+          return uploadPartWithRetry(entry, attempt + 1);
+        }
+      }
+
+      async function worker() {
+        while (!cancelled && cursor < init.parts.length) {
+          const entry = init.parts[cursor++];
+          await uploadPartWithRetry(entry);
+        }
+      }
+
+      const workers: Promise<void>[] = [];
+      for (let i = 0; i < parallel; i++) {
+        workers.push(worker());
+      }
+      await Promise.all(workers);
+
+      if (cancelled) {
+        throw new DOMException('Aborted by user', 'AbortError');
+      }
+
+      // 3) finalize
+      if (!api.endpoints.uploadFinalize) throw new Error('uploadFinalize not configured');
+      job.status = 'finalizing';
+      completed.sort((a, b) => a.partNumber - b.partNumber);
+      const final = await api.jsonFetch<UploadFinalizeResponse>(api.endpoints.uploadFinalize, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ uploadId: init.uploadId, parts: completed }),
+      });
+
+      job.status = 'done';
+      job.uploadedBytes = job.totalBytes;
+      job.percent = 100;
+      report();
+      opts.onDone?.(job, final);
+      return final;
+    } catch (err) {
+      const asError = err instanceof Error ? err : new Error(String(err));
+      job.status = asError.name === 'AbortError' ? 'aborted' : 'error';
+      job.error = asError.message;
+      report();
+
+      // Best-effort server-side cleanup
+      if (job.uploadId && api.endpoints.uploadAbort && job.status === 'aborted') {
+        try {
+          await api.jsonFetch(api.endpoints.uploadAbort, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ uploadId: job.uploadId }),
+          });
+        } catch {
+          /* swallow — DB row will expire, S3 TTL handles orphan parts */
+        }
+      }
+
+      opts.onError?.(job, asError);
+      throw asError;
+    }
+  }
+
+  return { uploadFile };
+}

package/src/composables/useViewerFetch.ts

@@ -0,0 +1,58 @@
+/**
+ * useViewerFetch — tiny wrapper around `fetch` for the rich viewers.
+ *
+ * The PreviewModal already builds and pushes `authHeaders` + the
+ * configured `credentials` mode into every viewer. The viewers need
+ * binary access (ArrayBuffer for utif/ag-psd/pdfjs, Blob for EPUB,
+ * text for CSV/Mermaid/ipynb), and they all want to honour the same
+ * auth strategy.
+ *
+ * Each helper uses the URL the modal hands down (`previewUrl(path)`)
+ * and merges in the same headers + credentials so a CSRF/Bearer host
+ * doesn't reject the request when the viewer fetches the file body
+ * directly (instead of letting the browser do it via `<img src>` etc).
+ */
+export interface ViewerFetchOptions {
+  url: string;
+  headers?: Record<string, string>;
+  credentials?: RequestCredentials;
+  signal?: AbortSignal;
+}
+
+async function fetchOk(opts: ViewerFetchOptions): Promise<Response> {
+  const res = await fetch(opts.url, {
+    headers: opts.headers ?? {},
+    credentials: opts.credentials ?? 'same-origin',
+    signal: opts.signal,
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(
+      `${res.status} ${res.statusText}${text ? ' — ' + text.slice(0, 200) : ''}`,
+    );
+  }
+  return res;
+}
+
+export async function fetchViewerArrayBuffer(
+  opts: ViewerFetchOptions,
+): Promise<ArrayBuffer> {
+  const res = await fetchOk(opts);
+  return res.arrayBuffer();
+}
+
+export async function fetchViewerBlob(
+  opts: ViewerFetchOptions,
+): Promise<{ blob: Blob; objectUrl: string; mime: string }> {
+  const res = await fetchOk(opts);
+  const blob = await res.blob();
+  const mime = blob.type || res.headers.get('content-type') || '';
+  return { blob, objectUrl: URL.createObjectURL(blob), mime };
+}
+
+export async function fetchViewerText(
+  opts: ViewerFetchOptions,
+): Promise<string> {
+  const res = await fetchOk(opts);
+  return res.text();
+}

package/src/index.ts

@@ -0,0 +1,80 @@
+/**
+ * @brftech/filex-core — public entry.
+ *
+ * Vue 3 source of truth for the filex file manager. Sibling packages
+ * (`@brftech/filex` Web Component, `@brftech/filex-react` React adapter)
+ * wrap this single FileExplorer SFC.
+ *
+ * Usage (Vue):
+ *   import { FileExplorer } from '@brftech/filex-core';
+ *   import '@brftech/filex-core/style.css';
+ *
+ *   <FileExplorer
+ *     :config="{ apiBase: 'https://files.example.com',
+ *                auth: { kind: 'bearer', token: '…' } }"
+ *     @error="…"
+ *   />
+ */
+
+export { default as FileExplorer } from './FileExplorer.vue';
+
+// PreviewModal is exposed so embedders can mount their own
+// fullscreen editor route (e.g. /files/edit) without re-implementing
+// the viewer dispatch logic.
+export { default as PreviewModal } from './modals/PreviewModal.vue';
+
+// ——— Phase-2 standalone components (consumers can mount these
+//      independently of the FileExplorer host, e.g. a sidebar tray).
+export { default as StarButton } from './components/StarButton.vue';
+export { default as TagPicker } from './components/TagPicker.vue';
+export { default as RecentlyOpened } from './components/RecentlyOpened.vue';
+
+// ——— Types ———
+export type {
+  ExplorerConfig,
+  ExplorerEmits,
+  AuthConfig,
+  ThemeMode,
+  LocaleCode,
+  EndpointMap,
+} from './types/ExplorerConfig';
+
+export type {
+  FileNode,
+  ShareInfo,
+  UploadLimits,
+  Capabilities,
+  ExternalServiceState,
+  ExternalServiceStatus,
+  UploadInitResponse,
+  UploadFinalizeResponse,
+  ArchiveEntry,
+  ViewMode,
+  ClipboardState,
+} from './types/FileNode';
+export { isExternalUsable } from './types/FileNode';
+
+// ——— Composables (consumers can roll their own UI on top) ———
+export { useFileApi, resolveEndpoints } from './composables/useFileApi';
+export type { FileApi, ManagerResponse, PendingOpDto } from './composables/useFileApi';
+
+export { useUploadChunked } from './composables/useUploadChunked';
+export type { UploadJob, UploadOptions } from './composables/useUploadChunked';
+
+export { useSelection } from './composables/useSelection';
+export { useKeyboardShortcuts } from './composables/useKeyboardShortcuts';
+export type { ShortcutHandlers } from './composables/useKeyboardShortcuts';
+export { useLocale } from './composables/useLocale';
+export { usePendingOps } from './composables/usePendingOps';
+export type { PendingOp, UsePendingOpsOptions } from './composables/usePendingOps';
+export {
+  useMonacoLoader,
+  preloadEditor,
+  ensureMonaco,
+  ensureHighlight,
+  getMonaco,
+  getHighlight,
+} from './composables/useMonacoLoader';
+
+// ——— Locale catalogue (consumers may merge their own keys) ———
+export { messages, tr, en } from './locales';

package/src/locales/en.ts

@@ -0,0 +1,122 @@
+/** English UI strings. */
+export const en: Record<string, string> = {
+  'toolbar.new_folder': 'New Folder',
+  'toolbar.upload': 'Upload',
+  'toolbar.search': 'Search',
+  'toolbar.search.placeholder': 'File name…',
+  'toolbar.view.list': 'List',
+  'toolbar.view.grid': 'Grid',
+  'toolbar.refresh': 'Refresh',
+  'toolbar.go_up': 'Up one level',
+
+  'ctx.open': 'Open',
+  'ctx.preview': 'Preview',
+  'ctx.download': 'Download',
+  'ctx.convert': 'Convert',
+  'ctx.rename': 'Rename',
+  'ctx.delete': 'Delete',
+  'ctx.delete_perm': 'Delete Permanently',
+  'ctx.restore': 'Restore',
+  'ctx.share': 'Share',
+  'ctx.move': 'Move',
+  'ctx.copy': 'Copy',
+  'ctx.cut': 'Cut',
+  'ctx.paste': 'Paste',
+  'ctx.info': 'Info',
+  'ctx.duplicate': 'Duplicate',
+  'ctx.new_file': 'New File',
+
+  'modal.delete.title': 'Delete?',
+  'modal.delete.message': '{count} item(s) will be moved to trash.',
+  'modal.delete.confirm': 'Move to Trash',
+  'modal.delete.cancel': 'Cancel',
+
+  'modal.rename.title': 'Rename',
+  'modal.rename.save': 'Save',
+  'modal.rename.cancel': 'Cancel',
+
+  'modal.newfolder.title': 'New Folder',
+  'modal.newfolder.placeholder': 'Folder name',
+  'modal.newfolder.create': 'Create',
+  'modal.newfolder.cancel': 'Cancel',
+
+  'modal.share.title': 'Share Link',
+  'modal.share.pin': 'PIN protected',
+  'modal.share.expires': 'Expires at',
+  'modal.share.max_downloads': 'Download limit',
+  'modal.share.create': 'Share',
+  'modal.share.cancel': 'Cancel',
+  'modal.share.copy': 'Copy',
+  'modal.share.url_copied': 'Link copied',
+  'modal.share.pin_copied': 'PIN copied',
+  'modal.share.cli_copied': 'CLI command copied',
+
+  'upload.progress': 'Uploading',
+  'upload.done': 'Done',
+  'upload.error': 'Error',
+  'upload.aborted': 'Aborted',
+  'upload.cancel': 'Cancel',
+
+  'empty.folder': 'This folder is empty',
+  'empty.search': 'No results',
+  'loading': 'Loading…',
+
+  'col.name': 'Name',
+  'col.size': 'Size',
+  'col.modified': 'Modified',
+  'col.type': 'Type',
+
+  'unit.bytes': 'B',
+  'unit.kb': 'KB',
+  'unit.mb': 'MB',
+  'unit.gb': 'GB',
+  'unit.tb': 'TB',
+
+  'breadcrumb.root': 'Root',
+  'breadcrumb.copy_path': 'Copy Path',
+  'breadcrumb.go_to_path': 'Go To Path',
+  'breadcrumb.path_placeholder': 'fileman/foo/bar',
+
+  'ops.copy': 'Copying',
+  'ops.move': 'Moving',
+  'ops.delete': 'Deleting',
+  'ops.queued': 'queued',
+  'ops.done': 'done',
+  'ops.error': 'error',
+
+  'node.trash': 'Trash',
+
+  // ——— Rich viewer chrome ———
+  'viewer.open_in_new_tab': 'Open in New Tab',
+  'viewer.loading': 'Loading…',
+  'viewer.failed_to_load': 'Failed to load file',
+  'viewer.peer_not_installed': 'Optional viewer library is not installed. Install the peer dependency or use the download button.',
+  'viewer.format_unsupported_3d': 'This 3D format is not supported in the browser preview (model-viewer only reads .glb / .gltf / .usdz). Please download and open with a local tool.',
+  'viewer.zoom_in': 'Zoom in',
+  'viewer.zoom_out': 'Zoom out',
+  'viewer.fit_width': 'Fit width',
+  'viewer.next_page': 'Next page',
+  'viewer.prev_page': 'Previous page',
+  'viewer.page_n_of_m': 'Page {n} of {m}',
+  'viewer.tags': 'Tags',
+  'viewer.layers': 'Layers',
+  'viewer.toc': 'Contents',
+  'viewer.font_smaller': 'Smaller text',
+  'viewer.font_larger': 'Larger text',
+  'viewer.search': 'Search',
+  'viewer.download': 'Download',
+  'viewer.save_annotations': 'Save annotations',
+  'viewer.annotations_on': 'Annotations: on',
+  'viewer.annotations_off': 'Annotations: off',
+  'viewer.read_only': 'Read only',
+  'viewer.csv_first_row_header': 'First row as header',
+  'viewer.csv_filter': 'Filter rows…',
+  'viewer.epub_prev': 'Previous',
+  'viewer.epub_next': 'Next',
+  'viewer.drawio.disabled': 'diagrams.net embed is not configured for this filex instance — operator must wire FILEX_DRAWIO_URL to enable the editor.',
+  'viewer.archive.entries': '{n} files',
+  'viewer.archive.empty': 'Archive is empty.',
+  'viewer.archive.error': 'Could not read archive contents.',
+  'viewer.name': 'Name',
+  'viewer.size': 'Size',
+};

package/src/locales/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Locale message catalogue. The string-table is intentionally tiny — no
+ * external i18n library, just a `t(key, vars?)` helper exposed via
+ * `useLocale`.
+ */
+import { tr } from './tr';
+import { en } from './en';
+import type { LocaleCode } from '../types/ExplorerConfig';
+
+export const messages: Record<LocaleCode, Record<string, string>> = { tr, en };
+
+export { tr, en };

package/src/locales/tr.ts

@@ -0,0 +1,122 @@
+/** Turkish UI strings. */
+export const tr: Record<string, string> = {
+  'toolbar.new_folder': 'Yeni Klasör',
+  'toolbar.upload': 'Yükle',
+  'toolbar.search': 'Ara',
+  'toolbar.search.placeholder': 'Dosya adı…',
+  'toolbar.view.list': 'Liste',
+  'toolbar.view.grid': 'Izgara',
+  'toolbar.refresh': 'Yenile',
+  'toolbar.go_up': 'Üst Klasör',
+
+  'ctx.open': 'Aç',
+  'ctx.preview': 'Önizle',
+  'ctx.download': 'İndir',
+  'ctx.convert': 'Dönüştür',
+  'ctx.rename': 'Yeniden Adlandır',
+  'ctx.delete': 'Sil',
+  'ctx.delete_perm': 'Kalıcı Olarak Sil',
+  'ctx.restore': 'Geri Getir',
+  'ctx.share': 'Paylaş',
+  'ctx.move': 'Taşı',
+  'ctx.copy': 'Kopyala',
+  'ctx.cut': 'Kes',
+  'ctx.paste': 'Yapıştır',
+  'ctx.info': 'Bilgi',
+  'ctx.duplicate': 'Kopyasını Oluştur',
+  'ctx.new_file': 'Yeni Dosya',
+
+  'modal.delete.title': 'Silinsin mi?',
+  'modal.delete.message': '{count} öğe çöpe atılacak.',
+  'modal.delete.confirm': 'Çöpe At',
+  'modal.delete.cancel': 'Vazgeç',
+
+  'modal.rename.title': 'Yeniden Adlandır',
+  'modal.rename.save': 'Kaydet',
+  'modal.rename.cancel': 'Vazgeç',
+
+  'modal.newfolder.title': 'Yeni Klasör',
+  'modal.newfolder.placeholder': 'Klasör adı',
+  'modal.newfolder.create': 'Oluştur',
+  'modal.newfolder.cancel': 'Vazgeç',
+
+  'modal.share.title': 'Paylaşım Linki',
+  'modal.share.pin': 'PIN koruması',
+  'modal.share.expires': 'Son kullanma',
+  'modal.share.max_downloads': 'İndirme limiti',
+  'modal.share.create': 'Paylaş',
+  'modal.share.cancel': 'Vazgeç',
+  'modal.share.copy': 'Kopyala',
+  'modal.share.url_copied': 'Link kopyalandı',
+  'modal.share.pin_copied': 'PIN kopyalandı',
+  'modal.share.cli_copied': 'CLI komutu kopyalandı',
+
+  'upload.progress': 'Yükleniyor',
+  'upload.done': 'Tamamlandı',
+  'upload.error': 'Hata',
+  'upload.aborted': 'İptal edildi',
+  'upload.cancel': 'İptal',
+
+  'empty.folder': 'Bu klasör boş',
+  'empty.search': 'Sonuç bulunamadı',
+  'loading': 'Yükleniyor…',
+
+  'col.name': 'Ad',
+  'col.size': 'Boyut',
+  'col.modified': 'Tarih',
+  'col.type': 'Tür',
+
+  'unit.bytes': 'B',
+  'unit.kb': 'KB',
+  'unit.mb': 'MB',
+  'unit.gb': 'GB',
+  'unit.tb': 'TB',
+
+  'breadcrumb.root': 'Kök',
+  'breadcrumb.copy_path': 'Yolu Kopyala',
+  'breadcrumb.go_to_path': 'Yola Git',
+  'breadcrumb.path_placeholder': 'fileman/foo/bar',
+
+  'ops.copy': 'Kopyalanıyor',
+  'ops.move': 'Taşınıyor',
+  'ops.delete': 'Siliniyor',
+  'ops.queued': 'sırada',
+  'ops.done': 'tamamlandı',
+  'ops.error': 'hata',
+
+  'node.trash': 'Çöp Kutusu',
+
+  // ——— Zengin önizleyici chrome ———
+  'viewer.open_in_new_tab': 'Yeni Sekmede Aç',
+  'viewer.loading': 'Yükleniyor…',
+  'viewer.failed_to_load': 'Dosya yüklenemedi',
+  'viewer.peer_not_installed': 'Bu dosya tipi için opsiyonel kütüphane kurulu değil. Peer dependency yükle veya İndir düğmesini kullan.',
+  'viewer.format_unsupported_3d': 'Bu 3B format tarayıcı önizlemesinde desteklenmiyor (model-viewer yalnızca .glb / .gltf / .usdz okur). Lütfen indirip yerel bir araçta açın.',
+  'viewer.zoom_in': 'Yakınlaştır',
+  'viewer.zoom_out': 'Uzaklaştır',
+  'viewer.fit_width': 'Sayfa genişliğine sığdır',
+  'viewer.next_page': 'Sonraki sayfa',
+  'viewer.prev_page': 'Önceki sayfa',
+  'viewer.page_n_of_m': 'Sayfa {n} / {m}',
+  'viewer.tags': 'Etiketler',
+  'viewer.layers': 'Katmanlar',
+  'viewer.toc': 'İçindekiler',
+  'viewer.font_smaller': 'Yazıyı küçült',
+  'viewer.font_larger': 'Yazıyı büyüt',
+  'viewer.search': 'Ara',
+  'viewer.download': 'İndir',
+  'viewer.save_annotations': 'Açıklamaları kaydet',
+  'viewer.annotations_on': 'Açıklamalar: açık',
+  'viewer.annotations_off': 'Açıklamalar: kapalı',
+  'viewer.read_only': 'Salt okunur',
+  'viewer.csv_first_row_header': 'İlk satır başlık olsun',
+  'viewer.csv_filter': 'Satır filtrele…',
+  'viewer.epub_prev': 'Önceki',
+  'viewer.epub_next': 'Sonraki',
+  'viewer.drawio.disabled': 'diagrams.net editörü bu filex kurulumunda yapılandırılmamış — yönetici FILEX_DRAWIO_URL\'yi ayarlamalı.',
+  'viewer.archive.entries': '{n} dosya',
+  'viewer.archive.empty': 'Arşiv boş.',
+  'viewer.archive.error': 'Arşiv okunamadı.',
+  'viewer.name': 'Ad',
+  'viewer.size': 'Boyut',
+};