@agent-native/core-corpus 0.213.1 → 0.216.0

package/corpus/templates/slides-2/app/lib/deck-access-lost.ts

@@ -0,0 +1,4 @@
+/** 403/404 on an open deck: the viewer's access was revoked or the deck is gone. */
+export function isDeckAccessLostStatus(status: unknown): boolean {
+  return status === 403 || status === 404;
+}

package/corpus/templates/slides-2/app/lib/deck-backup.ts

@@ -0,0 +1,186 @@
+import { ASPECT_RATIO_VALUES, type AspectRatio } from "@shared/aspect-ratios";
+
+import type { Deck, Slide, SlideLayout } from "@/context/DeckContext";
+
+import { normalizeSlideClipboard } from "./slide-clipboard";
+
+export const DECK_BACKUP_FORMAT = "agent-native-slides-deck" as const;
+export const DECK_BACKUP_VERSION = 1 as const;
+
+const SLIDE_LAYOUTS: SlideLayout[] = [
+  "title",
+  "section",
+  "content",
+  "two-column",
+  "image",
+  "statement",
+  "full-image",
+  "blank",
+];
+
+export type DeckBackupFields = {
+  title: string;
+  slides: Slide[];
+  aspectRatio?: AspectRatio;
+  designSystemId?: string;
+  tweaks?: Record<string, string | number | boolean>;
+  starred?: boolean;
+};
+
+export type DeckBackup = {
+  format: typeof DECK_BACKUP_FORMAT;
+  version: typeof DECK_BACKUP_VERSION;
+  deck: DeckBackupFields;
+};
+
+export class DeckBackupError extends Error {
+  constructor() {
+    super("Invalid Slides backup");
+    this.name = "DeckBackupError";
+  }
+}
+
+function record(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+function isAspectRatio(value: unknown): value is AspectRatio {
+  return (
+    typeof value === "string" &&
+    (ASPECT_RATIO_VALUES as readonly string[]).includes(value)
+  );
+}
+
+function isSlideLayout(value: unknown): value is SlideLayout {
+  return (
+    typeof value === "string" && SLIDE_LAYOUTS.includes(value as SlideLayout)
+  );
+}
+
+function parseSlide(value: unknown): Slide {
+  const source = record(value);
+  if (
+    !source ||
+    typeof source.id !== "string" ||
+    !source.id ||
+    typeof source.content !== "string"
+  ) {
+    throw new DeckBackupError();
+  }
+
+  if (typeof source.notes !== "string" || !isSlideLayout(source.layout)) {
+    throw new DeckBackupError();
+  }
+
+  const normalized = normalizeSlideClipboard(source);
+  if (!normalized) throw new DeckBackupError();
+  return normalized;
+}
+
+function backupFields(deck: Deck): DeckBackupFields {
+  return {
+    title: deck.title,
+    slides: deck.slides.map(
+      ({ imageLoading: _imageLoading, ...slide }) => slide,
+    ),
+    ...(deck.aspectRatio ? { aspectRatio: deck.aspectRatio } : {}),
+    ...(deck.designSystemId ? { designSystemId: deck.designSystemId } : {}),
+    ...(deck.tweaks ? { tweaks: deck.tweaks } : {}),
+    ...(deck.starred !== undefined ? { starred: deck.starred } : {}),
+  };
+}
+
+export function serializeDeckBackup(deck: Deck): string {
+  return JSON.stringify(
+    {
+      format: DECK_BACKUP_FORMAT,
+      version: DECK_BACKUP_VERSION,
+      deck: backupFields(deck),
+    } satisfies DeckBackup,
+    null,
+    2,
+  );
+}
+
+export function parseDeckBackup(raw: string): DeckBackup {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new DeckBackupError();
+  }
+
+  const root = record(parsed);
+  const source = record(root?.deck);
+  if (
+    root?.format !== DECK_BACKUP_FORMAT ||
+    root.version !== DECK_BACKUP_VERSION ||
+    !source ||
+    typeof source.title !== "string" ||
+    !source.title.trim() ||
+    !Array.isArray(source.slides)
+  ) {
+    throw new DeckBackupError();
+  }
+
+  const slides = source.slides.map(parseSlide);
+  if (new Set(slides.map((slide) => slide.id)).size !== slides.length) {
+    throw new DeckBackupError();
+  }
+
+  const deck: DeckBackupFields = {
+    title: source.title,
+    slides,
+  };
+  if (source.aspectRatio !== undefined) {
+    if (!isAspectRatio(source.aspectRatio)) throw new DeckBackupError();
+    deck.aspectRatio = source.aspectRatio;
+  }
+  if (source.designSystemId !== undefined) {
+    if (typeof source.designSystemId !== "string") throw new DeckBackupError();
+    deck.designSystemId = source.designSystemId;
+  }
+  if (source.tweaks !== undefined) {
+    const tweaks = record(source.tweaks);
+    if (
+      !tweaks ||
+      Object.values(tweaks).some(
+        (value) =>
+          typeof value !== "string" &&
+          typeof value !== "number" &&
+          typeof value !== "boolean",
+      )
+    ) {
+      throw new DeckBackupError();
+    }
+    deck.tweaks = tweaks as DeckBackupFields["tweaks"];
+  }
+  if (source.starred !== undefined) {
+    if (typeof source.starred !== "boolean") throw new DeckBackupError();
+    deck.starred = source.starred;
+  }
+
+  return {
+    format: DECK_BACKUP_FORMAT,
+    version: DECK_BACKUP_VERSION,
+    deck,
+  };
+}
+
+export function downloadDeckBackup(deck: Deck): void {
+  const safeTitle = deck.title.replace(/[^a-zA-Z0-9_-]/g, "-") || "deck";
+  const blob = new Blob([serializeDeckBackup(deck)], {
+    type: "application/json",
+  });
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement("a");
+  anchor.href = url;
+  anchor.download = `${safeTitle}.deck.json`;
+  anchor.rel = "noopener";
+  document.body.appendChild(anchor);
+  anchor.click();
+  anchor.remove();
+  window.setTimeout(() => URL.revokeObjectURL(url), 60_000);
+}

