@brftech/filex-core 0.41.0 → 0.41.1

package/src/composables/useRowTouch.ts

@@ -0,0 +1,95 @@
+/**
+ * useRowTouch — the one touch grammar every file view speaks (list, grid,
+ * gallery).
+ *
+ * A mouse selects with a click and opens with a double-click. A finger has no
+ * double-click: the browser swallows the second tap into a zoom or never sends
+ * `dblclick` at all, so on a phone the desktop grammar left nothing openable
+ * (issue #26). What a finger does instead is what every mobile file manager
+ * does:
+ *
+ *   - a long press opens the item's menu (and, through it, selects the item);
+ *   - a tap is reported AS a tap, so the host can open instead of select.
+ *
+ * The views only report. What a tap means is decided once, in FilePane.
+ *
+ * ⚠ A tap is judged from the gesture that produced the click, never from the
+ * screen: `pointerType` where the browser sets it on click (Chromium, Firefox),
+ * and the touchend that just preceded the click where it does not (older
+ * WebKit). A touch laptop's trackpad therefore keeps the desktop grammar while
+ * its screen gets the phone one. A `(pointer: coarse)` media query cannot tell
+ * those two apart.
+ *
+ * ⚠ It used to live as three identical copies of the long-press timer, one per
+ * view; the tap rule is exactly the kind of addition a copy misses.
+ */
+import { onBeforeUnmount } from 'vue';
+
+/** How long a finger rests before the press becomes a long press. */
+export const LONG_PRESS_MS = 500;
+/** A click this soon after a touchend is the tap that touchend ended. */
+const TAP_WINDOW_MS = 800;
+/** A finger that travels further than this is scrolling, not pressing. */
+const MOVE_TOLERANCE_PX = 10;
+
+export interface TouchPoint {
+  clientX: number;
+  clientY: number;
+}
+
+export function useRowTouch<T>(onLongPress: (item: T, at: TouchPoint) => void) {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let target: T | null = null;
+  let origin: TouchPoint = { clientX: 0, clientY: 0 };
+  let longPressed = false;
+  let tapEndedAt = 0;
+
+  function stopTimer() {
+    if (timer) clearTimeout(timer);
+    timer = undefined;
+  }
+
+  function onTouchStart(item: T, ev: TouchEvent) {
+    const t0 = ev.touches[0];
+    if (!t0) return;
+    stopTimer();
+    target = item;
+    longPressed = false;
+    origin = { clientX: t0.clientX, clientY: t0.clientY };
+    timer = setTimeout(() => {
+      timer = undefined;
+      if (target === null) return;
+      longPressed = true;
+      onLongPress(target, origin);
+    }, LONG_PRESS_MS);
+  }
+
+  function onTouchMove(ev: TouchEvent) {
+    const t0 = ev.touches[0];
+    if (
+      !t0 ||
+      Math.abs(t0.clientX - origin.clientX) > MOVE_TOLERANCE_PX ||
+      Math.abs(t0.clientY - origin.clientY) > MOVE_TOLERANCE_PX
+    ) {
+      stopTimer();
+      target = null;
+    }
+  }
+
+  function onTouchEnd() {
+    stopTimer();
+    if (target !== null && !longPressed) tapEndedAt = Date.now();
+    target = null;
+  }
+
+  /** Whether this click is a finger's tap. */
+  function isTap(ev: MouseEvent): boolean {
+    const kind = (ev as PointerEvent).pointerType;
+    if (kind) return kind === 'touch';
+    return Date.now() - tapEndedAt < TAP_WINDOW_MS;
+  }
+
+  onBeforeUnmount(stopTimer);
+
+  return { onTouchStart, onTouchMove, onTouchEnd, isTap };
+}

package/src/lib/shareTtl.ts

@@ -74,7 +74,12 @@ export function expiryInputMax(maxDays: number | undefined, now: Date = new Date
 }
 
 /** "Valid until 30 Aug 2026, 14:05" / "Does not expire" from the server's `expires_at`. */
