@brftech/filex-core 0.40.0 → 0.41.1

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,89 @@
+/**
+ * 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, provide, watch, type Ref } from 'vue';
+import type { ExplorerConfig } from '../types/ExplorerConfig';
+import type { Capabilities } from '../types/FileNode';
+import { EXPLORER_CLOCK, 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): symbol {
+  const owner = Symbol('filex-explorer');
+  // Every component under this explorer reads its dates on this owner's
+  // tiers, not the page's newest (lib/timezone, timeZoneSourcesFor).
+  provide(EXPLORER_CLOCK, owner);
+
+  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));
+  return 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,