@wssto2/vue-core 0.3.0 → 0.4.0

package/dist/{index-B2dbYZR9.js → index-GcLnFF-z.js}

@@ -1,4 +1,4 @@
-import { route as q } from "./client/index.js";
+import { r as q } from "./route-goWMxDUN.js";
 import { d as Le, p as Ce } from "./feature-DdUAfyi4.js";
 import { d as Re } from "./context-Ch1r4fdN.js";
 import { d as Ee } from "./defineRoutes-BGAdiIrt.js";
@@ -6,19 +6,19 @@ import { useI18n as Q } from "vue-i18n";
 import { a as Ne } from "./error-CD7x0Jrz.js";
 import { u as ve } from "./describeError-Ctga6GcS.js";
 import { defineComponent as Y, ref as D, computed as j, watch as le, openBlock as f, createBlock as S, unref as t, withCtx as h, createElementVNode as N, createElementBlock as g, toDisplayString as k, createCommentVNode as O, createVNode as $, Fragment as K, renderList as P, createSlots as be, renderSlot as Se, createTextVNode as M, useTemplateRef as ne } from "vue";
-import { _ as I } from "./Button.vue_vue_type_script_setup_true_lang-CYil8h9z.js";
-import { _ as V } from "./FormGroup.vue_vue_type_script_setup_true_lang-0mfG8TkU.js";
-import { e as U } from "./options-BXkMR63B.js";
-import { _ as Te } from "./AlertDialog.vue_vue_type_script_setup_true_lang-CJsMUIUg.js";
+import { _ as I } from "./Button.vue_vue_type_script_setup_true_lang-CL9Qh5yq.js";
+import { _ as V } from "./FormGroup.vue_vue_type_script_setup_true_lang-DG2zdG_a.js";
+import { e as U } from "./control-7EP4tjYy.js";
+import { _ as Te } from "./AlertDialog.vue_vue_type_script_setup_true_lang-whA4WLdl.js";
 import { t as ee } from "./toast-D9Z5To38.js";
-import { _ as ce } from "./AccessGate.vue_vue_type_script_setup_true_lang-DKX3PH2n.js";
-import { _ as Oe } from "./AsyncSection.vue_vue_type_script_setup_true_lang-CCtthMRd.js";
+import { _ as ce } from "./AccessGate.vue_vue_type_script_setup_true_lang-DcbZBINh.js";
+import { _ as Oe } from "./AsyncSection.vue_vue_type_script_setup_true_lang-Blj6KgCr.js";
 import { u as Ae } from "./useLoad-CYRVx6HW.js";
