@wssto2/vue-core 0.4.28 → 0.5.0

package/dist/{neighbors-RVQ4O3Qv.js → neighbors-IMRQ4rkm.js}

@@ -1,7 +1,7 @@
 import { computed as j, ref as z, shallowRef as I, watch as F, getCurrentScope as J, onScopeDispose as Q } from "vue";
 import { useRoute as O } from "vue-router";
-import { i as N } from "./error-CD7x0Jrz.js";
-import { L as k, d as B, e as D, o as U, q as V } from "./http-BFfkA7gN.js";
+import { a as N } from "./error-Bb_dr_Ay.js";
+import { L as k, d as B, e as D, o as U, q as V } from "./http-D_pBg22D.js";
 function K(l, t, n, g) {
   return typeof t == "string" ? t : { ...t, query: { ...t.query, [n]: D(l, g) } };
 }
@@ -18,13 +18,13 @@ function le(l, t) {
   };
 }
 const W = 8;
-function re(l, t) {
+function ae(l, t) {
   const n = O(), g = t.from ?? (() => typeof n.query[k] == "string" ? n.query[k] : null), q = t.stateKey ?? "query", f = z(null), p = z(0), h = I(null), m = I(null), S = z(!1), x = I(null), o = /* @__PURE__ */ new Map();
   let d = 0, C = new AbortController(), E = !1;
-  function L(w, b, a) {
+  function L(w, b, r) {
     const v = { ...w, page: b }, i = V(v);
     let u = o.get(i);
-    for (u ? o.delete(i) : (u = (async () => l.load(v, { signal: a }))(), u.catch(() => {
+    for (u ? o.delete(i) : (u = (async () => l.load(v, { signal: r }))(), u.catch(() => {
       o.get(i) === u && o.delete(i);
     })), o.set(i, u); o.size > W; ) o.delete(o.keys().next().value);
     return u.catch((e) => {
@@ -36,48 +36,48 @@ function re(l, t) {
     f.value = null, h.value = null, m.value = null, p.value = 0;
   }
   async function _() {
-    const w = ++d, b = C.signal, a = B(l, g()), v = t.current();
-    if (x.value = a ? K(l, t.list, q, a) : null, !a || v === null || v === void 0 || v === "") {
+    const w = ++d, b = C.signal, r = B(l, g()), v = t.current();
+    if (x.value = r ? K(l, t.list, q, r) : null, !r || v === null || v === void 0 || v === "") {
       T(), S.value = !1;
       return;
     }
     S.value = !0, h.value = null, m.value = null;
-    const i = (e) => e ? e.rows.findIndex((r) => String(l.key(r)) === String(v)) : -1, u = (e, r) => {
-      const s = D(l, { ...a, page: e });
+    const i = (e) => e ? e.rows.findIndex((a) => String(l.key(a)) === String(v)) : -1, u = (e, a) => {
+      const s = D(l, { ...r, page: e });
       return {
-        key: r,
+        key: a,
         get to() {
-          return { name: n.name ?? void 0, params: { ...n.params, [t.param]: String(r) }, query: { ...n.query, [k]: s }, hash: n.hash };
+          return { name: n.name ?? void 0, params: { ...n.params, [t.param]: String(a) }, query: { ...n.query, [k]: s }, hash: n.hash };
         }
       };
     };
     try {
-      let e = a.page, r = await L(a, e, b), s = i(r);
+      let e = r.page, a = await L(r, e, b), s = i(a);
       for (const y of [e - 1, e + 1]) {
-        if (s !== -1 || !r || y < 1 || y > r.lastPage) continue;
-        const c = await L(a, y, b), M = i(c);
-        c && M !== -1 && (e = y, r = c, s = M);
+        if (s !== -1 || !a || y < 1 || y > a.lastPage) continue;
+        const c = await L(r, y, b), M = i(c);
+        c && M !== -1 && (e = y, a = c, s = M);
       }
       if (w !== d) return;
-      if (!r || s === -1) {
+      if (!a || s === -1) {
         T();
         return;
       }
-      const X = r.pageSize || a.pageSize, A = r.rows;
+      const X = a.pageSize || r.pageSize, A = a.rows;
       let P = null;
       if (s > 0) P = u(e, l.key(A[s - 1]));
       else if (e > 1) {
-        const y = await L(a, e - 1, b), c = y?.rows[y.rows.length - 1];
+        const y = await L(r, e - 1, b), c = y?.rows[y.rows.length - 1];
         c !== void 0 && (P = u(e - 1, l.key(c)));
       }
       let R = null;
       if (s < A.length - 1) R = u(e, l.key(A[s + 1]));
-      else if (e < r.lastPage) {
-        const c = (await L(a, e + 1, b))?.rows[0];
+      else if (e < a.lastPage) {
+        const c = (await L(r, e + 1, b))?.rows[0];
         c !== void 0 && (R = u(e + 1, l.key(c)));
       }
       if (w !== d) return;
-      p.value = r.total, f.value = (e - 1) * X + s + 1, h.value = P, m.value = R, x.value = K(l, t.list, q, { ...a, page: e });
+      p.value = a.total, f.value = (e - 1) * X + s + 1, h.value = P, m.value = R, x.value = K(l, t.list, q, { ...r, page: e });
     } catch (e) {
       if (!N(e)) throw e;
     } finally {
@@ -100,6 +100,6 @@ function re(l, t) {
   } };
 }
 export {
-  re as a,
+  ae as a,
   le as u
 };

package/dist/notifications/context.d.ts

@@ -1,5 +1,6 @@
-import type { ShallowRef } from "vue";
+import type { Component, ShallowRef } from "vue";
 import type { IconName } from "../icon";
+import type { Preferences } from "../modules/notification/entities";
 import type { Hue } from "../state";
 import type { Inbox } from "./inbox";
 /** How a category of notification is drawn in the inbox: the icon of its row and the colour behind it. */
@@ -9,6 +10,24 @@ export interface NotificationCategoryLook {
     /** One of the category hues; default neutral. */
     hue?: Hue;
 }
+/**
+ * A section an application adds to the notification settings page: a title (and a line under it) in the page's own style, and the
+ * component, which renders its groups (`FormGroup`s of rows) and is given the person's `preferences` as a prop.
+ * The built-in sections sit at 0 (channels), 10 (quiet hours), 20 (this device) and 30 (devices); a section without an `order` comes
+ * after them, in the order given.
+ */
+export interface NotificationSettingsSection {
+    /** Unique among the sections and not one of the built-in ids (`channels`, `quiet`, `device`, `devices`). */
+    readonly id: string;
+    /** The application's message key of the section's title. */
+    readonly titleKey: string;
+    /** The key of the line under the title. */
+    readonly descriptionKey?: string;
+    readonly component: Component;
+    readonly order?: number;
+    /** Leaves the section out for these preferences. Default: always shown. */
+    readonly visible?: (preferences: Preferences) => boolean;
+}
 /** What the bell and the inbox read from the feature that installed them. */
 export interface NotificationsContext {
     /** The signed-in session's inbox; null while nobody is signed in (it is made and ended with the session). */
@@ -16,5 +35,9 @@ export interface NotificationsContext {
     readonly categories: Readonly<Record<string, NotificationCategoryLook>>;
     /** Whether the settings page is installed: the inbox shows its gear. */
     readonly settings: boolean;
+    /** Whether web push is installed: its sections on the settings page (shown when the server has push) and the sync of this browser's subscription. */
+    readonly push: boolean;
+    /** The sections the application added to the settings page. */
+    readonly sections: readonly NotificationSettingsSection[];
 }
 export declare const notificationsContextKey: import("vue").InjectionKey<NotificationsContext>, useNotificationsContext: () => NotificationsContext;

package/dist/notifications/feature.d.ts

@@ -1,6 +1,6 @@
 import { type Feature } from "../app";
 import type { Destination } from "../router";
-import { type NotificationCategoryLook } from "./context";
+import { type NotificationCategoryLook, type NotificationSettingsSection } from "./context";
 export interface NotificationsFeatureOptions {
     /** How each category the application declared in go-core is drawn: the icon of its rows and the colour behind it. A category without an entry gets the bell on a neutral tile. */
     categories?: Readonly<Record<string, NotificationCategoryLook>>;
@@ -20,6 +20,15 @@ export interface NotificationsFeatureOptions {
      * split at its dots; a category without a text is shown by its code. `false` leaves the page, the menu entry and the gear out. Default true.
      */
     settings?: boolean;
+    /** Sections of the application's own on the settings page (`NotificationSettingsSection`: a title, groups of rows), placed by `order` among the built-in ones. */
+    settingsSections?: readonly NotificationSettingsSection[];
+    /**
+     * Web push: on the settings page the "This device" section (turn push on for this browser) and the list of devices, both shown only
+     * when the server has push (`push_available`), the push switch next to e-mail for each category, and, for a signed-in person whose
+     * browser already holds a subscription, registering it again once per session (and removing it when they sign out). The
+     * service worker is the application's own: it imports `@wssto2/vue-core/push-worker`. `false` leaves all of it out. Default true.
+     */
+    push?: boolean;
 }
 /**
  * The in-app notifications of go-core's notification module, one feature to install: the bell with the

package/dist/notifications/index.d.ts

@@ -6,7 +6,7 @@ export type * as DeadLetterInputs from "../modules/events/schemas";
 export { eventsRoutes } from "../modules/events/routes";
 export { notificationsFeature } from "./feature";
 export type { NotificationsFeatureOptions } from "./feature";
-export type { NotificationCategoryLook } from "./context";
+export type { NotificationCategoryLook, NotificationSettingsSection } from "./context";
 export { notificationSettingsRoutes } from "./settings/routes";
 export type { NotificationSettingsRoutes } from "./settings/routes";
 export { deadLettersRoutes } from "./deadletters/routes";

package/dist/notifications/index.js

@@ -1,4 +1,4 @@
-import { d as s, e as o, n as a, a as i, b as n } from "../index-sTBBHqNG.js";
+import { d as s, e as o, n as a, b as i, c as n } from "../index-g-qbUeTk.js";
 export {
   s as deadLettersRoutes,
   o as eventsRoutes,

package/dist/notifications/push/DevicesSection.vue.d.ts

@@ -0,0 +1,12 @@
+import type { Devices } from "./devices";
+/**
+ * The browsers where the person turned push on, one row each: the name (the server's, from the browser), "This device" on
+ * the one in use, "Disabled" on one the server gave up on, when it was last used and last got a push. Rename in place,
+ * send a test (not to a disabled device), remove after a confirmation: the three are the row's "⋯" menu.
+ */
+type __VLS_Props = {
+    devices: Devices;
+    hash: string | null;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/notifications/push/ThisDeviceSection.vue.d.ts

@@ -0,0 +1,15 @@
+import type { ThisDevice } from "./thisDevice";
+/**
+ * Push on this browser, one state at a time: still reading it, not supported, an iPhone Safari tab (add the app to the
+ * home screen first), blocked (how to allow it again), off (turn it on from a tap), on. The permission prompt only ever
+ * comes from the action row.
+ */
+type __VLS_Props = {
+    device: ThisDevice;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    changed: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChanged?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/notifications/push/browser.d.ts

@@ -0,0 +1,40 @@
+import type { Subscription } from "../../modules/notification/schemas";
+/**
+ * What this browser can do with Web Push:
+ * - `supported`: the permission can be asked for from a tap;
+ * - `ios-browser`: an iPhone or iPad Safari tab, where push exists only in the app added to the home screen;
+ * - `unsupported`: no Push API or no service worker (an old browser, a dev server without a worker, an iframe).
+ */
+export type PushSupport = "supported" | "ios-browser" | "unsupported";
+/** The browser's side of push, so the logic around it is testable and the real thing is one small adapter. */
+export interface PushBrowser {
+    support(): PushSupport;
+    /** `unknown` where there is no Notification API. */
+    permission(): NotificationPermission | "unknown";
+    /** Must be called from a tap. */
+    requestPermission(): Promise<NotificationPermission>;
+    /** This browser's subscription with the application's service worker; null when there is none (or no worker). */
+    subscription(): Promise<PushSubscription | null>;
+    /** Subscribes with the server's public key (base64url); null without a worker. */
+    subscribe(publicKey: string): Promise<PushSubscription | null>;
+}
+/** The VAPID public key (base64url) as the Push API wants it. */
+export declare function applicationServerKey(base64url: string): Uint8Array<ArrayBuffer>;
+/** Whether a subscription was made with this key; a rotated key needs a new subscription. A browser that does not report its key counts as matching. */
+export declare function subscribedWithKey(subscription: PushSubscription, base64url: string): boolean;
+/** The body go-core registers a device with; null for a subscription without keys. */
+export declare function toSubscription(subscription: PushSubscription): Subscription | null;
+/** Hex SHA-256 of the endpoint: the `endpoint_hash` go-core keeps for a device, which tells "this device" in the list. */
+export declare function endpointHash(endpoint: string): Promise<string>;
+interface Environment {
+    userAgent: string;
+    maxTouchPoints: number;
+    standalone: boolean;
+    hasPushManager: boolean;
+    hasNotification: boolean;
+    hasServiceWorker: boolean;
+}
+export declare function detectPushSupport(env: Environment): PushSupport;
+/** The real browser. Reads the globals when asked, never on import. */
+export declare function browserPush(): PushBrowser;
+export {};

package/dist/notifications/push/devices.d.ts

@@ -0,0 +1,15 @@
+import { type ComputedRef } from "vue";
+import type { HttpClient } from "../../client";
+import type { Device } from "../../modules/notification/entities";
+import { type Load } from "../../state";
+/** The devices where the person turned push on, and what can be done with each. */
+export interface Devices {
+    readonly loaded: Load<Device[]>;
+    readonly list: ComputedRef<readonly Device[]>;
+    rename(id: number, label: string): Promise<void>;
+    remove(id: number): Promise<void>;
+    /** Sends a test push to one device; a refusal or a failure rejects. */
+    test(id: number): Promise<void>;
+}
+/** The devices of the signed-in person, from `GET /v1/notifications/devices`. */
+export declare function useDevices(http?: HttpClient): Devices;

package/dist/notifications/push/thisDevice.d.ts

@@ -0,0 +1,28 @@
+import { type Ref } from "vue";
+import type { HttpClient } from "../../client";
+import { type PushBrowser } from "./browser";
+/** What the "this device" panel shows: one state at a time. */
+export type ThisDeviceState = "loading" | "unsupported" | "ios-browser" | "denied" | "off" | "on";
+export interface ThisDevice {
+    readonly state: Readonly<Ref<ThisDeviceState>>;
+    /** `endpoint_hash` of this browser's subscription, to mark its row in the device list; null without one. */
+    readonly hash: Readonly<Ref<string | null>>;
+    readonly busy: Readonly<Ref<boolean>>;
+    /** Reads this browser's state; registers nothing. */
+    inspect(): Promise<void>;
+    /** Asks for the permission and registers this browser. Call it from a tap. Resolves to the state it ended in. */
+    enable(): Promise<ThisDeviceState>;
+    /** Stops push on this browser only: the device is removed from the account and the subscription cancelled. */
+    disable(): Promise<void>;
+}
+/** Cancels this browser's subscription at the account and in the browser; a failing server call never keeps the browser subscribed. */
+export declare function unsubscribeThisBrowser(http: HttpClient, browser?: PushBrowser, signal?: AbortSignal): Promise<void>;
+/**
+ * Re-registers a subscription this browser already holds, for the person who just signed in: go-core makes registering
+ * again idempotent, and it is what refreshes the device's last use, re-enables a disabled one and moves a shared computer's
+ * endpoint to the person signed in now. Once per session, never prompts; a subscription made with a rotated key is replaced,
+ * one the browser's permission no longer backs is dropped.
+ */
+export declare function syncThisBrowser(http: HttpClient, browser: PushBrowser, signal?: AbortSignal): Promise<void>;
+/** This browser's push subscription, for the settings panel. */
+export declare function useThisDevice(http?: HttpClient, browser?: PushBrowser): ThisDevice;

package/dist/notifications/settings/ChannelsSection.vue.d.ts

@@ -0,0 +1,16 @@
+import type { Preferences } from "../../modules/notification/entities";
+import type { Channel } from "./state";
+/**
+ * "Notify me about": a group per category the application declared, with a switch per channel that is available (e-mail, push),
+ * saved as it is switched (one on its way ignores another touch). A setting someone else enforces is a row that reads, with
+ * who decides. In-app is not a switch: the line under the title says it is always on. Without e-mail and push there is a sentence and no switches.
+ */
+type __VLS_Props = {
+    preferences: Preferences;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (category: string, channel: Channel, enabled: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((category: string, channel: Channel, enabled: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/notifications/settings/{QuietHoursPanel.vue.d.ts → QuietHoursSection.vue.d.ts}

@@ -3,7 +3,9 @@ import type { QuietHoursInput } from "../../modules/notification/schemas";
 /**
  * Quiet hours: e-mail made inside them waits until they end (the in-app notification never does). On or off, from and to
  * on the clock of the application's time zone, and one line in words. A window may run over midnight; the same time twice is
- * refused on the field. Saved with the button, like the profile's panels.
+ * refused on the field. Edited in place and saved as it changes, like the channel switches (the switch at once, a time when it is
+ * committed and valid; a change made while a save is on its way follows it): a refusal or a failure puts the last saved values back
+ * and is said under the group. Not a sheet: it is one switch and two times, and what they do to the summary is worth seeing as you edit.
  */
 type __VLS_Props = {
     quietHours: QuietHours;

package/dist/notifications/settings/SettingsBody.vue.d.ts

@@ -0,0 +1,17 @@
+import type { Preferences } from "../../modules/notification/entities";
+import type { Settings } from "./settings";
+import type { Channel } from "./state";
+/**
+ * The sections of the settings page in their order: the built-in ones (channels 0, quiet hours 10, this device 20, devices 30)
+ * and the application's own sections (each under its own title, like the built-in ones). Push is created only here, once the preferences say the server has it.
+ */
+type __VLS_Props = {
+    preferences: Preferences;
+    settings: Settings;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (category: string, channel: Channel, enabled: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((category: string, channel: Channel, enabled: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/notifications/settings/settings.d.ts

@@ -3,14 +3,15 @@ import type { HttpClient } from "../../client";
 import type { Preferences, QuietHours } from "../../modules/notification/entities";
 import type { QuietHoursInput } from "../../modules/notification/schemas";
 import { type Load } from "../../state";
+import { type Channel } from "./state";
 /** One person's notification settings: what the page shows and the two ways to change it. */
 export interface Settings {
     /** The load of the preferences, as `AsyncSection` takes it. */
     readonly loaded: Load<Preferences>;
-    /** The categories whose switch is on its way to the server: each is locked meanwhile, so a change never overtakes another. */
+    /** The categories whose switches are on their way to the server (a category at a time): each is locked meanwhile, so a change never overtakes another. */
     readonly saving: Readonly<Ref<readonly string[]>>;
-    /** Switches the e-mail of one category at once and saves it; a refusal (an enforced setting) or a failure puts the switch back and rejects. */
-    setEmail(category: string, enabled: boolean): Promise<void>;
+    /** Switches one channel (e-mail or push) of one category at once and saves it; a refusal (an enforced setting) or a failure puts the switch back and rejects. */
+    setChannel(category: string, channel: Channel, enabled: boolean): Promise<void>;
     /** Saves the quiet hours; the server's answer is what is shown after. A refusal rejects and changes nothing. */
     saveQuietHours(input: QuietHoursInput): Promise<QuietHours>;
 }

package/dist/notifications/settings/state.d.ts

@@ -1,8 +1,10 @@
 import type { CategorySettings, Preferences, QuietHours } from "../../modules/notification/entities";
 /** The preferences with one category's setting replaced (what the server answered, or what is shown before it does). */
 export declare function withCategory(preferences: Preferences, settings: CategorySettings): Preferences;
-/** One category's e-mail switched here, before the server answers: it is the person's own choice now. */
-export declare function withEmail(preferences: Preferences, category: string, enabled: boolean): Preferences;
+/** The channels a category can be switched on: e-mail and web push. In-app is always on. */
+export type Channel = "email" | "push";
+/** One category's channel switched here, before the server answers: it is the person's own choice now. */
+export declare function withChannel(preferences: Preferences, category: string, channel: Channel, enabled: boolean): Preferences;
 /** Minutes after midnight as the `"HH:mm"` a time field edits. */
 export declare function timeOfMinutes(minutes: number): string;
 /** A time field's `"HH:mm"` as minutes after midnight; null when it is empty. */