@wssto2/vue-core 0.2.0 → 0.4.0

package/dist/notifications/inbox.d.ts

@@ -0,0 +1,62 @@
+import { type Ref } from "vue";
+import { type HttpClient, type Transport } from "../client";
+import type { Item } from "../modules/notification/entities";
+/** The first page of the inbox: not asked yet, on its way, here, or failed (`error` is what the request rejected with). */
+export type InboxList = {
+    readonly status: "idle";
+} | {
+    readonly status: "loading";
+} | {
+    readonly status: "loaded";
+} | {
+    readonly status: "failed";
+    readonly error: unknown;
+};
+export interface InboxOptions {
+    http: HttpClient;
+    /** The stream's whole address (the API base and `/v1/notifications/stream`). */
+    streamUrl: string;
+    /** Ends everything the inbox does: the stream, its timers and listeners, and the answers still on their way. */
+    signal: AbortSignal;
+    /** Reads the stream; default `fetch`. */
+    transport?: Transport;
+    /** Notifications per request, at most 50 (go-core's limit). Default 20. */
+    pageSize?: number;
+    /** The wait before reconnecting grows from `min` to `max`, in milliseconds. Default 1 s to 30 s. */
+    backoff?: {
+        readonly min: number;
+        readonly max: number;
+    };
+    /** How long a silent connection lives; go-core beats every 25 s, so the default is 50 s. */
+    idleTimeout?: number;
+    /** The moment to stamp a reading made here with. Default now. */
+    now?: () => Date;
+}
+/**
+ * One signed-in person's inbox: what the bell and the list show. It keeps the live stream open for as
+ * long as `signal` lives, and nothing of it outlives the session.
+ */
+export interface Inbox {
+    /** Newest first: what was loaded plus what the stream brought. */
+    readonly items: Readonly<Ref<readonly Item[]>>;
+    /** The server's count, kept current by every answer and every stream event. */
+    readonly unreadCount: Readonly<Ref<number>>;
+    readonly hasMore: Readonly<Ref<boolean>>;
+    readonly list: Readonly<Ref<InboxList>>;
+    /** Whether "Load more" is running or failed. */
+    readonly more: Readonly<Ref<"idle" | "loading" | "failed">>;
+    /** Reads the first page again (opening the inbox). A reload while one is running makes the earlier answer irrelevant. */
+    load(): Promise<void>;
+    loadMore(): Promise<void>;
+    /** Marks one notification read here at once and, through the server, on every device. A reading that fails is taken back. */
+    markRead(item: Pick<Item, "id" | "read_at">): Promise<void>;
+    /** Marks read what the person has seen: everything up to the newest id this inbox shows. A notification that arrives afterwards stays unread. */
+    markAllRead(): Promise<void>;
+}
+/**
+ * Starts the inbox of a session. Staying right when the connection drops: the stream opens with the
+ * count; a reconnect waits 1 s, 2 s, … up to 30 s, and refetches the count first (through the platform's
+ * client, which also renews an expired session); a connection silent for two heartbeats is dropped and
+ * redone; coming back to the foreground or online refetches the count and reconnects at once.
+ */
+export declare function createInbox(options: InboxOptions): Inbox;

package/dist/notifications/index.d.ts

@@ -0,0 +1,13 @@
+export type { Item as Notification, Page as InboxPage, StreamEvent, StreamKind, UnreadCount } from "../modules/notification/entities";
+export type * as Inputs from "../modules/notification/schemas";
+export { notificationRoutes } from "../modules/notification/routes";
+export type { DeadLetterRow, Retried } from "../modules/events/entities";
+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 { notificationSettingsRoutes } from "./settings/routes";
+export type { NotificationSettingsRoutes } from "./settings/routes";
+export { deadLettersRoutes } from "./deadletters/routes";
+export type { DeadLettersRoutes } from "./deadletters/routes";

package/dist/notifications/index.js

@@ -0,0 +1,8 @@
+import { d as s, e as o, n as a, a as i, b as n } from "../index-BsJ92eub.js";
+export {
+  s as deadLettersRoutes,
+  o as eventsRoutes,
+  a as notificationRoutes,
+  i as notificationSettingsRoutes,
+  n as notificationsFeature
+};

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

