@brftech/filex-core 0.39.1 → 0.41.0

package/src/components/ViewSwitcher.vue

@@ -3,7 +3,8 @@
  * ViewSwitcher — the list / grid / gallery toggle.
  *
  * Lifted out of Toolbar.vue unchanged (same classes, same glyphs, same
- * `role="tablist"` semantics) because the `drive` profile puts it on the
+ * `role="tablist"` semantics — the glyphs moved to lib/actionIcons with the
+ * rest of the emoji, see `gorunum:v1-icons`) because the `drive` profile puts it on the
  * breadcrumb row instead of in the header, and two copies of a switcher is
  * how the two rows end up offering different modes. One component, mounted
  * in whichever row the profile asks for.
@@ -15,6 +16,7 @@
  * block's `data-v` hash does not match in the web-component build).
  */
 import { useLocale } from '../composables/useLocale';
+import { actionIconSvg } from '../lib/actionIcons';
 import type { LocaleCode } from '../types/ExplorerConfig';
 import type { ViewMode } from '../types/FileNode';
 
@@ -47,7 +49,8 @@ function offers(v: ViewMode): boolean {
       data-testid="view-list"
       @click="emit('update:viewMode', 'list')"
     >
-      <span class="fe-icon" aria-hidden="true">☰</span>
+      <!-- eslint-disable-next-line vue/no-v-html — static markup from lib/actionIcons -->
+      <span class="fe-icon" aria-hidden="true" v-html="actionIconSvg('view-list')"></span>
     </button>
     <button
       v-if="offers('grid')"
@@ -61,7 +64,8 @@ function offers(v: ViewMode): boolean {
       data-testid="view-grid"
       @click="emit('update:viewMode', 'grid')"
     >
-      <span class="fe-icon" aria-hidden="true">▦</span>
+      <!-- eslint-disable-next-line vue/no-v-html — static markup from lib/actionIcons -->
+      <span class="fe-icon" aria-hidden="true" v-html="actionIconSvg('view-grid')"></span>
     </button>
     <button
       v-if="offers('gallery')"
@@ -75,7 +79,8 @@ function offers(v: ViewMode): boolean {
       data-testid="view-gallery"
       @click="emit('update:viewMode', 'gallery')"
     >
-      <span class="fe-icon" aria-hidden="true">▣</span>
+      <!-- eslint-disable-next-line vue/no-v-html — static markup from lib/actionIcons -->
+      <span class="fe-icon" aria-hidden="true" v-html="actionIconSvg('view-gallery')"></span>
     </button>
   </div>
 </template>

package/src/composables/useConnections.ts

@@ -53,11 +53,25 @@ export function connectionsBase(config: ExplorerConfig): string {
  * The origin a client program should be pointed at.
  *
  * The instruction pages are only worth anything if they name the real
- * deployment, so this resolves to an absolute origin: the configured
- * apiBase when there is one (the desktop app, embeds), otherwise the page's
- * own origin (the admin SPA, which is served by the same binary).
+ * deployment, so this resolves to an absolute address, best evidence first:
+ *
+ *   1. `publicUrl` — what the SERVER says it is reached at
+ *      (`/api/files/capabilities` → `public_url`, published only when the
+ *      operator configured it or the request came in on a tenant's own host);
+ *   2. the configured apiBase when it is absolute (the desktop app, embeds
+ *      that talk to filex directly);
+ *   3. the page's own origin (the admin SPA, which the same binary serves).
+ *
+ * ⚠⚠ The first rung is new and it is the fix. Without it an explorer embedded
+ * in ANOTHER app — which proxies `/api` to filex under its own origin, the way
+ * work.example.com and fishapp do — printed `https://<that app>/dav/`: an address
+ * that reaches the host application, never filex. It also left one guide page
+ * speaking with two voices, because its S3 endpoint and SFTP host were always
+ * the server's and only the WebDAV / mount lines were the page's.
  */
-export function connectionsOrigin(config: ExplorerConfig): string {
+export function connectionsOrigin(config: ExplorerConfig, publicUrl?: string | null): string {
+  const told = String(publicUrl ?? '').trim();
+  if (/^https?:\/\/[^/]/i.test(told)) return told.replace(/\/+$/, '');
   const base = connectionsBase(config);
   if (/^https?:\/\//i.test(base)) {
     try {
@@ -80,6 +94,8 @@ export function useConnections(config: ExplorerConfig) {
   /** Storage names a non-admin may see (manager root). */
   const visible = shallowRef<string[]>([]);
   const me = ref<ConnectionsUser | null>(null);
+  /** The server's own public address, when it has one to give (see connectionsOrigin). */
+  const publicUrl = ref<string | null>(null);
 
   const loading = ref(false);
   const loaded = ref(false);
@@ -102,6 +118,19 @@ export function useConnections(config: ExplorerConfig) {
     loading.value = true;
     error.value = null;
     try {
+      // Where the server says it lives. Best-effort and in parallel: a server
+      // older than `public_url`, or one that has none to give, leaves the
+      // guides on the address the page loaded from — exactly as before.
+      const told = api
+        .capabilities()
+        .then((c) => {
+          const v = (c as { public_url?: unknown } | null)?.public_url;
+          publicUrl.value = typeof v === 'string' && v ? v : null;
+        })
+        .catch(() => {
+          publicUrl.value = null;
+        });
+
       // Identity first: the guides need the caller's own e-mail (it IS the
       // WebDAV username), and it is the one call every role may make.
       try {
@@ -152,6 +181,7 @@ export function useConnections(config: ExplorerConfig) {
           visible.value = [];
         }
       }
+      await told;
       loaded.value = true;
     } finally {
       loading.value = false;
@@ -249,6 +279,7 @@ export function useConnections(config: ExplorerConfig) {
     storages,
     visible,
     me,
+    publicUrl,
     loading,
     loaded,
     error,

package/src/composables/useExplorerTimeZone.ts

@@ -0,0 +1,85 @@
+/**
+ * useExplorerTimeZone — what ONE explorer instance knows about the clock, fed
+ * into `lib/timezone`'s resolver.
+ *
+ * An explorer knows two of the four tiers and nobody else can know them for
+ * it: the zone its host configured (`config.timeZone`, tier `host`) and the
+ * account behind the credential it holds (tier `account`). The viewer tier is
+ * the browser's and the device tier is `Intl`'s; neither needs an instance.
+ *
+ * How the account is learned — nothing new on the server:
+ *
+ *   1. the credential's KIND, from `GET /api/files/capabilities`
+ *      (`caller_kind`, migration 00030), which the explorer already fetches —
+ *      or `config.callerKind`, which a host may set to answer sooner and which
+ *      wins over the server's, exactly as it does for the panel's surfaces;
+ *   2. for a person, `GET /api/auth/me` — the route every role may call, open
+ *      to a bearer token (MiddlewareWithToken) and to cross-origin callers
+ *      (CORS allows `Authorization`), and already used by the Connections
+ *      panel for the caller's own e-mail. `user.timezone` is the zone.
+ *
+ * ⚠⚠ An `app` token skips the tier. It authenticates AS its owner, so
+ * `/api/auth/me` would happily answer with that owner's zone — and the embeds
+ * we run authenticate every visitor with ONE such token. Imposing its owner's
+ * clock on all of them is the exact thing the owner ruled out.
+ *
+ * ⚠ Unknown kind also skips. When capabilities never lands (an old server, a
+ * host that routes nothing but the manager), nobody can say whether the key is
+ * a person's, and guessing "person" would be guessing the dangerous way.
+ *
+ * ⚠ Every failure is silent and falls through: a 401, a 404 from a host that
+ * does not proxy `/api/auth/me`, a network error. The tier is withdrawn and
+ * the browser's zone answers. A clock must never throw.
+ */
+
+import { onBeforeUnmount, watch, type Ref } from 'vue';
+import type { ExplorerConfig } from '../types/ExplorerConfig';
+import type { Capabilities } from '../types/FileNode';
+import { releaseTimeZoneOwner, setAccountTimeZone, setHostTimeZone } from '../lib/timezone';
+
+export interface ExplorerTimeZoneDeps {
+  config: () => ExplorerConfig;
+  /** The explorer's capabilities answer; `null` until (and unless) it lands. */
+  capabilities: Ref<Capabilities | null>;
+  /** `GET /api/auth/me` with this explorer's credential. */
+  fetchMe: () => Promise<{ user?: { timezone?: unknown } | null } | undefined>;
+}
+
+export function useExplorerTimeZone(deps: ExplorerTimeZoneDeps): void {
+  const owner = Symbol('filex-explorer');
+
+  watch(
+    () => deps.config().timeZone,
+    (tz) => setHostTimeZone(owner, tz),
+    { immediate: true },
+  );
+
+  const kind = (): 'user' | 'app' | undefined =>
+    deps.config().callerKind ?? deps.capabilities.value?.caller_kind;
+
+  let asked = false;
+  watch(
+    kind,
+    (k) => {
+      if (k !== 'user') {
+        // `app`: nobody's account. Unknown: cannot tell. Either way, withdraw.
+        setAccountTimeZone(owner, null);
+        return;
+      }
+      if (asked) return;
+      asked = true;
+      deps
+        .fetchMe()
+        .then((body) => {
+          // The kind may have changed while the request was out.
+          if (kind() !== 'user') return;
+          const tz = body?.user?.timezone;
+          setAccountTimeZone(owner, typeof tz === 'string' ? tz : null);
+        })
+        .catch(() => setAccountTimeZone(owner, null));
+    },
+    { immediate: true },
+  );
+
+  onBeforeUnmount(() => releaseTimeZoneOwner(owner));
+}

package/src/composables/useFileApi.ts

@@ -48,6 +48,17 @@ export interface PendingOpDto {
   created_at: string | null;
 }
 
+/** Answer to `?action=newfile` — where the new document actually landed. */
+export interface NewFileResponse {
+  /** Adapter-qualified path, ready to hand to the viewer. */
+  path: string;
+  /** Final basename, which may have gained the extension server-side. */
+  name: string;
+  ext: string;
+  size: number;
+  mime: string;
+}
+
 export interface ManagerResponse {
   adapter: string;
   storages: string[];
@@ -504,6 +515,27 @@ export function useFileApi(config: ExplorerConfig) {
     });
   }
 
+  /**
+   * Create an empty document of a known type in `path`.
+   *
+   * `type` is an extension from `capabilities.newdoc_types` — the registry the
+   * SERVER compiled in, not a list the client keeps. That matters for the
+   * office formats: a .docx is a ZIP of XML parts, so "create an empty file"
+   * has to be answered by whoever holds the template bytes, and the client
+   * cannot manufacture one.
+   *
+   * `name` may or may not already carry the extension; the server appends it
+   * when it is missing. Throws on a name collision (409 NAME_TAKEN) — the
+   * dialog warns first, but this is the check.
+   */
+  async function newFile(path: string, name: string, type: string): Promise<NewFileResponse> {
+    return jsonFetch<NewFileResponse>(managerUrl('newfile'), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ path, name, type }),
+    });
+  }
+
   async function rename(path: string, item: string, name: string): Promise<ManagerResponse> {
     return jsonFetch<ManagerResponse>(managerUrl('rename'), {
       method: 'POST',
@@ -577,11 +609,18 @@ export function useFileApi(config: ExplorerConfig) {
   /**
    * Restore soft-deleted nodes by their node id. The filex backend restores
    * one node per call (`POST {node_id}`), so we fan out and tally successes.
+   *
+   * `taken` names the entries the server refused because something already
+   * holds their original path (409 `EXISTS`). That refusal is the server
+   * protecting the file that holds the name — a restore used to overwrite it —
+   * so it is reported by name rather than folded into "0 items restored",
+   * which would read as if nothing had been tried.
    */
-  async function restoreIds(ids: number[]): Promise<{ restored: number }> {
+  async function restoreIds(ids: number[]): Promise<{ restored: number; taken: string[] }> {
     const url = endpoints.trashRestore;
     if (!url) throw new Error('trashRestore endpoint not configured');
     let restored = 0;
+    const taken: string[] = [];
     for (const id of ids) {
       try {
         await jsonFetch(url, {
@@ -590,11 +629,20 @@ export function useFileApi(config: ExplorerConfig) {
           body: JSON.stringify({ node_id: id }),
         });
         restored++;
-      } catch {
-        /* skip individual failures; report the count that succeeded */
+      } catch (err) {
+        const e = err as { status?: number; detail?: string };
+        if (e.status === 409) {
+          try {
+            const body = JSON.parse(e.detail ?? '') as { code?: string; name?: string };
+            if (body.code === 'EXISTS') taken.push(body.name || String(id));
+          } catch {
+            /* a 409 without the envelope is counted as a plain failure */
+          }
+        }
+        /* any other failure: skip it, report the count that succeeded */
       }
     }
-    return { restored };
+    return { restored, taken };
   }
 
   /**
@@ -934,6 +982,7 @@ export function useFileApi(config: ExplorerConfig) {
     quotaMe /* surucu:d1 */,
     subfolders,
     newFolder,
+    newFile,
     rename,
     move,
     copy,

package/src/composables/useKeyboardShortcuts.ts

@@ -47,6 +47,22 @@ export interface ShortcutHandlers {
   onTabNext?: () => void; // Ctrl+Tab
   onTabPrev?: () => void; // Ctrl+Shift+Tab
   /* /wiring:d1 */
+  /* tus:t1 — the verbs that were only ever reachable from the menus. Every
+   * one of them is remappable like the rest; the ones that ship unbound are
+   * there so the user can give them a key, not because they do less. */
+  onNewFolder?: () => void; // Shift+N
+  onUpload?: () => void; // U
+  onRefresh?: () => void; // R
+  onDownload?: () => void; // D
+  onPreview?: () => void; // P
+  onShare?: () => void; // Shift+S
+  onTags?: () => void; // T
+  onConvert?: () => void; // (unbound)
+  onOpenTab?: () => void; // (unbound)
+  onCopyPath?: () => void; // (unbound)
+  onCopyId?: () => void; // (unbound)
+  onRestore?: () => void; // (unbound)
+  /* /tus:t1 */
   hasSelection?: () => boolean; // disambiguates Backspace
 }
 
@@ -77,6 +93,33 @@ export interface ShortcutActionDef {
   inForms?: boolean;
 }
 
+/**
+ * Combos the BROWSER takes before the page sees them. `preventDefault()`
+ * cannot stop these in an ordinary tab — Chrome and Firefox handle them at
+ * the window level — so an action bound to one of them only ever fires in
+ * the desktop app, an installed PWA or a kiosk window.
+ *
+ * They are not forbidden as DEFAULTS (the tab actions have shipped on
+ * Ctrl+T/W/Tab since wiring:d1 and work in the desktop app), but the
+ * settings modal refuses to let a user assign one: choosing a key that
+ * silently does nothing where you are standing is not a choice, it is a
+ * trap. `isReservedCombo` is the one place that list lives.
+ */
+const RESERVED_COMBOS = new Set([
+  'Ctrl+N', 'Ctrl+Shift+N',
+  'Ctrl+T', 'Ctrl+Shift+T',
+  'Ctrl+W', 'Ctrl+Shift+W',
+  'Ctrl+Tab', 'Ctrl+Shift+Tab',
+  'Ctrl+Q',
+  'Ctrl+Shift+I', 'Ctrl+Shift+J', 'Ctrl+Shift+C',
+  'F11', 'F12',
+]);
+
+/** Does the browser eat this combo before the page can see it? */
+export function isReservedCombo(combo: string): boolean {
+  return RESERVED_COMBOS.has(combo);
+}
+
 /** Registry order = help/settings display order. */
 export const SHORTCUT_ACTIONS: ShortcutActionDef[] = [
   // Navigation
@@ -109,6 +152,25 @@ export const SHORTCUT_ACTIONS: ShortcutActionDef[] = [
   { id: 'tab-next', defaultCombo: 'Ctrl+Tab', labelKey: 'shortcuts.tab_next', groupKey: 'shortcuts.group.tabs' },
   { id: 'tab-prev', defaultCombo: 'Ctrl+Shift+Tab', labelKey: 'shortcuts.tab_prev', groupKey: 'shortcuts.group.tabs' },
   /* /wiring:d1 */
+  /* tus:t1 — the rest of the menu verbs. Until now these were reachable only
+   * by right-clicking, and the right-click menu named no keys at all, so 16 of
+   * the registry's actions were invisible unless somebody opened the `?` sheet
+   * on their own. The ones with no default are deliberate: they are rare
+   * enough that taking a key from the user by default is the wrong trade, and
+   * they are in the registry so the user can take one. */
+  { id: 'new-folder', defaultCombo: 'Shift+N', labelKey: 'shortcuts.new_folder', groupKey: 'shortcuts.group.file' },
+  { id: 'upload', defaultCombo: 'U', labelKey: 'shortcuts.upload', groupKey: 'shortcuts.group.file' },
+  { id: 'refresh', defaultCombo: 'R', labelKey: 'shortcuts.refresh', groupKey: 'shortcuts.group.nav' },
+  { id: 'download', defaultCombo: 'D', labelKey: 'shortcuts.download', groupKey: 'shortcuts.group.file' },
+  { id: 'preview', defaultCombo: 'P', labelKey: 'shortcuts.preview', groupKey: 'shortcuts.group.nav' },
+  { id: 'share', defaultCombo: 'Shift+S', labelKey: 'shortcuts.share', groupKey: 'shortcuts.group.file' },
+  { id: 'tags', defaultCombo: 'T', labelKey: 'shortcuts.tags', groupKey: 'shortcuts.group.file' },
+  { id: 'convert', defaultCombo: '', labelKey: 'shortcuts.convert', groupKey: 'shortcuts.group.file' },
+  { id: 'open-tab', defaultCombo: '', labelKey: 'shortcuts.open_tab', groupKey: 'shortcuts.group.tabs' },
+  { id: 'copy-path', defaultCombo: '', labelKey: 'shortcuts.copy_path', groupKey: 'shortcuts.group.file' },
+  { id: 'copy-id', defaultCombo: '', labelKey: 'shortcuts.copy_id', groupKey: 'shortcuts.group.file' },
+  { id: 'restore', defaultCombo: '', labelKey: 'shortcuts.restore', groupKey: 'shortcuts.group.file' },
+  /* /tus:t1 */
 ];
 
 /** action id → ShortcutHandlers callback name. */
@@ -134,6 +196,19 @@ const HANDLER_KEY: Record<string, keyof ShortcutHandlers> = {
   'tab-close': 'onTabClose',
   'tab-next': 'onTabNext',
   'tab-prev': 'onTabPrev',
+  /* tus:t1 */
+  'new-folder': 'onNewFolder',
+  upload: 'onUpload',
+  refresh: 'onRefresh',
+  download: 'onDownload',
+  preview: 'onPreview',
+  share: 'onShare',
+  tags: 'onTags',
+  convert: 'onConvert',
+  'open-tab': 'onOpenTab',
+  'copy-path': 'onCopyPath',
+  'copy-id': 'onCopyId',
+  restore: 'onRestore',
 };
 
 // --------------------------------------------------------------------
@@ -336,6 +411,53 @@ export function comboLabel(combo: string): string {
   return isMacLike() ? combo.replace(/\bCtrl\b/g, '⌘') : combo;
 }
 
+/**
+ * Menu action key → registry action id.
+ *
+ * The right-click menu, the toolbar and the keyboard all name the same verbs,
+ * but the menu's `key` and the registry's `id` are separate vocabularies and
+ * two of them genuinely differ (`access` is the share dialog, `details` is the
+ * inspector). One map, in one place: a second copy is a second chance to
+ * forget, and the symptom would be a menu row that silently stops naming its
+ * key while every other row keeps working.
+ */
+export const MENU_ACTION_SHORTCUTS: Record<string, string> = {
+  open: 'open',
+  'open-tab': 'open-tab',
+  preview: 'preview',
+  download: 'download',
+  convert: 'convert',
+  access: 'share',
+  details: 'inspector',
+  'copy-id': 'copy-id',
+  'copy-path': 'copy-path',
+  rename: 'rename',
+  cut: 'cut',
+  copy: 'copy',
+  paste: 'paste',
+  star: 'star',
+  tags: 'tags',
+  delete: 'delete',
+  restore: 'restore',
+  'new-folder': 'new-folder',
+  'toggle-hidden': 'toggle-hidden',
+  upload: 'upload',
+  refresh: 'refresh',
+};
+
+/**
+ * What a menu row or a toolbar button should print beside its label: the
+ * current combo for the verb it triggers, or '' when it has none (unbound, or
+ * not a registry action at all — `keep-local`, the E2E entries and so on).
+ */
+export function menuShortcutHint(menuKey: string): string {
+  /* Fall back to the key itself: the toolbar's own buttons (go-up, upload,
+   * refresh…) pass a registry id directly, and an id nothing knows returns ''
+   * rather than throwing. */
+  const id = MENU_ACTION_SHORTCUTS[menuKey] ?? menuKey;
+  return SHORTCUT_ACTIONS.some((a) => a.id === id) ? shortcutHint(id) : '';
+}
+
 /**
  * The one way a hint may name a key.
  *