package/corpus/templates/slides-2/app/lib/deck-editor-loading.ts

@@ -0,0 +1,91 @@
+export function deckAccessCheckKey(
+  deckId: string | undefined,
+  orgId: string | null | undefined,
+): string | null {
+  return deckId ? JSON.stringify([deckId, orgId ?? null]) : null;
+}
+
+export async function retryMissingDeck({
+  refetchOrg,
+  reloadDecks,
+  refetchAccessStatus,
+}: {
+  refetchOrg: () => Promise<unknown>;
+  reloadDecks: () => Promise<unknown>;
+  refetchAccessStatus: () => Promise<unknown>;
+}): Promise<void> {
+  await refetchOrg();
+  await reloadDecks();
+  await refetchAccessStatus();
+}
+
+/**
+ * What the metadata-only access probe says about a deck the editor could not
+ * load. Only `allowed` needs the protected deck list to settle; every other
+ * outcome already decides what the viewer sees.
+ */
+type DeckAccessCheck = "loading" | "allowed" | "denied" | "missing" | "failed";
+
+export function deckAccessCheckFor(query: {
+  data?: { exists: boolean; hasAccess: boolean } | null;
+  isError: boolean;
+  isLoading: boolean;
+}): DeckAccessCheck {
+  if (query.isError) return "failed";
+  if (!query.data) return query.isLoading ? "loading" : "failed";
+  if (!query.data.exists) return "missing";
+  return query.data.hasAccess ? "allowed" : "denied";
+}
+
+export function shouldShowDeckEditorSkeleton({
+  deckFound,
+  decksLoading,
+  orgLoading,
+  accessCheckKey,
+  checkedAccessKey,
+  retrying,
+  accessCheck,
+}: {
+  deckFound: boolean;
+  decksLoading: boolean;
+  orgLoading: boolean;
+  accessCheckKey: string | null;
+  checkedAccessKey: string | null;
+  retrying: boolean;
+  accessCheck: DeckAccessCheck;
+}): boolean {
+  if (deckFound) return false;
+  if (retrying) return true;
+  // The access probe is authoritative even when loading the protected deck
+  // list fails or stays pending, so a denied, missing, or unreadable deck
+  // never waits on the list.
+  if (accessCheck !== "allowed") return accessCheck === "loading";
+  if (decksLoading) return true;
+  if (!accessCheckKey) return false;
+  return orgLoading || checkedAccessKey !== accessCheckKey;
+}
+
+export type DeckAccessRequestState = {
+  status: "idle" | "pending" | "sent" | "failed";
+};
+
+/**
+ * The viewer's access request as the access denied page shows it: a request
+ * sent from this page, else one already on record from an earlier visit. A
+ * request whose owner notification failed stays retryable, because submitting
+ * again is what retries the notification.
+ */
+export function deckAccessRequestStateFor(
+  mutation: {
+    isPending: boolean;
+    isError: boolean;
+    data?: { notifiedOwner: boolean };
+  },
+  recordedRequest: { notifiedOwner: boolean } | null | undefined,
+): DeckAccessRequestState {
+  if (mutation.isPending) return { status: "pending" };
+  const latest = mutation.data ?? (mutation.isError ? null : recordedRequest);
+  if (latest?.notifiedOwner) return { status: "sent" };
+  if (latest || mutation.isError) return { status: "failed" };
+  return { status: "idle" };
+}

