selfstore 1.8.5 → 1.8.7

package/dist/{flows-1EntUZ91.d.ts → flows-vX9zy9bI.d.ts}

@@ -47,7 +47,44 @@ interface FlowHost {
 type StoreLike = FlowHost | {
     flowHost: FlowHost;
 };
+/**
+ * A destination this device has already used, offered as one gesture back to
+ * it rather than as the question it answered the first time.
+ *
+ * The screen that asks "where should we save your data?" is right exactly
+ * once. Every time after that - a device whose destination was detached, a
+ * browser whose storage was cleared - the app usually still knows the answer,
+ * and asking again makes the returning user re-derive a decision they already
+ * made. This offer carries that memory: it goes first, above a separator, and
+ * says WHICH backup it will reopen.
+ *
+ * The host supplies the connector, because only the host knows how to reach
+ * the remembered destination (adopting a known file id, not searching by
+ * name). The flow supplies what follows: no conflict step, and no chooser.
+ */
+interface ResumeOffer {
+    /** Which destination it is. Picks the icon and the wording, nothing else. */
+    kind: ConnectKind;
+    /**
+     * What exactly is being reopened - the account, the file name. Rendered as
+     * the card's second line: "resume my backup" only answers the user's
+     * question when it can name the backup.
+     */
+    detail?: string;
+    /** Reopen it. Same contract as any connector: null when the user cancels. */
+    connect: Connector;
+}
 interface ConnectFlowOptions {
+    /**
+     * The destination this device already used, offered ahead of the others.
+     * Absent (the default) means every visit is a first visit.
+     *
+     * Taking this offer never raises the conflict step, whatever
+     * `hasLocalData` says: reopening one's own backup is not a merge question,
+     * it IS the answer to it. The question still stands for a destination the
+     * user newly points at.
+     */
+    resume?: ResumeOffer;
     /** Declare when this device holds data worth a question: only then does an
      *  existing backup raise the 'conflict' step with the destructive choices.
      *  Default: never - the flow applies defaultResolution. */
@@ -126,6 +163,10 @@ interface ConnectFlow extends FlowStore<ConnectSnapshot> {
      *  with the object form, `variant` picks the gesture: 'create' (default,
      *  save picker) or 'open' (adopt an existing backup file). */
     choose(kind: ConnectKind, variant?: 'create' | 'open'): void;
+    /** Reopen the remembered destination (`options.resume`). Same gesture rule
+     *  as choose - call it inside the click. No-op when nothing is remembered.
+     *  Never raises the conflict step: this backup is already this device's. */
+    resume(): void;
     /** 'form' step (webdav: true): submit the server config. */
     submitWebdav(config: WebdavConfig): void;
     /** 'form' step (s3: true): submit the bucket config. */
@@ -323,4 +364,4 @@ declare function joinFlow(link: string, engine: JoinEngine, options?: {
     deadlineMs?: number;
 }): JoinFlow;
 
-export { replicaFlow as A, shareFlow as B, type ConnectTargets as C, type FlowHost as F, type JoinEngine as J, type ReplicaFlow as R, type StoreLike as S, type ConnectFlowOptions as a, type ConnectKind as b, type ConnectFlow as c, type ShareEngine as d, type ShareLevel as e, type ShareFlow as f, type JoinFlow as g, type ConnectFlowOutcome as h, type ConnectResolution as i, type ConnectSnapshot as j, type ConnectStep as k, type Connector as l, type JoinOutcome as m, type JoinPreview as n, type JoinSnapshot as o, type JoinStep as p, REPLICA_ID as q, type ReplicaFlowOptions as r, type ReplicaSnapshot as s, type ReplicaStep as t, type ShareBusy as u, type ShareLinkInfo as v, type ShareMemberInfo as w, type ShareSnapshot as x, connectFlow as y, joinFlow as z };
+export { joinFlow as A, replicaFlow as B, type ConnectTargets as C, shareFlow as D, type FlowHost as F, type JoinEngine as J, type ReplicaFlow as R, type StoreLike as S, type ConnectFlowOptions as a, type ConnectKind as b, type ConnectFlow as c, type ShareEngine as d, type ShareLevel as e, type ShareFlow as f, type JoinFlow as g, type ConnectFlowOutcome as h, type ConnectResolution as i, type ConnectSnapshot as j, type ConnectStep as k, type Connector as l, type JoinOutcome as m, type JoinPreview as n, type JoinSnapshot as o, type JoinStep as p, REPLICA_ID as q, type ReplicaFlowOptions as r, type ReplicaSnapshot as s, type ReplicaStep as t, type ResumeOffer as u, type ShareBusy as v, type ShareLinkInfo as w, type ShareMemberInfo as x, type ShareSnapshot as y, connectFlow as z };

package/dist/flows.d.ts

@@ -1,4 +1,4 @@
-export { c as ConnectFlow, a as ConnectFlowOptions, h as ConnectFlowOutcome, b as ConnectKind, i as ConnectResolution, j as ConnectSnapshot, k as ConnectStep, C as ConnectTargets, l as Connector, F as FlowHost, J as JoinEngine, g as JoinFlow, m as JoinOutcome, n as JoinPreview, o as JoinSnapshot, p as JoinStep, q as REPLICA_ID, R as ReplicaFlow, r as ReplicaFlowOptions, s as ReplicaSnapshot, t as ReplicaStep, u as ShareBusy, d as ShareEngine, f as ShareFlow, e as ShareLevel, v as ShareLinkInfo, w as ShareMemberInfo, x as ShareSnapshot, y as connectFlow, z as joinFlow, A as replicaFlow, B as shareFlow } from './flows-1EntUZ91.js';
+export { c as ConnectFlow, a as ConnectFlowOptions, h as ConnectFlowOutcome, b as ConnectKind, i as ConnectResolution, j as ConnectSnapshot, k as ConnectStep, C as ConnectTargets, l as Connector, F as FlowHost, J as JoinEngine, g as JoinFlow, m as JoinOutcome, n as JoinPreview, o as JoinSnapshot, p as JoinStep, q as REPLICA_ID, R as ReplicaFlow, r as ReplicaFlowOptions, s as ReplicaSnapshot, t as ReplicaStep, u as ResumeOffer, v as ShareBusy, d as ShareEngine, f as ShareFlow, e as ShareLevel, w as ShareLinkInfo, x as ShareMemberInfo, y as ShareSnapshot, z as connectFlow, A as joinFlow, B as replicaFlow, D as shareFlow } from './flows-vX9zy9bI.js';
 export { F as FlowStore, w as withDeadline } from './machine-ALMkT3mk.js';
 import './store-BiQ-BuVl.js';
 import './cache-ilsK3Tki.js';

package/dist/flows.js

@@ -1,4 +1,4 @@
-export { connectFlow, joinFlow, shareFlow } from './chunk-PNX7AJYO.js';
+export { connectFlow, joinFlow, shareFlow } from './chunk-LKIRWVXM.js';
 import { connect as connect$1, connect3, connect2, fromSession as fromSession$1, fromSession2, fromSession3 } from './chunk-TKWU52LK.js';
 import { makeMachine, toStoreError } from './chunk-W22V5CRM.js';
 export { withDeadline } from './chunk-W22V5CRM.js';

package/dist/index.d.ts

@@ -4,7 +4,7 @@ import { L as LocalCache, K as KV } from './cache-ilsK3Tki.js';
 import { SyncConfig } from './sync.js';
 import { i as DriveAuth } from './drive-CTYvGg_7.js';
 import { W as WebdavConfig, S as S3Config } from './s3-DvsnA-FK.js';
-export { c as changePassword, g as gisDriveAuth, p as pickFromDisk, s as saveToDisk } from './local-C52j3DeH.js';
+export { f as changePassword, g as gisDriveAuth, p as pickFromDisk, s as saveToDisk } from './local-VLHtF3vT.js';
 
 declare const BACKUP_EXTENSION = ".zip";
 declare const BACKUP_MIME = "application/zip";

package/dist/index.js

@@ -1,5 +1,5 @@
-import { indexedDbCache, memoryCache, isLockableCache, createLocalStore } from './chunk-ELDSPUTS.js';
-export { gisDriveAuth } from './chunk-ELDSPUTS.js';
+import { indexedDbCache, memoryCache, isLockableCache, createLocalStore } from './chunk-TXAMWBG5.js';
+export { gisDriveAuth } from './chunk-TXAMWBG5.js';
 import './chunk-SKWHKM25.js';
 import { saveToDisk } from './chunk-DCEXWSM6.js';
 export { pickFromDisk, saveToDisk } from './chunk-DCEXWSM6.js';

package/dist/{local-C52j3DeH.d.ts → local-VLHtF3vT.d.ts}

@@ -21,19 +21,54 @@ declare function changePassword(input: Blob | Uint8Array, opts: {
 
 /**
  * A client-only DriveAuth: the Google Identity Services token flow, no backend.
- * The access token is cached in sessionStorage so a reload reuses it, and a
- * silent re-acquisition is attempted when it lapses; if that fails (the Google
- * session expired, or third-party cookies are blocked) the Drive target reports
- * needs-attention and the user reconnects in one click. For a connection that
- * never re-prompts, back the Drive target with a server that holds a refresh
- * token instead (a broker implementing the same DriveAuth interface).
+ *
+ * What this flow can and cannot do, because it decides how often a user is
+ * interrupted. Google's browser token flow issues an access token that lives
+ * about an hour and NO refresh token - a refresh token requires a client secret,
+ * which requires a server. And `requestAccessToken` always opens a popup, even
+ * with `prompt: ''`: the popup closes by itself when the grant is still on file,
+ * but opening it at all needs a user gesture. So a purely client-side app cannot
+ * silently re-acquire a token on page load. What it CAN do:
+ *
+ *   - reuse a token it already has (`persist: 'session'`), so a reload inside the
+ *     hour asks for nothing at all;
+ *   - name the account (`hint`), so the popup does not ask which one;
+ *   - re-grant without the consent screen (`prompt: ''` before `'consent'`) -
+ *     which is also what stops Google mailing "you granted access" every time.
+ *
+ * For a connection that never re-prompts, back the Drive target with a server
+ * that holds a refresh token instead (a broker implementing this same DriveAuth).
  */
 
-/** Build a client-only DriveAuth for the given OAuth client id (no backend). */
-declare function gisDriveAuth(opts: {
+/** Where the access token survives between requests. */
+type GisTokenPersistence = 'memory' | 'session';
+interface GisDriveAuthOptions {
     clientId: string;
     scope?: string;
-}): DriveAuth;
+    /**
+     * The account to re-grant for, so the popup does not ask which one. Pass the
+     * address the app remembers (`driveTarget.account()` answers it once
+     * connected); a function is read at every request, for a host that only
+     * learns it after the first connect.
+     */
+    hint?: string | (() => string | null | undefined);
+    /**
+     * Where the access token lives between requests.
+     *
+     * `'memory'` (the default) keeps it in a closure and nowhere else: a reload
+     * has to re-acquire it, which needs a click, but no Drive-scoped credential is
+     * ever written to web storage.
+     *
+     * `'session'` also keeps it in `sessionStorage`, so a reload reuses the token
+     * it already has and asks for nothing. That token is a bearer credential for
+     * the `drive.file` scope, readable by any script on the origin; it dies with
+     * the tab and within the hour. Opt in for an app whose users reload often;
+     * leave it alone where an XSS on the origin must find nothing to lift.
+     */
+    persist?: GisTokenPersistence;
+}
+/** Build a client-only DriveAuth for the given OAuth client id (no backend). */
+declare function gisDriveAuth(opts: GisDriveAuthOptions): DriveAuth;
 
 /**
  * Save a backup blob to disk via the File System Access API, else a download.
@@ -62,4 +97,4 @@ declare function datedName(filename: string, when?: Date): string;
 /** Prompt the user to pick a backup file from disk. Resolves null if cancelled. */
 declare function pickFromDisk(): Promise<File | null>;
 
-export { inspect as a, isEncrypted as b, changePassword as c, datedName as d, exportSnapshot as e, gisDriveAuth as g, importSnapshot as i, pickFromDisk as p, saveToDisk as s };
+export { type GisDriveAuthOptions as G, type GisTokenPersistence as a, inspect as b, isEncrypted as c, datedName as d, exportSnapshot as e, changePassword as f, gisDriveAuth as g, importSnapshot as i, pickFromDisk as p, saveToDisk as s };

package/dist/widgets.d.ts

@@ -1,4 +1,4 @@
-import { F as FlowHost, S as StoreLike, C as ConnectTargets, a as ConnectFlowOptions, b as ConnectKind, c as ConnectFlow, d as ShareEngine, e as ShareLevel, f as ShareFlow, J as JoinEngine, g as JoinFlow, R as ReplicaFlow } from './flows-1EntUZ91.js';
+import { F as FlowHost, S as StoreLike, C as ConnectTargets, a as ConnectFlowOptions, b as ConnectKind, c as ConnectFlow, d as ShareEngine, e as ShareLevel, f as ShareFlow, J as JoinEngine, g as JoinFlow, R as ReplicaFlow } from './flows-vX9zy9bI.js';
 import { f as BackupsManager } from './manager-DZ1c_aSS.js';
 import './store-BiQ-BuVl.js';
 import './cache-ilsK3Tki.js';
@@ -127,6 +127,15 @@ declare class SelfstoreConnectElement extends FlowWidget {
     attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
     connectedCallback(): void;
     private wire;
+    /**
+     * The destination choice: the way back first, then a rule, then the ways
+     * forward.
+     *
+     * Its own method because `view` covers every step of the journey and was at
+     * the complexity cap; this is the step that keeps growing, since it is the
+     * one the host shapes.
+     */
+    private viewChoose;
     protected view(into: HTMLElement): void;
     /**
      * A form field that keeps its name once you start typing.
@@ -137,6 +146,15 @@ declare class SelfstoreConnectElement extends FlowWidget {
      * never a label.
      */
     private labelled;
+    /**
+     * The destination this device already used, first and on its own.
+     *
+     * It carries the same shape as an ordinary card so nothing new has to be
+     * styled, and the host's icon for that kind, so it reads as the same place
+     * rather than a fourth option. Its second line names WHICH backup - without
+     * that, "resume my backup" is one more thing to wonder about.
+     */
+    private resumeCard;
     private destCard;
     /** The grouped "your own server" card shown when both WebDAV and S3 are
      *  offered: one entry into the tabbed form, opening on the first server kind. */

package/dist/widgets.js

@@ -1,5 +1,5 @@
 import { saveToDisk, datedName } from './chunk-DCEXWSM6.js';
-import { connectFlow, shareFlow, joinFlow } from './chunk-PNX7AJYO.js';
+import { connectFlow, shareFlow, joinFlow } from './chunk-LKIRWVXM.js';
 import { isOpenSupported } from './chunk-TKWU52LK.js';
 import './chunk-W22V5CRM.js';
 import './chunk-J5MFXJU6.js';
@@ -81,6 +81,24 @@ button[part~='dot-button'] {
 }
 button[part~='card'] { cursor: pointer; font: inherit; color: inherit; }
 button[part~='card']:hover { border-color: var(--_accent); }
+/* The rule between "go back to what you had" and "start something new". A word
+   sits in the gap rather than beside it, so the two groups read as two even
+   before either is read. */
+[part~='separator'] {
+	display: flex;
+	align-items: center;
+	gap: 0.7rem;
+	margin: 0.15rem 0;
+	color: var(--_ink-dim);
+	font-size: 0.85em;
+}
+[part~='separator']::before,
+[part~='separator']::after {
+	content: '';
+	flex: 1;
+	height: 1px;
+	background: var(--_border);
+}
 img[part~='icon'] {
 	width: var(--selfstore-icon-size, 2.1em);
 	height: var(--selfstore-icon-size, 2.1em);
@@ -487,6 +505,10 @@ var FlowWidget = class extends HTMLElement {
 var EN = {
   "connect.title": "Where should we save your data?",
   "connect.recommended": "Recommended",
+  // The way back, and the rule under it. A host that can name the destination
+  // overrides this with something less abstract ("Resume my Google Drive").
+  "connect.resume": "Resume my backup",
+  "connect.or": "or",
   "connect.drive": "Google Drive",
   "connect.drive.sub": "Available on all your devices",
   "connect.file": "A file on this device",
@@ -548,6 +570,8 @@ var EN = {
 var FR = {
   "connect.title": "O\xF9 enregistrer vos donn\xE9es ?",
   "connect.recommended": "Recommand\xE9",
+  "connect.resume": "Reprendre ma sauvegarde",
+  "connect.or": "ou",
   "connect.drive": "Google Drive",
   "connect.drive.sub": "Disponible sur tous vos appareils",
   "connect.file": "Un fichier sur cet appareil",
@@ -755,39 +779,54 @@ var SelfstoreConnectElement = class extends FlowWidget {
       this.rerender();
     });
   }
+  /**
+   * The destination choice: the way back first, then a rule, then the ways
+   * forward.
+   *
+   * Its own method because `view` covers every step of the journey and was at
+   * the complexity cap; this is the step that keeps growing, since it is the
+   * one the host shapes.
+   */
+  viewChoose(into, s) {
+    put(into, this.heading("title", "connect.title"));
+    const offer = this.#options.resume;
+    if (offer) {
+      into.append(this.resumeCard(offer));
+      into.append(h("div", { part: "separator" }, h("span", {}, this.t("connect.or"))));
+    }
+    const serverKinds = ["webdav", "s3"].filter(
+      (k) => s.kinds.includes(k) && !this.#advanced.includes(k)
+    );
+    const groupServer = serverKinds.length >= 2;
+    for (const kind of s.kinds) {
+      if (this.#advanced.includes(kind)) continue;
+      if (groupServer && (kind === "webdav" || kind === "s3")) {
+        if (kind === serverKinds[0]) into.append(this.serverCard(serverKinds[0]));
+        continue;
+      }
+      into.append(this.destCard(kind));
+    }
+    for (const kind of s.kinds) {
+      if (!this.#advanced.includes(kind)) continue;
+      into.append(
+        h(
+          "button",
+          {
+            part: "link advanced-link",
+            "data-kind": kind,
+            onclick: () => this.#flow?.choose(kind)
+          },
+          this.t(`connect.${kind}`)
+        )
+      );
+    }
+  }
   view(into) {
     const flow = this.#flow;
     if (!flow) return;
     const s = flow.snapshot;
     if (s.step === "choose") {
-      put(into, this.heading("title", "connect.title"));
-      const serverKinds = ["webdav", "s3"].filter(
-        (k) => s.kinds.includes(k) && !this.#advanced.includes(k)
-      );
-      const groupServer = serverKinds.length >= 2;
-      for (const kind of s.kinds) {
-        if (this.#advanced.includes(kind)) continue;
-        if (groupServer && (kind === "webdav" || kind === "s3")) {
-          if (kind === serverKinds[0]) into.append(this.serverCard(serverKinds[0]));
-          continue;
-        }
-        into.append(this.destCard(kind));
-      }
-      for (const kind of s.kinds) {
-        if (this.#advanced.includes(kind)) {
-          into.append(
-            h(
-              "button",
-              {
-                part: "link advanced-link",
-                "data-kind": kind,
-                onclick: () => this.#flow?.choose(kind)
-              },
-              this.t(`connect.${kind}`)
-            )
-          );
-        }
-      }
+      this.viewChoose(into, s);
       return;
     }
     if (s.step === "form") {
@@ -962,6 +1001,30 @@ var SelfstoreConnectElement = class extends FlowWidget {
   labelled(labelKey, input) {
     return h("label", { part: "labelled" }, h("span", { part: "label" }, this.t(labelKey)), input);
   }
+  /**
+   * The destination this device already used, first and on its own.
+   *
+   * It carries the same shape as an ordinary card so nothing new has to be
+   * styled, and the host's icon for that kind, so it reads as the same place
+   * rather than a fourth option. Its second line names WHICH backup - without
+   * that, "resume my backup" is one more thing to wonder about.
+   */
+  resumeCard(offer) {
+    const icon = this.#icons[offer.kind] ?? defaultIcons[offer.kind];
+    const head = icon ? h("img", { part: "icon", src: icon, alt: "" }) : null;
+    const title = h("div", { part: "title" }, this.t("connect.resume"));
+    const sub = offer.detail ? h("div", { part: "sub" }, offer.detail) : null;
+    return h(
+      "button",
+      {
+        part: "card resume-card",
+        "data-kind": offer.kind,
+        onclick: () => this.#flow?.resume()
+      },
+      head,
+      h("div", {}, title, sub)
+    );
+  }
   destCard(kind) {
     const icon = this.#icons[kind] ?? defaultIcons[kind];
     const head = icon ? h("img", { part: "icon", src: icon, alt: "" }) : null;