@@ -0,0 +1,14 @@
+import type { Preferences } from "../../modules/notification/entities";
+/**
+ * "E-mail me about": one switch per category the application declared, 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; without e-mail there is a sentence and no switches. In-app is not a switch: it is always on.
+ */
+type __VLS_Props = {
+    preferences: Preferences;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (category: string, enabled: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((category: string, enabled: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,14 @@
+import type { QuietHours } from "../../modules/notification/entities";
+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.
+ */
+type __VLS_Props = {
+    quietHours: QuietHours;
+    timeZone: string;
+    submit: (input: QuietHoursInput) => Promise<QuietHours>;
+};
+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/settings/SettingsMenuItem.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,9 @@
+/**
+ * How a category is named on the settings page: the application's own texts `notifications.categories.<code>.label`
+ * (and an optional `.description`), the code split at its dots (`tickets.assigned` is `notifications.categories.tickets.assigned.label`).
+ * A category the application gave no text is shown by its code, never by a missing key.
+ */
+export declare function useCategoryText(): (code: string) => {
+    label: string;
+    description?: string;
+};

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

@@ -0,0 +1,13 @@
+import type { RouteRecordRaw } from "vue-router";
+/**
+ * The route of the person's own notification settings (`/profile/notifications`, name `notifications.settings`): any signed-in person
+ * may open it, so it has no `access`. A typed target for links and the record `notificationsFeature` installs.
+ */
+export interface NotificationSettingsRoutes {
+    /** The records `notificationsFeature` installs. */
+    readonly records: readonly RouteRecordRaw[];
+    readonly index: {
+        readonly name: "notifications.settings";
+    };
+}
+export declare const notificationSettingsRoutes: NotificationSettingsRoutes;

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

@@ -0,0 +1,18 @@
+import { type Ref } from "vue";
+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";
+/** 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. */
+    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>;
+    /** Saves the quiet hours; the server's answer is what is shown after. A refusal rejects and changes nothing. */
+    saveQuietHours(input: QuietHoursInput): Promise<QuietHours>;
+}
+/** The settings of the signed-in person, read from `GET /v1/notifications/preferences` through the platform's client. */
+export declare function useSettings(http?: HttpClient): Settings;

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

@@ -0,0 +1,16 @@
+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;
+/** 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. */
+export declare function minutesOfTime(time: string | null): number | null;
+/** What the quiet-hours form edits: the server's minutes as times of day. */
+export interface QuietDraft {
+    enabled: boolean;
+    start: string | null;
+    end: string | null;
+}
+export declare const draftOf: (quiet: QuietHours) => QuietDraft;

package/dist/notifications/state.d.ts

@@ -0,0 +1,27 @@
+import type { Item, StreamEvent } from "../modules/notification/entities";
+/** What the inbox keeps: the notifications this app has loaded or been sent, newest first, and the server's unread count. */
+export interface InboxContents {
+    readonly items: readonly Item[];
+    readonly unreadCount: number;
+}
+/** The newest id of a list: "Mark all as read" stops there, so a notification nobody has seen stays unread. 0 for none. */
+export declare function newestId(items: readonly Item[]): number;
+/** One notification marked read here (before the server answers). */
+export declare function markedRead(items: readonly Item[], id: number, readAt: string): readonly Item[];
+/** Everything up to `upToId` marked read here. */
+export declare function markedReadUpTo(items: readonly Item[], upToId: number, readAt: string): readonly Item[];
+/**
+ * The first page of a (re)load, with anything newer the stream brought while the request was on its way: the page was
+ * read before it, so it would otherwise vanish until the next load. Newest first, each id once.
+ */
+export declare function withNewer(page: readonly Item[], current: readonly Item[]): readonly Item[];
+/** A further (older) page appended, ids already shown left out. */
+export declare function withOlder(current: readonly Item[], page: readonly Item[]): readonly Item[];
+/**
+ * One stream event applied. Every event carries the server's unread count and it always wins over counting here
+ * (NOTIF-READ-001); a reading on another device marks the same notifications read here. A "read all" names the newest
+ * id that device had seen, and only notifications up to it are read.
+ */
+export declare function applyStreamEvent(state: InboxContents, event: StreamEvent, readAt: string): InboxContents;
+/** The unread count as a badge shows it: "99+" past 99. */
+export declare function unreadBadge(count: number): string;

package/dist/notifications/stream.d.ts

@@ -0,0 +1,21 @@
+import type { Transport } from "../client";
+import type { StreamEvent } from "../modules/notification/entities";
+/** Why a stream ended: the caller reconnects, except after `aborted`. */
+export type StreamEnd = "closed" | "unauthorized" | "failed" | "aborted" | "stalled";
+export interface ReadStreamOptions {
+    url: string;
+    transport: Transport;
+    signal: AbortSignal;
+    onEvent(event: StreamEvent): void;
+    /** A connection that sends nothing, not even a heartbeat, for this long is dropped. go-core beats every 25 s. */
+    idleTimeout: number;
+}
+/** One server-sent message block as an event; a comment (`: ping`), a block without data and an unreadable one give null. */
+export declare function parseStreamMessage(message: string): StreamEvent | null;
+/**
+ * Opens the notification stream and reads it until it ends. `EventSource` cannot send headers and
+ * cannot tell a dead connection from a quiet one, so the byte stream is read with `fetch` through the
+ * platform's transport: the session cookie goes with it, the heartbeat resets a watchdog, and aborting
+ * the signal ends it at once.
+ */
+export declare function readStream({ url, transport, signal, onEvent, idleTimeout }: ReadStreamOptions): Promise<StreamEnd>;

package/dist/options-Ba_0uLWN.js

@@ -0,0 +1,18 @@
+function l(t) {
+  const o = /* @__PURE__ */ new Map();
+  for (const e of t) {
+    const n = e.group ?? null, r = o.get(n) ?? [];
+    r.push(e), o.set(n, r);
+  }
+  return [...o.entries()].sort(([e], [n]) => e === null ? -1 : n === null ? 1 : 0).map(([e, n]) => ({ title: e, options: n }));
+}
+function c(t, o) {
+  const e = s(o.trim());
+  return e === "" ? t : t.filter((n) => s(n.label).includes(e) || n.description !== void 0 && s(n.description).includes(e));
+}
+const s = (t) => t.normalize("NFD").replace(/[̀-ͯ]/g, "").toLocaleLowerCase();
+export {
+  s as f,
+  l as g,
+  c as m
+};

package/dist/overlay/AlertDialog.vue.d.ts

@@ -2,10 +2,10 @@ import { type IconName } from "../icon";
 declare const _default: <Subject = undefined>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
         readonly onCancel?: (() => any) | undefined;
-        readonly onFailed?: ((error: unknown) => any) | undefined;
         readonly onDismissed?: (() => any) | undefined;
+        readonly onFailed?: ((error: unknown) => any) | undefined;
         readonly onConfirm?: ((subject: Subject) => any) | undefined;
-    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onCancel" | "onDismissed" | "onConfirm" | "onFailed"> & {
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onCancel" | "onDismissed" | "onFailed" | "onConfirm"> & {
         title: string;
         message?: string;
         /** Says exactly what happens; by default "Confirm". */
@@ -25,7 +25,7 @@ declare const _default: <Subject = undefined>(__VLS_props: NonNullable<Awaited<t
     slots: {
         default?: () => unknown;
     };
-    emit: ((evt: "cancel") => void) & ((evt: "failed", error: unknown) => void) & ((evt: "dismissed") => void) & ((evt: "confirm", subject: Subject) => void);
+    emit: ((evt: "cancel") => void) & ((evt: "dismissed") => void) & ((evt: "failed", error: unknown) => void) & ((evt: "confirm", subject: Subject) => void);
 }>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };

package/dist/overlay/Popover.vue.d.ts

@@ -61,8 +61,8 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
     onDismissed?: (() => any) | undefined;
 }>, {
     width: "sm" | "md" | "lg" | "auto";
-    block: boolean;
     placement: Placement;
+    block: boolean;
     arrow: boolean;
     matchTriggerWidth: boolean;
     autofocus: boolean;

package/dist/overlay/closeOverlays.d.ts

@@ -0,0 +1,7 @@
+/** Fired on `document` to close every open popover and menu; see `closeOverlays`. */
+export declare const CLOSE_OVERLAYS_EVENT = "vue-core:close-overlays";
+/**
+ * Closes every open popover and menu: for something that takes the screen over (the prompt of an expired session),
+ * so a menu does not hang open beside it. Dialogs are not touched: they have their own stack.
+ */
+export declare function closeOverlays(): void;

package/dist/overlay/index.js

@@ -1,24 +1,25 @@
-import { _ as e } from "../AlertDialog.vue_vue_type_script_setup_true_lang-e4hzkzg3.js";
-import { _ as t } from "../Menu.vue_vue_type_script_setup_true_lang-CrMj6KPD.js";
-import { _ as p, t as _ } from "../toast-DvrHQ6Ag.js";
-import { _ as f } from "../Toaster.vue_vue_type_script_setup_true_lang-55boRLAj.js";
-import { _ as I } from "../Tooltip.vue_vue_type_script_setup_true_lang-OOD_XNWx.js";
-import { I as u, u as i } from "../dialogStack-DZZg55w0.js";
-import { I as C, u as P } from "../useDialog-CXR3hN0G.js";
-import { C as n, u as D } from "../mediaQuery-CygcXmFW.js";
-import { _ as g } from "../PhotoViewer.vue_vue_type_script_setup_true_lang-ElDizaW2.js";
+import { _ as e } from "../AlertDialog.vue_vue_type_script_setup_true_lang-whA4WLdl.js";
+import { _ as a } from "../Menu.vue_vue_type_script_setup_true_lang-DTbAcDzL.js";
+import { _ as p } from "../Popover.vue_vue_type_script_setup_true_lang-Dx-tDhNE.js";
+import { _ as m } from "../Toaster.vue_vue_type_script_setup_true_lang-55boRLAj.js";
+import { _ as x } from "../Tooltip.vue_vue_type_script_setup_true_lang-OOD_XNWx.js";
+import { t as T } from "../toast-D9Z5To38.js";
+import { I as i, u as A } from "../dialogStack-DZZg55w0.js";
+import { I as P, u as l } from "../useDialog-CXR3hN0G.js";
+import { C as D, u as R } from "../mediaQuery-CygcXmFW.js";
+import { _ as E } from "../PhotoViewer.vue_vue_type_script_setup_true_lang-QPCW3Xi6.js";
 export {
   e as AlertDialog,
-  n as COMPACT_MEDIA_QUERY,
-  u as INERT_SKIP_ATTR,
-  C as INITIAL_FOCUS_SKIP_ATTR,
-  t as Menu,
-  g as PhotoViewer,
+  D as COMPACT_MEDIA_QUERY,
+  i as INERT_SKIP_ATTR,
+  P as INITIAL_FOCUS_SKIP_ATTR,
+  a as Menu,
+  E as PhotoViewer,
   p as Popover,
-  f as Toaster,
-  I as Tooltip,
-  _ as toast,
-  D as useCompactPresentation,
-  P as useDialog,
-  i as useOpenDialogCount
+  m as Toaster,
+  x as Tooltip,
+  T as toast,
+  R as useCompactPresentation,
+  l as useDialog,
+  A as useOpenDialogCount
 };

package/dist/page/AdaptivePageShell.vue.d.ts

@@ -58,11 +58,11 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}
     path: readonly PagePathItem[] | null;
     width: "full" | "content" | "readable";
     icon: IconName;
-    description: string;
     actions: readonly PageAction[];
-    count: number | null;
     back: PageBack | null;
     documentTitle: string | null;
+    description: string;
+    count: number | null;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;

package/dist/page/ResourceHeader.vue.d.ts

@@ -27,11 +27,11 @@ type __VLS_Slots = {
 };
 declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     icon: IconName;
+    actions: readonly PageAction[];
+    leading: PageAction | null;
     status: string | null;
     description: string;
-    actions: readonly PageAction[];
     count: number | null;
-    leading: PageAction | null;
     inlineActions: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;