@payloadcms/ui 4.0.0-internal.532221d → 4.0.0-internal.567a487

package/dist/elements/MergeBranch/index.css

@@ -0,0 +1,136 @@
+@layer payload-default {
+  /* Wraps the summary and its optional link so the gap to the mode options is the
+     wrapper's, and does not depend on which of the two is last. */
+  .merge-branch-modal__intro {
+    display: flex;
+    flex-direction: column;
+    align-items: flex-start;
+    gap: var(--spacer-1);
+    margin-block-end: var(--spacer-3);
+  }
+
+  .merge-branch-modal__summary {
+    margin-block: 0;
+    color: var(--color-text-secondary);
+  }
+
+  /* The way out of "all of it" — sits directly under the sentence it qualifies. */
+  .merge-branch-modal__review {
+    color: var(--color-text-brand);
+  }
+
+  .merge-branch-modal__modes {
+    display: flex;
+    flex-direction: column;
+    gap: var(--spacer-2);
+  }
+
+  /* Separated from the mode radios by a rule: this is a second, independent
+     decision, not a third option in the first one. */
+  .merge-branch-modal__close-branch {
+    margin-block-start: var(--spacer-3);
+    padding-block-start: var(--spacer-3);
+    border-block-start: var(--stroke-width-small) solid var(--color-border);
+  }
+
+  .merge-branch-modal__close-branch-help {
+    margin-block: var(--spacer-1) 0;
+    padding-inline-start: var(--spacer-4);
+    color: var(--color-text-secondary);
+  }
+
+  /* Indented to the radio label above it, so the date reads as part of choosing
+     "schedule" rather than as the next question down the modal. */
+  .merge-branch-modal__schedule {
+    display: flex;
+    flex-direction: column;
+    gap: var(--spacer-2);
+    margin-block-start: var(--spacer-2);
+    padding-inline-start: var(--spacer-4);
+  }
+
+  .merge-branch-modal__schedule-field {
+    display: flex;
+    flex-direction: column;
+    gap: var(--spacer-1);
+  }
+
+  /* The picker sizes itself to its container, which in a modal is the full width —
+     a date needs nothing like that much room. */
+  .merge-branch-modal__schedule-field .date-time-picker {
+    max-width: calc(var(--spacer-6) * 6);
+  }
+
+  .merge-branch-modal__schedule-help {
+    margin: 0;
+    color: var(--color-text-secondary);
+  }
+
+  .merge-branch-modal__upcoming {
+    display: flex;
+    flex-direction: column;
+    gap: var(--spacer-1);
+  }
+
+  .merge-branch-modal__upcoming-title {
+    margin: 0;
+    font-family: var(--text-body-small-font-family);
+    font-size: var(--text-body-small-font-size);
+    color: var(--color-text-secondary);
+  }
+
+  .merge-branch-modal__upcoming-list {
+    margin: 0;
+    padding: 0;
+    list-style: none;
+  }
+
+  .merge-branch-modal__upcoming-row {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: var(--spacer-3);
+  }
+
+  .merge-branch-modal__unavailable {
+    margin: 0;
+    color: var(--color-text-secondary);
+  }
+
+  .merge-branch-modal__progress {
+    display: flex;
+    flex-direction: column;
+    gap: var(--spacer-2);
+    margin-block-start: var(--spacer-4);
+  }
+
+  .merge-branch-modal__progress-bar {
+    height: var(--spacer-1);
+    border-radius: var(--radius-full);
+    background: var(--color-bg-secondary);
+    overflow: hidden;
+  }
+
+  .merge-branch-modal__progress-fill {
+    height: 100%;
+    border-radius: inherit;
+    background: var(--color-text-brand);
+    /* Each document lands as a discrete step, so ease between them rather than
+       letting the bar snap on every event. */
+    transition: width 200ms ease-out;
+  }
+
+  .merge-branch-modal__progress-fill--complete {
+    background: var(--color-bg-success);
+  }
+
+  .merge-branch-modal__blocked {
+    margin-block: var(--spacer-3) 0;
+    padding-inline-start: var(--spacer-3);
+    color: var(--color-text-danger);
+  }
+
+  .merge-branch-modal__progress-label {
+    color: var(--color-text-secondary);
+  }
+}