-export function validUntilLine(expiresAt: string | null | undefined, locale: 'tr' | 'en'): string {
+export function validUntilLine(
+  expiresAt: string | null | undefined,
+  locale: 'tr' | 'en',
+  /** The explorer whose clock applies (lib/timezone EXPLORER_CLOCK). */
+  clock?: symbol,
+): string {
   if (!expiresAt) return locale === 'tr' ? 'Bu bağlantının süresi yoktur.' : 'This link does not expire.';
   const d = new Date(expiresAt);
   // zaman:z1 — the viewer's chosen clock, not the browser's. "Valid until
@@ -87,7 +92,7 @@ export function validUntilLine(expiresAt: string | null | undefined, locale: 'tr
   // dialog and "Sep 20, 2026, 1:53 PM" in the listing behind it.
   const when = Number.isNaN(d.getTime())
     ? expiresAt
-    : formatInstant(d, locale, { dateStyle: 'medium', timeStyle: 'short' });
+    : formatInstant(d, locale, { dateStyle: 'medium', timeStyle: 'short' }, clock);
   return locale === 'tr' ? `Bu bağlantı ${when} tarihine kadar geçerli.` : `This link is valid until ${when}.`;
 }
 
@@ -99,3 +104,17 @@ export function ttlCeilingHint(maxDays: number | undefined, locale: 'tr' | 'en')
     ? `Bağlantılar en fazla ${max} gün geçerli olabilir (sunucu ayarı).`
     : `Links can be valid for at most ${max} day${max === 1 ? '' : 's'} (server setting).`;
 }
+
+/**
+ * The share dialog's muted detail line: its facts joined with " · ".
+ *
+ * ⚠ The first fact is a whole sentence ("This link is valid until …, 10:00
+ * AM.") and the ones after it are fragments ("3 downloads"), so a plain join
+ * printed "10:00 AM. · 3 downloads" — a full stop in the middle of a line. A
+ * fact that is followed by another loses its closing full stop; the last one
+ * keeps whatever it has.
+ */
+export function shareDetailLine(facts: Array<string | null | undefined>): string {
+  const kept = facts.filter((f): f is string => !!f);
+  return kept.map((f, i) => (i < kept.length - 1 ? f.replace(/\.\s*$/, '') : f)).join(' · ');
+}

package/src/lib/timezone.ts

@@ -36,7 +36,7 @@
  * that is shared state by nature — the browser's.
  */
 
-import { computed, ref, type Ref } from 'vue';
+import { computed, ref, type InjectionKey, type Ref } from 'vue';
 
 /* ── the order ────────────────────────────────────────────────────────── */
 
@@ -312,6 +312,11 @@ function ownedTier() {
       const list = entries.value;
       return list.length ? list[list.length - 1].zone : '';
     },
+    /** The newest answer among the owners `pick` accepts. */
+    currentWhere(pick: (owner: symbol) => boolean): string {
+      const list = entries.value.filter((e) => pick(e.owner));
+      return list.length ? list[list.length - 1].zone : '';
+    },
   };
 }
 
@@ -345,6 +350,46 @@ export function resolvedTimeZone(): ResolvedTimeZone {
   return resolved.value;
 }
 