-import { _ as De, a as Ke } from "./SelectField.vue_vue_type_script_setup_true_lang-BiGaEKBQ.js";
-import { _ as Be } from "./SegmentedField.vue_vue_type_script_setup_true_lang-BZ9UdgA1.js";
-import { u as Pe, _ as Ue } from "./useCommand-BgRwnYlV.js";
-import { u as Fe } from "./platform-hunMqFdB.js";
-import { _ as Ge } from "./IconTile.vue_vue_type_script_setup_true_lang-D7QgnUyN.js";
+import { _ as De, a as Ke } from "./SelectField.vue_vue_type_script_setup_true_lang-7O1BAx04.js";
+import { _ as Be } from "./SegmentedField.vue_vue_type_script_setup_true_lang-BMqWlpsL.js";
+import { u as Pe, _ as Ue } from "./useCommand-BkONMn3X.js";
+import { u as Fe } from "./platform-q3cjODLx.js";
+import { _ as Ge } from "./IconTile.vue_vue_type_script_setup_true_lang-BpIjgu5E.js";
 import { u as Me } from "./mediaQuery-CygcXmFW.js";
 import { _ as Ve } from "./Badge.vue_vue_type_script_setup_true_lang-DJyZc0C7.js";
 const C = {
@@ -43,12 +43,12 @@ const C = {
   viewAccess: "iam.user:view",
   manageBindings: "iam.user:manage"
 }, re = Ee({
-  roles: { name: "access.roles", path: "/iam/roles", component: () => import("./RolesPage-BniZv0nB.js"), meta: { access: F.viewRoles, titleKey: "core.access.title" } },
-  newRole: { name: "access.roles.new", path: "/iam/roles/new", component: () => import("./NewRolePage-Dla4YnMs.js"), meta: { access: F.manageRoles, titleKey: "core.access.new_title" } },
+  roles: { name: "access.roles", path: "/iam/roles", component: () => import("./RolesPage-DzGGCMnm.js"), meta: { access: F.viewRoles, titleKey: "core.access.title" } },
+  newRole: { name: "access.roles.new", path: "/iam/roles/new", component: () => import("./NewRolePage-DTOWIxxC.js"), meta: { access: F.manageRoles, titleKey: "core.access.new_title" } },
   role: {
     name: "access.role",
     path: "/iam/roles/:ref",
-    component: () => import("./RolePage-bZzv_E4l.js"),
+    component: () => import("./RolePage-DZk7BZOc.js"),
     // A role's ref (its key, or the id of a custom one) swaps in place when a link leads to another role.
     meta: { access: F.viewRoles, titleKey: "core.access.title", remountOnParam: "ref" }
   }

package/dist/index.d.ts

@@ -1,2 +1,2 @@
 /** The version of @wssto2/vue-core (kept equal to package.json by index.test.ts). */
-export declare const version = "0.3.0";
+export declare const version = "0.4.0";

package/dist/index.js

@@ -1,4 +1,4 @@
-const o = "0.3.0";
+const o = "0.4.0";
 export {
   o as version
 };

package/dist/modal/Sheet.vue.d.ts

@@ -26,6 +26,8 @@ type __VLS_Slots = {
     header?: (scope: {
         titleId: string;
     }) => unknown;
+    /** Buttons in the default header, just before the close button (an inbox's settings gear). */
+    actions?: () => unknown;
 };
 declare function present(): void;
 declare function dismiss(): void;

package/dist/modal/index.js

@@ -1,10 +1,10 @@
-import { _ as G } from "../DiscardChangesModal.vue_vue_type_script_setup_true_lang-Cb3xJI1x.js";
-import { _ as y } from "../Modal.vue_vue_type_script_setup_true_lang-D7SwVPpL.js";
-import { m as O } from "../Modal.vue_vue_type_script_setup_true_lang-D7SwVPpL.js";
-import { _ as T } from "../Sheet.vue_vue_type_script_setup_true_lang-bHYzx7-J.js";
+import { _ as G } from "../DiscardChangesModal.vue_vue_type_script_setup_true_lang-D1arePCZ.js";
+import { _ as y } from "../Modal.vue_vue_type_script_setup_true_lang-DpBb8ans.js";
+import { m as O } from "../Modal.vue_vue_type_script_setup_true_lang-DpBb8ans.js";
+import { _ as T } from "../Sheet.vue_vue_type_script_setup_true_lang-DgOFV4fa.js";
 import { defineComponent as b, ref as k, computed as v, openBlock as t, createBlock as w, unref as i, withCtx as S, createElementVNode as r, createElementBlock as o, Fragment as c, renderList as u, toDisplayString as l, createCommentVNode as C } from "vue";
 import { useI18n as B } from "vue-i18n";
-import { a as K, u as M } from "../Button.vue_vue_type_script_setup_true_lang-CYil8h9z.js";
+import { a as K, u as M } from "../Button.vue_vue_type_script_setup_true_lang-CL9Qh5yq.js";
 const $ = {
   class: "flex flex-col gap-5",
   "data-test": "shortcut-help"

package/dist/modules/events/entities.d.ts

@@ -0,0 +1,16 @@
+export type ConsumerNames = {
+    consumers: string[];
+};
+export type DeadLetterRow = {
+    event_id: number;
+    consumer: string;
+    event_name: string;
+    event_created_at: string | null;
+    attempts: number;
+    last_error: string;
+    dead_at: string;
+    retryable: boolean;
+};
+export type Retried = {
+    retried: number;
+};

package/dist/modules/events/routes.d.ts

@@ -0,0 +1,17 @@
+import { type ListResult } from "../../client";
+import type { ConsumerNames, DeadLetterRow, Retried } from "./entities";
+export declare const eventsRoutes: {
+    readonly deadLettersList: import("../../client").ApiRoute<{
+        consumer?: string | undefined;
+        page?: number | undefined;
+        per_page?: number | undefined;
+    }, ListResult<DeadLetterRow>>;
+    readonly deadLettersRetry: import("../../client").ApiRoute<{
+        event: number;
+        consumer: string;
+    }, Retried>;
+    readonly deadLettersRetryAll: import("../../client").ApiRoute<{
+        consumer: string;
+    }, Retried>;
+    readonly consumers: import("../../client").ApiRoute<void, ConsumerNames>;
+};

package/dist/modules/events/schemas.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const DeadLettersInputSchema: z.ZodObject<{
+    consumer: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodNumber>;
+    per_page: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type DeadLettersInput = z.infer<typeof DeadLettersInputSchema>;
+export declare const RetryAllInputSchema: z.ZodObject<{
+    consumer: z.ZodString;
+}, z.core.$strip>;
+export type RetryAllInput = z.infer<typeof RetryAllInputSchema>;
+export declare const RetryInputSchema: z.ZodObject<{
+    event: z.ZodNumber;
+    consumer: z.ZodString;
+}, z.core.$strip>;
+export type RetryInput = z.infer<typeof RetryInputSchema>;

package/dist/modules/notification/entities.d.ts

@@ -0,0 +1,46 @@
+export type CategorySettings = {
+    category: string;
+    email: Setting;
+};
+export type Item = {
+    id: number;
+    category: string;
+    title: string;
+    body: string;
+    link: string;
+    data: Record<string, string>;
+    read_at: string | null;
+    created_at: string;
+};
+export type Page = {
+    items: Item[];
+    has_more: boolean;
+};
+export type Preferences = {
+    email_available: boolean;
+    categories: CategorySettings[];
+    quiet_hours: QuietHours;
+    time_zone: string;
+};
+export type QuietHours = {
+    enabled: boolean;
+    start: number;
+    end: number;
+};
+export type Setting = {
+    enabled: boolean;
+    source: Source;
+};
+export type Source = "enforced" | "person" | "default";
+export type StreamEvent = {
+    type: StreamKind;
+    notification?: Item | null;
+    read_ids?: number[];
+    all_read?: boolean;
+    read_up_to_id?: number;
+    unread_count: number;
+};
+export type StreamKind = "created" | "read" | "unread";
+export type UnreadCount = {
+    unread_count: number;
+};

package/dist/modules/notification/routes.d.ts

@@ -0,0 +1,26 @@
+import type { CategorySettings, Page, Preferences, QuietHours, UnreadCount } from "./entities";
+export declare const notificationRoutes: {
+    readonly list: import("../../client").ApiRoute<{
+        before_id?: number | undefined;
+        limit?: number | undefined;
+    }, Page>;
+    readonly unread: import("../../client").ApiRoute<void, UnreadCount>;
+    readonly read: import("../../client").ApiRoute<{
+        id: number;
+    }, UnreadCount>;
+    readonly readAll: import("../../client").ApiRoute<{
+        up_to_id: number;
+    }, UnreadCount>;
+    readonly stream: import("../../client").RawRoute;
+    readonly test: import("../../client").ApiRoute<void, void>;
+    readonly preferences: import("../../client").ApiRoute<void, Preferences>;
+    readonly preferencesSetEmail: import("../../client").ApiRoute<{
+        category: string;
+        email: boolean | null;
+    }, CategorySettings>;
+    readonly quietHours: import("../../client").ApiRoute<{
+        enabled: boolean;
+        start: number;
+        end: number;
+    }, QuietHours>;
+};

package/dist/modules/notification/schemas.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const ListQuerySchema: z.ZodObject<{
+    before_id: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ListQuery = z.infer<typeof ListQuerySchema>;
+export declare const MarkAllInputSchema: z.ZodObject<{
+    up_to_id: z.ZodNumber;
+}, z.core.$strip>;
+export type MarkAllInput = z.infer<typeof MarkAllInputSchema>;
+export declare const QuietHoursInputSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+}, z.core.$strip>;
+export type QuietHoursInput = z.infer<typeof QuietHoursInputSchema>;
+export declare const ReadInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, z.core.$strip>;
+export type ReadInput = z.infer<typeof ReadInputSchema>;
+export declare const SetEmailInputSchema: z.ZodObject<{
+    category: z.ZodString;
+    email: z.ZodNullable<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SetEmailInput = z.infer<typeof SetEmailInputSchema>;

package/dist/{navigation-BPWa63ge.js → navigation-Cm3iChlR.js}

@@ -1,6 +1,6 @@
 import { computed as k } from "vue";
 import { d as y } from "./context-Ch1r4fdN.js";
-import { h as N } from "./platform-hunMqFdB.js";
+import { h as N } from "./platform-q3cjODLx.js";
 function F(l, a = {}) {
   const i = /* @__PURE__ */ new Map(), o = [];
   for (const e of l) {

package/dist/{neighbors-D0WRBxXI.js → neighbors-DpaIMQAL.js}

@@ -1,7 +1,7 @@
 import { ref as P, shallowRef as z, watch as X, getCurrentScope as j, onScopeDispose as B } from "vue";
 import { useRoute as F } from "vue-router";
 import { i as M } from "./error-CD7x0Jrz.js";
-import { L as I, o as J, d as Q, e as N, q as U } from "./http-DGGSKWvU.js";
+import { L as I, o as J, d as Q, e as N, q as U } from "./http-CNcDHSOj.js";
 const V = 8;
 function te(s, r) {
   const v = F(), R = r.from ?? (() => typeof v.query[I] == "string" ? v.query[I] : null), D = r.stateKey ?? "query", y = P(null), p = P(0), h = z(null), d = z(null), b = P(!1), S = z(null), n = /* @__PURE__ */ new Map();

package/dist/notifications/InboxPanel.vue.d.ts

@@ -0,0 +1,16 @@
+import type { Inbox } from "./inbox";
+/**
+ * The inbox: what the popover (wide screens) and the sheet (phones) show. Newest first; a tap marks the
+ * notification read and opens its link; "Mark all as read" marks what has been seen; older ones
+ * come with "Show older". Loading, failure and emptiness are the library's own states.
+ */
+type __VLS_Props = {
+    inbox: Inbox;
+    appearance: "popover" | "sheet";
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/notifications/MarkAllRead.vue.d.ts

@@ -0,0 +1,7 @@
+import type { Inbox } from "./inbox";
+/** "Mark all as read": what has been seen, up to the newest id the inbox shows. Off while nothing is unread. */
+type __VLS_Props = {
+    inbox: Inbox;
+};
+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/NotificationBell.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/SettingsLink.vue.d.ts

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

package/dist/notifications/context.d.ts

@@ -0,0 +1,20 @@
+import type { ShallowRef } from "vue";
+import type { IconName } from "../icon";
+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. */
+export interface NotificationCategoryLook {
+    /** Default: the bell. */
+    icon?: IconName;
+    /** One of the category hues; default neutral. */
+    hue?: Hue;
+}
+/** 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). */
+    readonly inbox: ShallowRef<Inbox | null>;
+    readonly categories: Readonly<Record<string, NotificationCategoryLook>>;
+    /** Whether the settings page is installed: the inbox shows its gear. */
+    readonly settings: boolean;
+}
+export declare const notificationsContextKey: import("vue").InjectionKey<NotificationsContext>, useNotificationsContext: () => NotificationsContext;

package/dist/notifications/deadletters/DeadLetters.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/deadletters/access.d.ts

@@ -0,0 +1,3 @@
+import type { Permission } from "../../platform";
+export declare const VIEW_DEAD_LETTERS: Permission;
+export declare const RETRY_DEAD_LETTERS: Permission;

package/dist/notifications/deadletters/list.d.ts

@@ -0,0 +1,3 @@
+import type { HttpClient } from "../../client";
+/** The dead letters of every consumer of the application's event queue, as go-core's `GET /v1/events/dead-letters` pages them (newest first; only the consumer narrows it). */
+export declare function deadLetterList(http: HttpClient): import("../../collection").CollectionDefinition<import("..").DeadLetterRow, never, "consumer", never>;

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

@@ -0,0 +1,13 @@
+import type { RouteRecordRaw } from "vue-router";
+/**
+ * The route of the dead-letters page (`/events/dead-letters`, name `events.deadletters`), for whoever holds
+ * `events.deadletter:view`: a typed target for links and the record `notificationsFeature` installs.
+ */
+export interface DeadLettersRoutes {
+    /** The records `notificationsFeature` installs. */
+    readonly records: readonly RouteRecordRaw[];
+    readonly index: {
+        readonly name: "events.deadletters";
+    };
+}
+export declare const deadLettersRoutes: DeadLettersRoutes;

package/dist/notifications/feature.d.ts

@@ -0,0 +1,31 @@
+import { type Feature } from "../app";
+import type { Destination } from "../router";
+import { type NotificationCategoryLook } 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>>;
+    /**
+     * The dead-letters page (`/events/dead-letters`, route `events.deadletters`) for whoever holds `events.deadletter:view`:
+     * the events a consumer of the queue gave up on, with retry behind `events.deadletter:retry`. `destination` is the node of
+     * the server's menu that opens it; without one the application binds the page itself. `false` leaves the page out.
+     * Default: the page, with no menu binding.
+     */
+    deadLetters?: {
+        destination?: Destination;
+    } | false;
+    /**
+     * The person's own notification settings (`/profile/notifications`, route `notifications.settings`): the categories they get by e-mail
+     * and their quiet hours, reached from the account menu ("Notification settings") and from a gear in the inbox. Needs no permission, only a
+     * session. The names of the categories are the application's texts `notifications.categories.<code>.label` (and `.description`), the code
+     * 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;
+}
+/**
+ * The in-app notifications of go-core's notification module, one feature to install: the bell with the
+ * unread count in the shell's `headerActions`, the inbox it opens (a popover on wide screens, a bottom sheet on
+ * phones), and the live stream behind both, which follows the session. Needs a shell with a `headerActions` place.
+ *
+ *   createApplication({ platform, shell: backofficeShell(), features: [identityFeature(), notificationsFeature({ categories: { "tickets.assigned": { icon: "user3Line", hue: "blue" } }, deadLetters: { destination: "events.deadletters" } })] })
+ */
+export declare function notificationsFeature(options?: NotificationsFeatureOptions): Feature;

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;