package/dist/elements/MergeBranch/index.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import './index.css';
+/**
+ * The modal every merge entry point opens.
+ *
+ * Merging is a decision — what to take, and when — so it happens in a modal from
+ * wherever the branch is on screen, rather than by routing somewhere first.
+ *
+ * The merge itself streams. A branch can hold hundreds of documents and each one
+ * is a full write with hooks and validation, so "merging 34 of 230" is real
+ * information rather than a spinner's decoration; see `endpoints/merge.ts` for
+ * why that is a streamed response rather than a job and a polling loop.
+ */
+export declare const MergeBranchModal: React.FC;
+//# sourceMappingURL=index.d.ts.map

package/dist/elements/MergeBranch/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/elements/MergeBranch/index.tsx"],"names":[],"mappings":"AAUA,OAAO,KAA2C,MAAM,OAAO,CAAA;AAuB/D,OAAO,aAAa,CAAA;AAmBpB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,EAAE,KAAK,CAAC,EAkiBpC,CAAA"}

package/dist/elements/MergeBranch/index.js

@@ -0,0 +1,545 @@
+'use client';
+
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { branchChangesCollectionSlug, branchesCollectionSlug, formatAdminURL, MAIN_BRANCH } from 'payload/shared';
+import React, { useCallback, useEffect, useState } from 'react';
+import { toast } from 'sonner';
+import { CheckboxInput } from '../../fields/Checkbox/Input.js';
+import { FieldLabel } from '../../fields/FieldLabel/index.js';
+import { Radio } from '../../fields/RadioGroup/Radio/index.js';
+import { useConfig } from '../../providers/Config/index.js';
+import { useRouter } from '../../providers/RouterAdapter/index.js';
+import { useRouteTransition } from '../../providers/RouteTransition/index.js';
+import { useServerFunctions } from '../../providers/ServerFunctions/index.js';
+import { useTranslation } from '../../providers/Translation/index.js';
+import { requests } from '../../utilities/api.js';
+import { buildUpcomingMergeWhere } from '../../utilities/scheduleMergeHandler.js';
+import { Button } from '../Button/index.js';
+import { ChangeSummary } from '../ChangeSummary/index.js';
+import { DatePickerField } from '../DatePicker/index.js';
+import { DialogBody, DialogFooter, DialogHeader, DialogModal } from '../Dialog/index.js';
+import { Link } from '../Link/index.js';
+import { useModal } from '../Modal/index.js';
+import { useMergeBranch } from './context.js';
+import { mergeBranchModalSlug } from './slug.js';
+import './index.css';
+const baseClass = 'merge-branch-modal';
+/**
+ * How many changes the modal will read to describe the merge.
+ *
+ * High enough to cover any branch a person is reviewing by hand, low enough that a
+ * runaway branch does not turn opening this modal into a bulk read.
+ */
+const SUMMARY_SAMPLE_LIMIT = 200;
+/**
+ * The modal every merge entry point opens.
+ *
+ * Merging is a decision — what to take, and when — so it happens in a modal from
+ * wherever the branch is on screen, rather than by routing somewhere first.
+ *
+ * The merge itself streams. A branch can hold hundreds of documents and each one
+ * is a full write with hooks and validation, so "merging 34 of 230" is real
+ * information rather than a spinner's decoration; see `endpoints/merge.ts` for
+ * why that is a streamed response rather than a job and a polling loop.
+ */
+export const MergeBranchModal = () => {
+  const {
+    closeMerge,
+    target
+  } = useMergeBranch();
+  const {
+    t
+  } = useTranslation();
+  const {
+    isModalOpen
+  } = useModal();
+  const router = useRouter();
+  const {
+    startRouteTransition
+  } = useRouteTransition();
+  const {
+    serverFunction
+  } = useServerFunctions();
+  const {
+    config: {
+      routes: {
+        api
+      },
+      serverURL
+    }
+  } = useConfig();
+  const [mode, setMode] = useState('now');
+  const [scheduledFor, setScheduledFor] = useState();
+  const [isMerging, setIsMerging] = useState(false);
+  const [progress, setProgress] = useState(null);
+  const [countedChanges, setCountedChanges] = useState(null);
+  /** The branch's changes, read here when the opener did not already know them. */
+  const [sampledChanges, setSampledChanges] = useState(null);
+  /** Set once the merge has finished, which switches the modal to its receipt. */
+  const [outcome, setOutcome] = useState(null);
+  const [closeBranch, setCloseBranch] = useState(false);
+  const [isScheduling, setIsScheduling] = useState(false);
+  const [upcoming, setUpcoming] = useState([]);
+  const isOpen = isModalOpen(mergeBranchModalSlug);
+  const branchSlug = target?.branchSlug;
+  const knownChanges = target?.changes;
+  // Offered only when nothing is left behind. Merging a subset means there is still
+  // work on the branch by definition, so closing it would abandon that work — a
+  // destructive act wearing a convenience checkbox. Computed up here because
+  // `handleMergeNow` depends on it.
+  const canCloseBranch = target?.selectedChangeIDs === undefined;
+  // Read on open rather than with the screen behind it: the switcher can be opened
+  // from anywhere, and a summary nobody has asked to see is a query on every page
+  // load. Skipped entirely when the opener already knows what it is merging.
+  useEffect(() => {
+    if (!isOpen || !branchSlug || knownChanges) {
+      return;
+    }
+    const controller = new AbortController();
+    const readChanges = async () => {
+      try {
+        const response = await requests.get(formatAdminURL({
+          apiRoute: api,
+          path: `/${branchChangesCollectionSlug}`,
+          serverURL
+        }), {
+          params: {
+            depth: 0,
+            limit: SUMMARY_SAMPLE_LIMIT,
+            select: {
+              collectionSlug: true,
+              operation: true
+            },
+            where: {
+              branch: {
+                equals: branchSlug
+              }
+            }
+          },
+          signal: controller.signal
+        });
+        const json = await response.json();
+        if (typeof json?.totalDocs === 'number') {
+          setCountedChanges(json.totalDocs);
+          // Only when the sample is the whole set. A breakdown of the first 200 of
+          // 900 changes would read as a description of the merge and be wrong about
+          // it, so past that point the count says it on its own.
+          setSampledChanges(json.docs?.length === json.totalDocs ? json.docs ?? null : null);
+        }
+      } catch (_err) {
+        // A missing summary degrades the copy, not the action — the merge still
+        // knows what it is applying.
+      }
+    };
+    void readChanges();
+    return () => controller.abort();
+  }, [api, branchSlug, isOpen, knownChanges, serverURL]);
+  // Upcoming schedules for this branch, loaded when the schedule option is chosen
+  // rather than with the modal — most merges are immediate and never ask.
+  const loadUpcoming = useCallback(async () => {
+    if (!branchSlug) {
+      return;
+    }
+    try {
+      const response_0 = await requests.get(formatAdminURL({
+        apiRoute: api,
+        path: '/payload-jobs',
+        serverURL
+      }), {
+        params: {
+          depth: 0,
+          limit: 10,
+          sort: 'waitUntil',
+          where: buildUpcomingMergeWhere({
+            branchSlug
+          })
+        }
+      });
+      const json_0 = await response_0.json();
+      setUpcoming((json_0.docs ?? []).filter(doc => Boolean(doc.waitUntil)).map(doc_0 => ({
+        id: doc_0.id,
+        waitUntil: String(doc_0.waitUntil)
+      })));
+    } catch (_err_0) {
+      // A missing list costs the reader context, not the action.
+    }
+  }, [api, branchSlug, serverURL]);
+  useEffect(() => {
+    if (isOpen && mode === 'schedule') {
+      void loadUpcoming();
+    }
+  }, [isOpen, loadUpcoming, mode]);
+  const reset = useCallback(() => {
+    setMode('now');
+    setScheduledFor(undefined);
+    setProgress(null);
+    setOutcome(null);
+    setCloseBranch(false);
+    setUpcoming([]);
+  }, []);
+  const dismiss = useCallback(() => {
+    closeMerge();
+    reset();
+  }, [closeMerge, reset]);
+  const reportResult = useCallback(result => {
+    if (result.merged.length) {
+      toast.success(t('branching:mergedCount', {
+        count: result.merged.length
+      }));
+    }
+    // Blocked entries are per-document refusals, not a failed merge: the rest
+    // was applied and the branch stays open for what was not.
+    result.blocked.forEach(({
+      message
+    }) => toast.error(message));
+    if (!result.merged.length && !result.blocked.length) {
+      toast.info(t('branching:noChangesYet'));
+    }
+  }, [t]);
+  const handleSchedule = useCallback(async () => {
+    if (!target || !scheduledFor || isScheduling) {
+      return;
+    }
+    setIsScheduling(true);
+    try {
+      const result_0 = await serverFunction({
+        name: 'schedule-merge',
+        args: {
+          branchID: target.branchID,
+          changes: target.selectedChangeIDs,
+          closeBranch: canCloseBranch && closeBranch,
+          date: scheduledFor
+        }
+      });
+      if (result_0?.error) {
+        toast.error(result_0.error);
+        return;
+      }
+      toast.success(t('branching:mergeScheduledFor', {
+        date: scheduledFor.toLocaleString(undefined, {
+          dateStyle: 'medium',
+          timeStyle: 'short'
+        })
+      }));
+      dismiss();
+      // The branch page shows nothing about a queued merge yet, but the jobs list
+      // does — and the branch's own state may have been read before this.
+      startRouteTransition(() => router.refresh());
+    } catch (_err_1) {
+      toast.error(t('error:unknown'));
+    } finally {
+      setIsScheduling(false);
+    }
+  }, [canCloseBranch, closeBranch, dismiss, isScheduling, router, scheduledFor, serverFunction, startRouteTransition, t, target]);
+  const handleCancel = useCallback(async deleteID => {
+    setIsScheduling(true);
+    try {
+      await serverFunction({
+        name: 'schedule-merge',
+        args: {
+          deleteID
+        }
+      });
+      await loadUpcoming();
+      toast.success(t('general:deletedSuccessfully'));
+    } catch (_err_2) {
+      toast.error(t('error:unknown'));
+    } finally {
+      setIsScheduling(false);
+    }
+  }, [loadUpcoming, serverFunction, t]);
+  const handleMergeNow = useCallback(async () => {
+    if (!target || isMerging) {
+      return;
+    }
+    setIsMerging(true);
+    setProgress(null);
+    try {
+      const response_1 = await fetch(formatAdminURL({
+        apiRoute: api,
+        path: `/${branchesCollectionSlug}/${target.branchID}/merge`,
+        serverURL
+      }), {
+        body: JSON.stringify({
+          changes: target.selectedChangeIDs,
+          // Ignored server-side when changes are left behind, but not sent at all
+          // when a subset is selected: the checkbox is not offered then either.
+          closeBranch: canCloseBranch && closeBranch,
+          stream: true
+        }),
+        credentials: 'include',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        method: 'POST'
+      });
+      if (!response_1.ok || !response_1.body) {
+        // A non-streaming failure still returns JSON — a 403 carrying `blocked`,
+        // most usefully — so read it as the result rather than a bare error.
+        const json_1 = await response_1.json().catch(() => null);
+        if (json_1?.blocked?.length) {
+          reportResult(json_1);
+        } else {
+          toast.error(t('error:unknown'));
+        }
+        return;
+      }
+      const result_1 = await readMergeStream({
+        body: response_1.body,
+        onProgress: setProgress
+      });
+      if (!result_1) {
+        // The stream ended without a terminal event, which means the connection
+        // dropped mid-merge. The transaction rolls back with it, so nothing was
+        // applied — but say so rather than implying success.
+        toast.error(t('branching:mergeInterrupted'));
+        return;
+      }
+      if (result_1.type === 'error') {
+        toast.error(result_1.message);
+        return;
+      }
+      reportResult(result_1.result);
+      // Held open rather than dismissed. A small branch merges faster than the
+      // progress bar can be read, so closing on success would make the whole
+      // operation a flicker — the reader is left guessing whether it ran. The
+      // completed state is the receipt, and it is dismissed deliberately.
+      setOutcome(result_1.result);
+      // The changed-documents list and the branch's status both moved. Refreshed
+      // behind the modal so the page is already correct when it is dismissed.
+      startRouteTransition(() => router.refresh());
+    } catch (_err_3) {
+      toast.error(t('error:unknown'));
+    } finally {
+      setIsMerging(false);
+    }
+  }, [api, canCloseBranch, closeBranch, isMerging, reportResult, router, serverURL, startRouteTransition, t, target]);
+  if (!target) {
+    return null;
+  }
+  const modeOptions = [{
+    label: t('branching:mergeNow'),
+    value: 'now'
+  }, {
+    label: t('branching:scheduleMerge'),
+    value: 'schedule'
+  }];
+  const total = target.totalChanges ?? countedChanges ?? undefined;
+  const selectedCount = target.selectedChangeIDs?.length;
+  const summaryChanges = target.changes ?? sampledChanges;
+  // Three cases, in order of how much is known: a subset chosen, the whole branch
+  // with a count, and the whole branch before the count lands.
+  const summary = selectedCount !== undefined && total !== undefined ? t('branching:mergeSelectedOfTotal', {
+    selected: selectedCount,
+    total
+  }) : total !== undefined ? t('branching:mergeAllCount', {
+    count: total
+  }) : t('branching:mergeAllChanges');
+  const mergedCount = outcome?.merged.length ?? 0;
+  const isDone = Boolean(outcome);
+  // Completed bar rather than a residual fraction: the last progress event fires
+  // *before* the last document is applied, so it never reaches 100% on its own.
+  const percentComplete = isDone ? 100 : progress?.total ? Math.round(progress.current / progress.total * 100) : 0;
+  return /*#__PURE__*/_jsxs(DialogModal, {
+    className: baseClass,
+    closeOnBlur: !isMerging,
+    slug: mergeBranchModalSlug,
+    children: [/*#__PURE__*/_jsx(DialogHeader, {
+      showClose: !isMerging,
+      title: isDone ? t('branching:mergeComplete') : t('branching:mergeBranchInto', {
+        branch: target.branchName,
+        target: MAIN_BRANCH
+      })
+    }), /*#__PURE__*/_jsxs(DialogBody, {
+      children: [!isDone && /*#__PURE__*/_jsxs(React.Fragment, {
+        children: [/*#__PURE__*/_jsxs("div", {
+          className: `${baseClass}__intro`,
+          children: [/*#__PURE__*/_jsx("p", {
+            className: `${baseClass}__summary`,
+            children: summary
+          }), summaryChanges && /*#__PURE__*/_jsx(ChangeSummary, {
+            changes: summaryChanges,
+            showOperations: true
+          }), target.reviewURL && !isMerging && /*#__PURE__*/_jsx(Link, {
+            className: `${baseClass}__review`,
+            href: target.reviewURL,
+            onClick: dismiss,
+            children: t('branching:mergeOnlySelected')
+          })]
+        }), /*#__PURE__*/_jsx("div", {
+          className: `${baseClass}__modes`,
+          children: modeOptions.map(option => /*#__PURE__*/_jsx(Radio, {
+            id: `merge-mode-${option.value}`,
+            isSelected: mode === option.value,
+            onChange: () => setMode(option.value),
+            option: option,
+            path: "merge-mode",
+            readOnly: isMerging
+          }, option.value))
+        }), mode === 'schedule' && /*#__PURE__*/_jsxs("div", {
+          className: `${baseClass}__schedule`,
+          children: [/*#__PURE__*/_jsxs("div", {
+            className: `${baseClass}__schedule-field`,
+            children: [/*#__PURE__*/_jsx(FieldLabel, {
+              label: t('general:time'),
+              path: "merge-scheduled-for",
+              required: true
+            }), /*#__PURE__*/_jsx(DatePickerField, {
+              id: "merge-scheduled-for",
+              minDate: new Date(),
+              onChange: value => setScheduledFor(value ?? undefined),
+              pickerAppearance: "dayAndTime",
+              readOnly: isScheduling,
+              value: scheduledFor
+            })]
+          }), /*#__PURE__*/_jsx("p", {
+            className: `${baseClass}__schedule-help`,
+            children: t('branching:scheduleMergeHelp')
+          }), upcoming.length > 0 && /*#__PURE__*/_jsxs("div", {
+            className: `${baseClass}__upcoming`,
+            children: [/*#__PURE__*/_jsx("h4", {
+              className: `${baseClass}__upcoming-title`,
+              children: t('branching:scheduledMerges')
+            }), /*#__PURE__*/_jsx("ul", {
+              className: `${baseClass}__upcoming-list`,
+              children: upcoming.map(event => /*#__PURE__*/_jsxs("li", {
+                className: `${baseClass}__upcoming-row`,
+                children: [/*#__PURE__*/_jsx("span", {
+                  children: new Date(event.waitUntil).toLocaleString(undefined, {
+                    dateStyle: 'medium',
+                    timeStyle: 'short'
+                  })
+                }), /*#__PURE__*/_jsx(Button, {
+                  buttonStyle: "ghost",
+                  className: `${baseClass}__upcoming-cancel`,
+                  disabled: isScheduling,
+                  onClick: () => void handleCancel(event.id),
+                  children: t('general:cancel')
+                })]
+              }, String(event.id)))
+            })]
+          })]
+        }), canCloseBranch && /*#__PURE__*/_jsxs("div", {
+          className: `${baseClass}__close-branch`,
+          children: [/*#__PURE__*/_jsx(CheckboxInput, {
+            checked: closeBranch,
+            id: "merge-close-branch",
+            label: t('branching:closeBranchAfterMerge'),
+            onToggle: () => setCloseBranch(prev => !prev),
+            readOnly: isMerging
+          }), /*#__PURE__*/_jsx("p", {
+            className: `${baseClass}__close-branch-help`,
+            children: closeBranch ? t('branching:closeBranchHelpOn') : t('branching:closeBranchHelpOff')
+          })]
+        })]
+      }), (isMerging || isDone) && /*#__PURE__*/_jsxs("div", {
+        className: `${baseClass}__progress`,
+        children: [/*#__PURE__*/_jsx("div", {
+          className: `${baseClass}__progress-bar`,
+          children: /*#__PURE__*/_jsx("div", {
+            className: [`${baseClass}__progress-fill`, isDone && `${baseClass}__progress-fill--complete`].filter(Boolean).join(' '),
+            style: {
+              width: `${percentComplete}%`
+            }
+          })
+        }), /*#__PURE__*/_jsx("span", {
+          className: `${baseClass}__progress-label`,
+          children: isDone ? t('branching:mergedOfTotal', {
+            current: mergedCount,
+            total: mergedCount
+          }) : progress ? t('branching:mergingProgress', {
+            current: progress.current,
+            total: progress.total
+          }) : t('branching:mergeStarting')
+        })]
+      }), outcome && outcome.blocked.length > 0 && /*#__PURE__*/_jsx("ul", {
+        className: `${baseClass}__blocked`,
+        children: outcome.blocked.map(each => /*#__PURE__*/_jsx("li", {
+          children: each.message
+        }, String(each.changeID)))
+      })]
+    }), /*#__PURE__*/_jsx(DialogFooter, {
+      children: isDone ? /*#__PURE__*/_jsx(Button, {
+        buttonStyle: "primary",
+        onClick: dismiss,
+        size: "medium",
+        children: t('general:close')
+      }) : /*#__PURE__*/_jsxs(React.Fragment, {
+        children: [/*#__PURE__*/_jsx(Button, {
+          buttonStyle: "secondary",
+          disabled: isMerging,
+          onClick: dismiss,
+          size: "medium",
+          children: t('general:cancel')
+        }), /*#__PURE__*/_jsx(Button, {
+          buttonStyle: "primary",
+          disabled: isMerging || isScheduling ||
+          // A schedule with no date is not a decision yet.
+          mode === 'schedule' && !scheduledFor,
+          onClick: () => void (mode === 'schedule' ? handleSchedule() : handleMergeNow()),
+          size: "medium",
+          children: mode === 'schedule' ? isScheduling ? t('branching:scheduling') : t('branching:scheduleMerge') : isMerging ? t('branching:merging') : t('branching:merge')
+        })]
+      })
+    })]
+  });
+};
+/**
+ * Reads the NDJSON merge stream, returning the terminal event.
+ *
+ * Returns null when the stream ends without one, which is how a dropped
+ * connection presents — indistinguishable from the server never finishing, and
+ * treated the same way, because in both cases the transaction did not commit.
+ */
+const readMergeStream = async ({
+  body,
+  onProgress
+}) => {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffered = '';
+  const handleLine = line => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      return null;
+    }
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch (_err) {
+      return null;
+    }
+    if (event.type === 'progress') {
+      onProgress({
+        current: Number(event.current),
+        total: Number(event.total)
+      });
+      return null;
+    }
+    return event;
+  };
+  while (true) {
+    const {
+      done,
+      value
+    } = await reader.read();
+    if (done) {
+      break;
+    }
+    buffered += decoder.decode(value, {
+      stream: true
+    });
+    // A chunk can split a line anywhere, so only whole lines are parsed and the
+    // remainder is carried forward.
+    const lines = buffered.split('\n');
+    buffered = lines.pop() ?? '';
+    for (const line of lines) {
+      const terminal = handleLine(line);
+      if (terminal) {
+        return terminal;
+      }
+    }
+  }
+  return handleLine(buffered);
+};
+//# sourceMappingURL=index.js.map