@remit/web-client 0.0.326 → 0.0.328

package/dist/src/components/mail/MailboxPane.js

@@ -23,7 +23,7 @@ import { useInfiniteQuery } from "@tanstack/react-query";
 import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from "react";
 import { useArchiveMailbox, useDraftsMailbox, useJunkMailbox, useTrashByAccount, useTrashMailbox, } from "../../hooks/useArchiveMailbox";
 import { useCurrentMailboxMessageCount, useCurrentMailboxName, useCurrentMailboxUnseenCount, } from "../../hooks/useCurrentMailboxName";
-import { dropDeletedThreads, useDeleteMessages, } from "../../hooks/useDeleteMessages";
+import { useDeleteMessages } from "../../hooks/useDeleteMessages";
 import { useEmptyTrash } from "../../hooks/useEmptyTrash";
 import { useIntelligenceData } from "../../hooks/useIntelligenceData";
 import { useIntelligenceDrawer } from "../../hooks/useIntelligenceDrawer";
@@ -191,14 +191,7 @@ function MailboxPaneProvider({ mailboxId, thread, children, }) {
     });
     const { accountId: mailboxAccountId, isLoading: mailboxAccountLoading } = useMailboxAccount(mailboxId);
     const mailboxName = useCurrentMailboxName({ accounts });
-    // The server answered the active predicate, so these rows are the list: the
-    // dedupe spans pages and the deleted drop repeats the server's own
-    // `excludeDeleted`, and neither result changes when another page loads.
-    // Residual tokens are the exception — the request could not carry them, so
-    // they are applied here over what came back. That thins a page rather than
-    // answering over the whole mailbox, which is why the empty state stops
-    // claiming the folder was read and the escalation predicate is withheld.
-    const threads = applyResidualTokens(dropDeletedThreads(dedupeThreadMessages(threadsData?.pages.flatMap((page) => page.items ?? []) ?? [])), residualTokens, mailboxAccountId);
+    const threads = applyResidualTokens(dedupeThreadMessages(threadsData?.pages.flatMap((page) => page.items ?? []) ?? []), residualTokens, mailboxAccountId);
     const onSelectFilterCategory = useCallback((id) => {
         setFilterCategory(id);
     }, []);

package/dist/src/components/settings/AccountFormPanel.js