package/corpus/templates/slides-2/app/lib/deck-export-file-client.ts

@@ -0,0 +1,77 @@
+import { appBasePath } from "@agent-native/core/client/api-path";
+
+export interface DeckExportFile {
+  blob: Blob;
+  filename: string;
+}
+
+export function deckExportFallbackFilename(
+  deckTitle: string,
+  extension: ".html" | ".pptx",
+): string {
+  const safeTitle = deckTitle.replace(/[^a-zA-Z0-9_-]/g, "-") || "deck";
+  return `${safeTitle}${extension}`;
+}
+
+function filenameFromDisposition(
+  value: string | null,
+  fallbackFilename: string,
+): string {
+  return value?.match(/filename="?([^\"]+)"?/i)?.[1] ?? fallbackFilename;
+}
+
+async function fetchDeckExportFile(
+  format: "html" | "pptx",
+  deckId: string,
+  fallbackError: string,
+  fallbackFilename: string,
+  exportPurpose?: "google_slides",
+): Promise<DeckExportFile> {
+  const response = await fetch(`${appBasePath()}/api/exports/${format}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      deckId,
+      ...(format === "pptx" && exportPurpose ? { exportPurpose } : {}),
+    }),
+  });
+  if (!response.ok) {
+    // coercion-ok: HTTP status records failure; the optional error body may not be JSON.
+    const payload = (await response.json().catch(() => null)) as {
+      error?: string;
+      message?: string;
+    } | null;
+    throw new Error(payload?.error || payload?.message || fallbackError);
+  }
+
+  return {
+    blob: await response.blob(),
+    filename: filenameFromDisposition(
+      response.headers.get("content-disposition"),
+      fallbackFilename,
+    ),
+  };
+}
+
+export function fetchDeckPptxFromServer(
+  deckId: string,
+  fallbackError: string,
+  exportPurpose?: "google_slides",
+  fallbackFilename = "deck.pptx",
+): Promise<DeckExportFile> {
+  return fetchDeckExportFile(
+    "pptx",
+    deckId,
+    fallbackError,
+    fallbackFilename,
+    exportPurpose,
+  );
+}
+
+export function fetchDeckHtmlFromServer(
+  deckId: string,
+  fallbackError: string,
+  fallbackFilename: string,
+): Promise<DeckExportFile> {
+  return fetchDeckExportFile("html", deckId, fallbackError, fallbackFilename);
+}

package/corpus/templates/slides-2/app/lib/deck-filter.ts

@@ -0,0 +1,52 @@
+import { appStorageKey } from "@shared/app-storage";
+
+export const DECK_FILTER_STORAGE_KEY = appStorageKey("deck-filter");
+
+export type DeckFilter = "all" | "mine" | "not-mine";
+
+export function resolveDeckFilter(
+  createdByParam: string | null,
+  storedFilter: DeckFilter | undefined,
+): DeckFilter {
+  if (createdByParam === "me") return "mine";
+  if (createdByParam === "not-me") return "not-mine";
+  if (createdByParam !== null) return "all";
+  return storedFilter ?? "mine";
+}
+
+export function readStoredDeckFilter(
+  storage: Pick<Storage, "getItem"> | null | undefined = typeof window ===
+  "undefined"
+    ? null
+    : window.localStorage,
+): DeckFilter | undefined {
+  if (!storage) return undefined;
+
+  try {
+    const stored = storage.getItem(DECK_FILTER_STORAGE_KEY);
+    return stored === "all" || stored === "mine" || stored === "not-mine"
+      ? stored
+      : undefined;
+  } catch {
+    // coercion-ok: localStorage failures intentionally fall back to the default filter.
+    return undefined;
+  }
+}
+
+export function writeStoredDeckFilter(
+  filter: DeckFilter,
+  storage: Pick<Storage, "setItem"> | null | undefined = typeof window ===
+  "undefined"
+    ? null
+    : window.localStorage,
+): boolean {
+  if (!storage) return false;
+
+  try {
+    storage.setItem(DECK_FILTER_STORAGE_KEY, filter);
+    return true;
+  } catch {
+    // coercion-ok: a non-persisted filter is an acceptable browser-storage fallback.
+    return false;
+  }
+}

package/corpus/templates/slides-2/app/lib/deck-list-loading.ts

@@ -0,0 +1,16 @@
+export type DeckListViewState = "loading" | "error" | "empty" | "decks";
+
+export function deckListViewState({
+  loading,
+  loadError,
+  deckCount,
+}: {
+  loading: boolean;
+  loadError: boolean;
+  deckCount: number;
+}): DeckListViewState {
+  if (loading) return "loading";
+  if (deckCount > 0) return "decks";
+  if (loadError) return "error";
+  return "empty";
+}

package/corpus/templates/slides-2/app/lib/deck-preview-frame.ts

@@ -0,0 +1,15 @@
+import { getAspectRatioDims, type AspectRatio } from "./aspect-ratios";
+
+const LISTING_FRAME_RATIO = 16 / 9;
+
+export function getDeckListingPreviewFrameStyle(aspectRatio?: AspectRatio) {
+  const dimensions = getAspectRatioDims(aspectRatio);
+  const isListingRatio =
+    dimensions.width / dimensions.height >= LISTING_FRAME_RATIO;
+
+  return {
+    aspectRatio: `${dimensions.width} / ${dimensions.height}`,
+    height: "100%",
+    width: isListingRatio ? "100%" : "auto",
+  };
+}

package/corpus/templates/slides-2/app/lib/deck-share-links.ts

@@ -0,0 +1,9 @@
+export type DeckShareLinkKind = "editor" | "presentation";
+
+export function getDeckShareLinkOrder(
+  visibility?: "private" | "org" | "public",
+): { primary: DeckShareLinkKind; secondary: DeckShareLinkKind } {
+  return visibility === "public"
+    ? { primary: "presentation", secondary: "editor" }
+    : { primary: "editor", secondary: "presentation" };
+}

package/corpus/templates/slides-2/app/lib/deck-sorting.ts

@@ -0,0 +1,19 @@
+import type { Deck } from "@/context/DeckContext";
+
+type DeckDates = Pick<Deck, "createdAt" | "updatedAt">;
+
+function parseDate(value: string | undefined): number | null {
+  if (!value) return null;
+  const timestamp = Date.parse(value);
+  return Number.isNaN(timestamp) ? null : timestamp;
+}
+
+export function getDeckRecency(deck: DeckDates): number {
+  return parseDate(deck.updatedAt) ?? parseDate(deck.createdAt) ?? 0;
+}
+
+export function sortDecksByRecency<T extends DeckDates>(decks: T[]): T[] {
+  return [...decks].sort(
+    (first, second) => getDeckRecency(second) - getDeckRecency(first),
+  );
+}

package/corpus/templates/slides-2/app/lib/deferred-editor-surfaces.ts

@@ -0,0 +1,24 @@
+import { lazy } from "react";
+
+let addSlidePopoverModule:
+  | Promise<typeof import("@/components/editor/AddSlidePopover")>
+  | undefined;
+
+function loadAddSlidePopover() {
+  addSlidePopoverModule ??= import("@/components/editor/AddSlidePopover").catch(
+    (error) => {
+      addSlidePopoverModule = undefined;
+      throw error;
+    },
+  );
+  return addSlidePopoverModule;
+}
+
+export function preloadAddSlidePopover() {
+  void loadAddSlidePopover().catch(() => {});
+}
+
+export const DeferredAddSlidePopover = lazy(async () => {
+  const module = await loadAddSlidePopover();
+  return { default: module.AddSlidePopover };
+});

package/corpus/templates/slides-2/app/lib/design-system-selection.ts

@@ -0,0 +1,11 @@
+export interface SelectableDesignSystem {
+  id: string;
+}
+
+export function resolveSelectableDesignSystemId(
+  designSystems: SelectableDesignSystem[],
+  candidateId: string | null | undefined,
+): string | null {
+  if (!candidateId) return null;
+  return designSystems.some((ds) => ds.id === candidateId) ? candidateId : null;
+}