+/**
+ * The owner key an explorer PROVIDES to its components, so the dates they
+ * print resolve against that explorer's own tiers (useLocale injects it).
+ */
+export const EXPLORER_CLOCK: InjectionKey<symbol> = Symbol('filex-explorer-clock');
+
+/**
+ * What the tiers hold for ONE explorer.
+ *
+ * ⚠⚠ The page-wide tiers answer with the NEWEST write, which is right for a
+ * surface outside every explorer and wrong inside one: two explorers on one
+ * page with different `config.timeZone` both printed the zone of whichever
+ * mounted last. The host tier is by definition one explorer's setting, so an
+ * explorer reads only its own. Its account tier is its own too; the only other
+ * account it may inherit is the one a HOST APP remembered for the person
+ * signed in (the admin app's session, `remember: true`) — never a sibling
+ * explorer's, which may belong to a different key altogether. The viewer tier
+ * is this browser's, shared by everything on the page.
+ *
+ * `owner` undefined is the page-wide answer, unchanged.
+ */
+export function timeZoneSourcesFor(owner: symbol | undefined): Required<TimeZoneSources> {
+  if (!owner) return timeZoneSources();
+  return {
+    viewer: viewerZone.value,
+    host: hostTier.of(owner) ?? '',
+    account: accountTier.of(owner) ?? accountTier.currentWhere((o) => rememberingOwners.has(o)),
+  };
+}
+
+/** resolvedTimeZone for ONE explorer (see timeZoneSourcesFor). Reactive. */
+export function resolvedTimeZoneFor(owner: symbol | undefined): ResolvedTimeZone {
+  return owner ? resolveTimeZone(timeZoneSourcesFor(owner)) : resolved.value;
+}
+
+/** activeTimeZone for ONE explorer (see timeZoneSourcesFor). Reactive. */
+export function activeTimeZoneFor(owner: symbol | undefined): string | undefined {
+  return resolvedTimeZoneFor(owner).zone;
+}
+
 /** What each tier currently holds (`''` = nothing). Reactive. */
 export function timeZoneSources(): Required<TimeZoneSources> {
   return {

package/src/locales/en.ts

@@ -1081,6 +1081,8 @@ export const en: Record<string, string> = {
   'conn.tokens.rootPlaceholder': 'storage://folder',
   'conn.tokens.expiry': 'Expires in (days)',
   'conn.tokens.expiryNever': 'never',
+  'conn.tokens.defaultName': 'API key {date}',
+  'conn.tokens.namePlaceholder': 'Name — e.g. backup script',
   'conn.tokens.capNote': 'Your account and its permissions are the ceiling — asking for more than you have is refused, not granted.',
   /* === /gezinti:g1 === */
 

package/src/locales/tr.ts

@@ -1079,6 +1079,8 @@ export const tr: Record<string, string> = {
   'conn.tokens.rootPlaceholder': 'depo://klasör',
   'conn.tokens.expiry': 'Geçerlilik (gün)',
   'conn.tokens.expiryNever': 'süresiz',
+  'conn.tokens.defaultName': 'API anahtarı {date}',
+  'conn.tokens.namePlaceholder': 'Ad — ör. yedekleme betiği',
   'conn.tokens.capNote': 'Tavan hesabın ve yetkilerin — sahip olduğundan fazlasını istemek reddedilir, verilmez.',
   /* === /gezinti:g1 === */
 

package/src/modals/PermissionsModal.vue

@@ -27,11 +27,19 @@
  * (`gorunum:v2-share`). A scoped style block here is silently dropped in the
  * web-component build — see web/tests/api/scopedStyles.test.ts.
  */
-import { ref, onMounted, onBeforeUnmount, computed, watch } from 'vue';
+import { ref, onMounted, onBeforeUnmount, computed, inject, watch } from 'vue';
 import type { FileApi, Grant, UserSuggestion } from '../composables/useFileApi';
 import type { ShareInfo } from '../types/FileNode';
 import { shareCliCommand } from '../lib/shareCli';
-import { STOCK_EXPIRY_DAYS, clampExpiryOptions, defaultExpiryDays, ttlCeilingHint, validUntilLine } from '../lib/shareTtl';
+import {
+  STOCK_EXPIRY_DAYS,
+  clampExpiryOptions,
+  defaultExpiryDays,
+  shareDetailLine,
+  ttlCeilingHint,
+  validUntilLine,
+} from '../lib/shareTtl';
+import { EXPLORER_CLOCK } from '../lib/timezone';
 import { resolveLocale } from '../locales/resolve';
 import { formatByteSize, useLocale } from '../composables/useLocale';
 import { actionIconSvg } from '../lib/actionIcons';
@@ -636,8 +644,11 @@ function expiryLine(days: number): string {
 }
 // What the server actually stored — shown under a fresh link so the real
 // expiry is visible even when the server shortened the request.
+// The explorer this dialog belongs to reads deadlines on its own clock.
+const clock = inject(EXPLORER_CLOCK, undefined);
+
 function validUntil(r: { expiresAt?: string | null } | null): string {
-  return validUntilLine(r?.expiresAt ?? null, tr.value ? 'tr' : 'en');
+  return validUntilLine(r?.expiresAt ?? null, tr.value ? 'tr' : 'en', clock);
 }
 
 /* ── the top tier: one switch, one sentence, one link ──────────────────── */
@@ -671,10 +682,10 @@ const linkDetail = computed(() => {
     if (shareMaxDl.value) bits.push(maxDlOptions.find((o) => o.v === shareMaxDl.value)?.l ?? '');
   } else if (downloadShares.value[0]) {
     const s = downloadShares.value[0];
-    bits.push(validUntilLine(s.expires_at ?? null, tr.value ? 'tr' : 'en'));
+    bits.push(validUntil({ expiresAt: s.expires_at ?? null }));
     if (s.max_downloads) bits.push(maxDlOptions.find((o) => o.v === s.max_downloads)?.l ?? String(s.max_downloads));
   }
-  return bits.filter(Boolean).join(' · ');
+  return shareDetailLine(bits);
 });
 
 /* Section summaries — a named section still has to say what is inside it, or