@@ -35,7 +35,7 @@ export const deriveUseDifferentSmtpCreds = (account) => {
     return smtpUsername !== account.username;
 };
 const accountFormSchema = z.object({
-    email: z.string().email().min(1, "Email is required"),
+    email: z.email(),
     displayName: z.string().optional(),
     username: z.string().optional(),
     password: z.string().optional(),

package/dist/src/hooks/useDeleteFolder.js

@@ -30,8 +30,6 @@ const collectMovableIds = async (mailboxId, alreadyMoved, limit, signal) => {
             throwOnError: true,
         });
         for (const item of data.items) {
-            if (item.isDeleted)
-                continue;
             if (alreadyMoved.has(item.messageId))
                 continue;
             if (ids.includes(item.messageId))
@@ -63,11 +61,7 @@ const liveMessageCount = async (mailboxId, signal) => {
             query: { order: "desc", continuationToken },
             throwOnError: true,
         });
-        for (const item of data.items) {
-            if (item.isDeleted)
-                continue;
-            count += 1;
-        }
+        count += data.items.length;
         if (!data.continuationToken)
             break;
         continuationToken = data.continuationToken;

package/dist/src/hooks/useDeleteMessages.d.ts

@@ -25,15 +25,6 @@ interface UseDeleteMessagesOptions {
  * the set are removed.
  */
 export declare const removeMessagesFromItems: (items: RemitImapThreadMessageResponse[], messageIds: Set<string>) => RemitImapThreadMessageResponse[];
-/**
- * Pure helper: drop soft-deleted rows from a flattened thread list.
- *
- * Belt-and-braces guard against #212. The backend already excludes
- * `isDeleted: true` rows from the inbox listing, but if a regression slips
- * back in (or an eventual-consistency window briefly returns a soft-deleted
- * row) the UI must not show it.
- */
-export declare const dropDeletedThreads: (items: RemitImapThreadMessageResponse[]) => RemitImapThreadMessageResponse[];
 export declare const useDeleteMessages: ({ mailboxId, threadId, accountId, messages, onAfterOptimisticRemove, }: UseDeleteMessagesOptions) => {
     deleteMessages: (messageIds: string[]) => void;
     isPending: boolean;

package/dist/src/hooks/useDeleteMessages.js

@@ -18,15 +18,6 @@ import { resolveMailboxesForMessages } from "./useMarkAsRead";
  * the set are removed.
  */
 export const removeMessagesFromItems = (items, messageIds) => items.filter((item) => !messageIds.has(item.messageId));
-/**
- * Pure helper: drop soft-deleted rows from a flattened thread list.
- *
- * Belt-and-braces guard against #212. The backend already excludes
- * `isDeleted: true` rows from the inbox listing, but if a regression slips
- * back in (or an eventual-consistency window briefly returns a soft-deleted
- * row) the UI must not show it.
- */
-export const dropDeletedThreads = (items) => items.filter((item) => item.isDeleted !== true);
 export const useDeleteMessages = ({ mailboxId, threadId, accountId, messages, onAfterOptimisticRemove, }) => {
     const queryClient = useQueryClient();
     const { pushError } = useErrorBanners();

package/dist/src/lib/calendar-route.d.ts

@@ -84,10 +84,6 @@ export declare function readCalendarIds(value: unknown): string[];
  * rather than a fact about the view, so it belongs to no tier of the address.
  */
 export declare const calendarSearchSchema: z.ZodObject<{
-    calendarId: z.ZodEffects<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], unknown>, string[] | undefined, unknown>;
-}, "strip", z.ZodTypeAny, {
-    calendarId?: string[] | undefined;
-}, {
-    calendarId?: unknown;
-}>;
+    calendarId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnknown, z.ZodTransform<string[], unknown>>, z.ZodTransform<string[] | undefined, string[]>>>;
+}, z.core.$strip>;
 export type CalendarSearch = z.infer<typeof calendarSearchSchema>;

package/dist/src/lib/calendar-route.js

@@ -140,6 +140,8 @@ export function readCalendarIds(value) {
  */
 export const calendarSearchSchema = z.object({
     calendarId: z
-        .preprocess(readCalendarIds, z.array(calendarIdSchema))
-        .transform((ids) => (ids.length === 0 ? undefined : ids)),
+        .unknown()
+        .transform(readCalendarIds)
+        .transform((ids) => (ids.length === 0 ? undefined : ids))
+        .optional(),
 });

package/dist/src/lib/mail-search.d.ts

@@ -16,19 +16,11 @@ import { z } from "zod";
  */
 export declare const briefSearchSchema: z.ZodObject<{
     q: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    q?: string | undefined;
-}, {
-    q?: string | undefined;
-}>;
+}, z.core.$strip>;
 /** The same, for `/mail/flagged/<thread>/<message>`. */
 export declare const flaggedSearchSchema: z.ZodObject<{
     q: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    q?: string | undefined;
-}, {
-    q?: string | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * The outbox's open message is a path segment
  * (`/mail/outbox/draft/<outboxMessageId>`), so the query carries nothing but
@@ -36,11 +28,7 @@ export declare const flaggedSearchSchema: z.ZodObject<{
  */
 export declare const outboxSearchSchema: z.ZodObject<{
     q: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    q?: string | undefined;
-}, {
-    q?: string | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * A folder's open thread and the message inside it are path segments
  * (`/mail/<mailbox>/<thread>/<message>`), so the query carries nothing but the
@@ -48,94 +36,64 @@ export declare const outboxSearchSchema: z.ZodObject<{
  */
 export declare const mailboxSearchSchema: z.ZodObject<{
     q: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    q?: string | undefined;
-}, {
-    q?: string | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * `/mail` itself only redirects to the brief, so it accepts what the brief
  * accepts and hands it straight on.
  */
 export declare const mailIndexSearchSchema: z.ZodObject<{
     q: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    q?: string | undefined;
-}, {
-    q?: string | undefined;
-}>;
+}, z.core.$strip>;
+/**
+ * The `/mail` layout's own search: the query, plus the selection wizard's step
+ * (#477 clause 1.6) and the affordance that opened it, so a reload lands back on
+ * the walk it was in. The router owns history, so the step is a validated
+ * search param rather than a raw pushState entry.
+ */
+export declare const mailSearchSchema: z.ZodObject<{
+    q: z.ZodOptional<z.ZodString>;
+    wizard: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
+        name: "name";
+        match: "match";
+        run: "run";
+        folder: "folder";
+        rule: "rule";
+        review: "review";
+        properties: "properties";
+    }>>>;
+    wizardFrom: z.ZodCatch<z.ZodOptional<z.ZodLiteral<"search">>>;
+}, z.core.$strip>;
 /** Every list's schema, by the path it validates. */
 export declare const mailListSearchSchemas: {
     readonly "/mail/brief": z.ZodObject<{
         q: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        q?: string | undefined;
-    }, {
-        q?: string | undefined;
-    }>;
+    }, z.core.$strip>;
     readonly "/mail/flagged": z.ZodObject<{
         q: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        q?: string | undefined;
-    }, {
-        q?: string | undefined;
-    }>;
+    }, z.core.$strip>;
     readonly "/mail/outbox": z.ZodObject<{
         q: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        q?: string | undefined;
-    }, {
-        q?: string | undefined;
-    }>;
+    }, z.core.$strip>;
     readonly "/mail/$mailboxId": z.ZodObject<{
         q: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        q?: string | undefined;
-    }, {
-        q?: string | undefined;
-    }>;
+    }, z.core.$strip>;
 };
 export declare const composeSeedSearch: z.ZodObject<{
     body: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    body?: string | undefined;
-}, {
-    body?: string | undefined;
-}>;
+}, z.core.$strip>;
 export type ComposeSeed = Required<z.infer<typeof composeSeedSearch>>;
 export declare const withoutComposeSeed: (prev: Record<string, unknown>) => Record<string, unknown>;
 export declare const replySearchSchemas: {
     readonly brief: z.ZodObject<{
         q: z.ZodOptional<z.ZodString>;
-    } & {
         body: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        body?: string | undefined;
-        q?: string | undefined;
-    }, {
-        body?: string | undefined;
-        q?: string | undefined;
-    }>;
+    }, z.core.$strip>;
     readonly flagged: z.ZodObject<{
         q: z.ZodOptional<z.ZodString>;
-    } & {
         body: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        body?: string | undefined;
-        q?: string | undefined;
-    }, {
-        body?: string | undefined;
-        q?: string | undefined;
-    }>;
+    }, z.core.$strip>;
     readonly mailbox: z.ZodObject<{
         q: z.ZodOptional<z.ZodString>;
-    } & {
         body: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        body?: string | undefined;
-        q?: string | undefined;
-    }, {
-        body?: string | undefined;
-        q?: string | undefined;
-    }>;
+    }, z.core.$strip>;
 };

package/dist/src/lib/mail-search.js

@@ -8,6 +8,7 @@
  * is one place for it to be right.
  */
 import { z } from "zod";
+import { wizardEntryValue, wizardStepValue } from "../routing/wizard-history";
 /** What every list carries, whatever else it carries. */
 const listSearch = z.object({ q: z.string().optional() });
 /**
@@ -36,6 +37,16 @@ export const mailboxSearchSchema = listSearch.extend({});
  * accepts and hands it straight on.
  */
 export const mailIndexSearchSchema = briefSearchSchema;
+/**
+ * The `/mail` layout's own search: the query, plus the selection wizard's step
+ * (#477 clause 1.6) and the affordance that opened it, so a reload lands back on
+ * the walk it was in. The router owns history, so the step is a validated
+ * search param rather than a raw pushState entry.
+ */
+export const mailSearchSchema = listSearch.extend({
+    wizard: wizardStepValue,
+    wizardFrom: wizardEntryValue,
+});
 /** Every list's schema, by the path it validates. */
 export const mailListSearchSchemas = {
     "/mail/brief": briefSearchSchema,