@jxsuite/studio 6.1.2 → 8.0.1

package/src/publish/publish-ids.ts

@@ -0,0 +1,49 @@
+/**
+ * The Publish workspace's closed vocabularies: its four sub-tabs and its two destinations.
+ *
+ * A module with no DOM import, for the reason `workspace/workspace-ids.ts` gives: the
+ * `publish.open` record names {@link PUBLISH_TABS} as its `args` enum, and
+ * `commands/app-commands.ts` loads every record in a bare Bun process for the CI checks.
+ * `src/shell.ts` reads the same lists for the session's `shell.publish` record, so there is one
+ * copy of each.
+ *
+ * @docs studio/publish
+ */
+
+/** The sub-tabs, in the order the workspace draws them (studio.md §22.8). */
+export const PUBLISH_TABS = ["review", "deploys", "branches", "hosting"] as const;
+
+export type PublishTab = (typeof PUBLISH_TABS)[number];
+
+/** What each sub-tab is called. The first is a verb phrase because it is the thing to do. */
+export const PUBLISH_TAB_TITLES: Readonly<Record<PublishTab, string>> = {
+  branches: "Branches",
+  deploys: "Deploys",
+  hosting: "Hosting",
+  review: "Review changes",
+};
+
+/**
+ * Where a change set goes: committed to the current branch and shipped (`live`), or committed to a
+ * branch of its own and opened as a pull request (`review`).
+ */
+export const PUBLISH_DESTINATIONS = ["live", "review"] as const;
+
+export type PublishDestination = (typeof PUBLISH_DESTINATIONS)[number];
+
+/** The tab the workspace opens on, and the destination it offers first. */
+export const DEFAULT_PUBLISH_TAB: PublishTab = "review";
+export const DEFAULT_PUBLISH_DESTINATION: PublishDestination = "live";
+
+const TAB_SET: ReadonlySet<string> = new Set(PUBLISH_TABS);
+const DESTINATION_SET: ReadonlySet<string> = new Set(PUBLISH_DESTINATIONS);
+
+/** Whether a value is one of the sub-tabs. A narrowing guard, so a caller needs no cast. */
+export function isPublishTab(value: unknown): value is PublishTab {
+  return typeof value === "string" && TAB_SET.has(value);
+}
+
+/** Whether a value is one of the destinations. */
+export function isPublishDestination(value: unknown): value is PublishDestination {
+  return typeof value === "string" && DESTINATION_SET.has(value);
+}

package/src/publish/publish-quick.ts

@@ -0,0 +1,148 @@
+/// <reference lib="dom" />
+/**
+ * Quick publish: the dialog behind the chevron beside the Publish workspace tab (studio.md §22.8).
+ *
+ * The workspace is where a change set is reviewed; this is where it is sent when there is nothing
+ * to review. It shows the count, the first few files, the destination, the summary and the checks
+ * in one line, and **Publish now** takes EVERY change, not only the included ones, because the
+ * dialog lists all of them and has no checkbox to leave one out. **Review all** closes it and opens
+ * the workspace on Review changes, where each file can be included or left out.
+ *
+ * The words are `publish/publish-changes.ts`'s, the same ones Review changes draws, and so is the
+ * verb: the dialog and the workspace cannot disagree about what Publish live does.
+ *
+ * @docs studio/publish
+ */
+
+import { effect, effectScope } from "../reactivity";
+import { runActiveReported } from "../commands/run-reported";
+import { shell } from "../shell";
+import { layerHost } from "../ui/layers";
+import { openPublishQuickSurface } from "../surfaces/publish-quick";
+import {
+  checksLine,
+  destinationChoices,
+  effectiveDestination,
+  publishBlocker,
+  publishChanges,
+  publishChecks,
+} from "./publish-changes";
+import { isPublishDestination } from "./publish-ids";
+import { changeRow, statusTag } from "./source-control";
+import type { EffectScope } from "@vue/reactivity";
+import type { GitFileStatus } from "../types";
+import type {
+  PublishQuickSurfaceHandle,
+  PublishQuickView,
+  QuickChangeRow,
+} from "../surfaces/publish-quick";
+
+/** How many files the short list names before it says how many more there are. */
+export const QUICK_LIST_LIMIT = 4;
+
+/** One file as the short list draws it: Review changes' own row, with the compact tag. */
+function quickRow(file: GitFileStatus): QuickChangeRow {
+  const { dir, key, name, path, status } = changeRow(file);
+  return { dir, key, name, path, status, tag: statusTag(status) };
+}
+
+/** What the dialog draws right now. */
+export function quickPublishView(): PublishQuickView {
+  const files = shell.git.status?.files ?? [];
+  const chosen = shell.publish.destination;
+  const destination = effectiveDestination(chosen);
+  const checks = publishChecks();
+  const open = checks.some((check) => check.state !== "done");
+  const blocker = shell.git.error || publishBlocker(destination, true);
+  const extra = files.length - QUICK_LIST_LIMIT;
+  return {
+    blocked: publishBlocker(destination, true) !== "",
+    blocker,
+    checksIcon: open ? "warning-circle" : "check",
+    checksLine: checksLine(checks),
+    checksState: open ? "open" : "done",
+    countLine:
+      files.length === 0
+        ? "Nothing to publish"
+        : `${files.length} ${files.length === 1 ? "change" : "changes"} ready`,
+    destination,
+    destinations: destinationChoices(chosen),
+    hasBlocker: blocker !== "",
+    hasMore: extra > 0,
+    listState: files.length > 0 ? "listed" : "empty",
+    more: extra > 0 ? `+ ${extra} more` : "",
+    rows: files.slice(0, QUICK_LIST_LIMIT).map((file) => quickRow(file)),
+    summary: shell.git.commitMessage,
+  };
+}
+
+interface OpenDialog {
+  handle: PublishQuickSurfaceHandle;
+  scope: EffectScope;
+}
+
+let _open: OpenDialog | null = null;
+
+/** Close the dialog. Idempotent. */
+export function closeQuickPublish(): void {
+  const open = _open;
+  _open = null;
+  if (open) {
+    open.scope.stop();
+    open.handle.close();
+  }
+}
+
+/**
+ * Open the dialog, or leave the one already up alone.
+ *
+ * @returns The dialog's handle, whose `ready` settles once it is showing.
+ */
+export function openQuickPublish(): PublishQuickSurfaceHandle {
+  if (_open) {
+    return _open.handle;
+  }
+  // A refusal from an earlier attempt is not this dialog's to show.
+  shell.git.error = null;
+  const handle = openPublishQuickSurface({
+    actions: {
+      closed: () => {
+        if (_open?.handle === handle) {
+          _open.scope.stop();
+          _open = null;
+        }
+      },
+      confirm: () => {
+        void publishChanges(effectiveDestination(shell.publish.destination), {
+          includeAll: true,
+        }).then((published) => {
+          if (published) {
+            closeQuickPublish();
+          }
+        });
+      },
+      editSummary: (value) => {
+        shell.git.commitMessage = value;
+      },
+      pickDestination: (value) => {
+        if (isPublishDestination(value)) {
+          shell.publish.destination = value;
+        }
+      },
+      reviewAll: () => {
+        closeQuickPublish();
+        void runActiveReported("publish.open", { tab: "review" }, "Publish");
+      },
+    },
+    layer: layerHost("dialog"),
+    view: quickPublishView(),
+  });
+  const scope = effectScope();
+  scope.run(() => {
+    effect(() => {
+      handle.update(quickPublishView());
+    });
+  });
+  _open = { handle, scope };
+  return handle;
+}