@agent-native/core-corpus 0.213.1 → 0.216.0

package/corpus/templates/slides-2/shared/api.ts

@@ -0,0 +1,406 @@
+import type { RevealUnresolvedReason } from "../app/lib/slide-animation-elements";
+import {
+  normalizeSlideTransition,
+  SLIDE_TRANSITION_INPUTS,
+  SLIDE_TRANSITION_SPEED,
+  type SlideTransitionType,
+} from "./slide-transitions";
+
+export interface DemoResponse {
+  message: string;
+}
+
+export const DEFAULT_STYLE_REFERENCE_URLS: string[] = [];
+
+export function normalizeReferenceUrls(
+  urls: readonly string[] | null | undefined,
+): string[] {
+  const normalized: string[] = [];
+  for (const url of urls ?? []) {
+    if (typeof url !== "string") continue;
+    const trimmed = url.trim();
+    if (!trimmed || normalized.includes(trimmed)) continue;
+    normalized.push(trimmed);
+  }
+  return normalized;
+}
+
+export type ImageGenModel = "gemini" | "openai" | "auto";
+
+export interface ImageGenRequest {
+  prompt: string;
+  model: ImageGenModel;
+  size?: string;
+  referenceImageUrls?: string[];
+  uploadedReferenceImages?: string[];
+}
+
+export interface ImageGenStatusResponse {
+  gemini: boolean;
+  openai: boolean;
+  preferredProvider: string | null;
+}
+
+export interface SlideGenerateRequest {
+  topic: string;
+  slideCount?: number;
+  style?: string;
+  includeImages?: boolean;
+  referenceImageUrls?: string[];
+  uploadedReferenceImages?: string[];
+}
+
+export interface GeneratedSlide {
+  content: string;
+  layout: "title" | "content" | "two-column" | "image" | "blank";
+  notes: string;
+  background?: string;
+  imagePrompt?: string;
+}
+
+export interface SlideGenerateResponse {
+  slides: GeneratedSlide[];
+}
+
+export interface ShareDeckRequest {
+  deck: {
+    id: string;
+    title: string;
+    slides: SharedDeckSlide[];
+  };
+}
+
+export interface ShareDeckResponse {
+  shareToken: string;
+}
+
+export interface SharedDeckResponse {
+  title: string;
+  slides: SharedDeckSlide[];
+  aspectRatio?: import("./aspect-ratios").AspectRatio;
+  designSystem?: DesignSystemData;
+}
+
+export type SharedAnimationType = "appear" | "fade" | "slide-up" | "zoom";
+
+export type SharedAnimationIssueCode =
+  | "invalid-shape"
+  | "invalid-element-path"
+  | "missing-target"
+  | "unsupported-type"
+  | RevealUnresolvedReason;
+
+export interface SharedSlideAnimationIssue {
+  index: number;
+  id: string | null;
+  code: SharedAnimationIssueCode;
+}
+
+export const ANIMATION_TRIGGERS = ["on-click", "with-previous"] as const;
+export type AnimationTrigger = (typeof ANIMATION_TRIGGERS)[number];
+
+export function isAnimationTrigger(value: unknown): value is AnimationTrigger {
+  return (ANIMATION_TRIGGERS as readonly unknown[]).includes(value);
+}
+
+export interface SharedSlideAnimation {
+  id: string;
+  elementIndex: number;
+  elementPath?: number[];
+  byParagraph?: boolean;
+  trigger?: AnimationTrigger;
+  type: SharedAnimationType;
+}
+
+export interface SharedDeckSlide {
+  id: string;
+  content: string;
+  sourceRuntimeRequired?: boolean;
+  notes: string;
+  layout: string;
+  background?: string;
+  transition?: SlideTransitionType;
+  transitionSpeed?: number;
+  animations?: SharedSlideAnimation[];
+  animationIssues?: SharedSlideAnimationIssue[];
+  splitByParagraph?: boolean;
+}
+
+export interface SharedDeckSlideOptions {
+  includeNotes?: boolean;
+  /**
+   * Reveal resolution issues for this slide, computed on the server by
+   * slideRevealIssues. Resolving needs the parsed .fmd-slide, which this
+   * module does not parse, so the caller passes the result in.
+   */
+  revealIssues?: SharedSlideAnimationIssue[];
+}
+
+const SHARED_ANIMATION_TYPES = new Set<SharedAnimationType>([
+  "appear",
+  "fade",
+  "slide-up",
+  "zoom",
+]);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function normalizeString(value: unknown, fallback: string): string {
+  return typeof value === "string" ? value : fallback;
+}
+
+function normalizeElementPath(value: unknown): number[] | undefined {
+  if (!Array.isArray(value) || value.length === 0) return undefined;
+  const path = value.filter(
+    (part): part is number =>
+      typeof part === "number" &&
+      Number.isInteger(part) &&
+      Number.isFinite(part) &&
+      part >= 0,
+  );
+  return path.length === value.length ? path : undefined;
+}
+
+function normalizeSlideAnimation(
+  value: unknown,
+  index: number,
+): { animation: SharedSlideAnimation } | { issue: SharedSlideAnimationIssue } {
+  const id = isRecord(value) && typeof value.id === "string" ? value.id : null;
+  const issue = (code: SharedAnimationIssueCode) => ({
+    issue: { index, id, code },
+  });
+
+  if (!isRecord(value)) return issue("invalid-shape");
+
+  const elementPath = normalizeElementPath(value.elementPath);
+  if (value.elementPath !== undefined && !elementPath) {
+    return issue("invalid-element-path");
+  }
+  const rawElementIndex = value.elementIndex;
+  const hasElementIndex =
+    typeof rawElementIndex === "number" &&
+    Number.isInteger(rawElementIndex) &&
+    Number.isFinite(rawElementIndex) &&
+    rawElementIndex >= 0;
+
+  if (!hasElementIndex && !elementPath) return issue("missing-target");
+
+  const rawType = value.type;
+  if (!SHARED_ANIMATION_TYPES.has(rawType as SharedAnimationType)) {
+    return issue("unsupported-type");
+  }
+  const type = rawType as SharedAnimationType;
+  const byParagraph =
+    typeof value.byParagraph === "boolean" ? value.byParagraph : undefined;
+  const trigger = isAnimationTrigger(value.trigger) ? value.trigger : undefined;
+
+  const resolvedElementIndex = hasElementIndex
+    ? rawElementIndex
+    : (elementPath![elementPath!.length - 1] ?? 0);
+
+  return {
+    animation: {
+      id: normalizeString(value.id, `animation-${index + 1}`),
+      elementIndex: resolvedElementIndex,
+      ...(elementPath ? { elementPath } : {}),
+      ...(byParagraph !== undefined ? { byParagraph } : {}),
+      ...(trigger ? { trigger } : {}),
+      type,
+    },
+  };
+}
+
+export interface NormalizedSharedSlideAnimations {
+  animations: SharedSlideAnimation[];
+  /** The stored position of each kept animation, parallel to `animations`. */
+  storedIndices: number[];
+  /** Structural rejects only; reveal resolution is a separate pass. */
+  issues: SharedSlideAnimationIssue[];
+}
+
+export function normalizeSharedSlideAnimations(
+  values: readonly unknown[],
+): NormalizedSharedSlideAnimations {
+  const animations: SharedSlideAnimation[] = [];
+  const storedIndices: number[] = [];
+  const issues: SharedSlideAnimationIssue[] = [];
+  values.forEach((value, storedIndex) => {
+    const result = normalizeSlideAnimation(value, storedIndex);
+    if ("animation" in result) {
+      animations.push(result.animation);
+      storedIndices.push(storedIndex);
+    } else {
+      issues.push(result.issue);
+    }
+  });
+  return { animations, storedIndices, issues };
+}
+
+export function toSharedDeckSlide(
+  value: unknown,
+  index: number,
+  options: SharedDeckSlideOptions = {},
+): SharedDeckSlide {
+  const slide = isRecord(value) ? value : {};
+  const shared: SharedDeckSlide = {
+    id: normalizeString(slide.id, `slide-${index + 1}`),
+    content: normalizeString(slide.content, ""),
+    notes: options.includeNotes ? normalizeString(slide.notes, "") : "",
+    layout: normalizeString(slide.layout, "content"),
+  };
+
+  if (
+    typeof slide.sourceTsx === "string" &&
+    slide.sourceTsx.trim() &&
+    !shared.content.trim()
+  ) {
+    shared.sourceRuntimeRequired = true;
+  }
+
+  if (typeof slide.background === "string") {
+    shared.background = slide.background;
+  }
+
+  // Membership gates the value before normalizing. A key lookup in the legacy
+  // map alone would also accept inherited names such as "toString".
+  if (
+    (SLIDE_TRANSITION_INPUTS as readonly unknown[]).includes(slide.transition)
+  ) {
+    shared.transition = normalizeSlideTransition(slide.transition);
+  }
+
+  const transitionSpeed = slide.transitionSpeed;
+  if (
+    typeof transitionSpeed === "number" &&
+    Number.isInteger(transitionSpeed) &&
+    transitionSpeed >= SLIDE_TRANSITION_SPEED.min &&
+    transitionSpeed <= SLIDE_TRANSITION_SPEED.max
+  ) {
+    shared.transitionSpeed = transitionSpeed;
+  }
+
+  if (typeof slide.splitByParagraph === "boolean") {
+    shared.splitByParagraph = slide.splitByParagraph;
+  }
+
+  if (Array.isArray(slide.animations)) {
+    const { animations, issues } = normalizeSharedSlideAnimations(
+      slide.animations,
+    );
+    if (animations.length > 0) shared.animations = animations;
+    // Unresolved reveals stay in `animations`; their reasons arrive as
+    // options.revealIssues, keyed by stored position.
+    const animationIssues = [...issues, ...(options.revealIssues ?? [])];
+    if (animationIssues.length > 0) {
+      shared.animationIssues = animationIssues.sort(
+        (a, b) => a.index - b.index,
+      );
+    }
+  }
+
+  return shared;
+}
+
+export interface DeckVersionSlidePreview {
+  slideNumber: number;
+  id: string | null;
+  layout: string | null;
+  textPreview: string;
+}
+
+export interface DeckVersionSummary {
+  id: string;
+  deckId: string;
+  title: string;
+  label: string | null;
+  createdAt: string;
+  slideCount: number;
+  aspectRatio: import("./aspect-ratios").AspectRatio | null;
+  designSystemId: string | null;
+  slidePreviews: DeckVersionSlidePreview[];
+}
+
+export interface DeckVersionListResponse {
+  deckId: string;
+  count: number;
+  versions: DeckVersionSummary[];
+}
+
+export interface DeckVersion extends DeckVersionSummary {
+  data: Record<string, unknown>;
+  slides: Array<{
+    id: string;
+    content: string;
+    notes?: string;
+    layout?: string;
+    background?: string;
+  }>;
+}
+
+export interface DesignSystemData {
+  colors: {
+    primary: string;
+    secondary: string;
+    accent: string;
+    background: string;
+    surface: string;
+    text: string;
+    textMuted: string;
+  };
+  typography: {
+    headingFont: string;
+    bodyFont: string;
+    headingWeight: string;
+    bodyWeight: string;
+    headingSizes: { h1: string; h2: string; h3: string };
+  };
+  spacing: { slidePadding: string; elementGap: string };
+  borders: { radius: string; accentWidth: string };
+  slideDefaults: {
+    background: string;
+    labelStyle: "uppercase" | "lowercase" | "capitalize" | "none";
+  };
+  logos: { url: string; name: string; variant: "light" | "dark" | "auto" }[];
+  imageStyle?: {
+    referenceUrls: string[];
+    styleDescription: string;
+  };
+  customCSS?: string;
+  notes?: string;
+}
+
+export interface DesignSystemAsset {
+  id: string;
+  name: string;
+  type: "logo" | "font" | "image" | "icon";
+  url: string;
+  mimeType: string;
+}
+
+export interface QuestionFlowQuestion {
+  id: string;
+  type: "text-options" | "color-options" | "slider" | "file" | "freeform";
+  header?: string;
+  question: string;
+  description?: string;
+  options?: {
+    label: string;
+    value: string;
+    color?: string;
+    icon?: string;
+    description?: string;
+    recommended?: boolean;
+  }[];
+  choices?: QuestionFlowQuestion["options"];
+  multiSelect?: boolean;
+  min?: number;
+  max?: number;
+  step?: number;
+  required?: boolean;
+  placeholder?: string;
+  allowOther?: boolean;
+  includeExplore?: boolean;
+  includeDecide?: boolean;
+}

package/corpus/templates/slides-2/shared/app-state-tabs.ts

@@ -0,0 +1,30 @@
+const SAFE_TAB_ID_RE = /^[A-Za-z0-9_-]{1,96}$/;
+
+export const SLIDES_2_APP_ID = "slides-2";
+
+const APP_STATE_PREFIX = `${SLIDES_2_APP_ID}:`;
+
+export function normalizeBrowserTabId(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return SAFE_TAB_ID_RE.test(trimmed) ? trimmed : null;
+}
+
+export function appStateKey(key: string): string {
+  if (key === "navigation" || key.startsWith(APP_STATE_PREFIX)) return key;
+  return `${APP_STATE_PREFIX}${key}`;
+}
+
+export function appStateKeyForBrowserTab(
+  key: string,
+  browserTabId: unknown,
+): string {
+  const normalized = normalizeBrowserTabId(browserTabId);
+  if (key === "navigation") {
+    return normalized
+      ? `${APP_STATE_PREFIX}navigation:${normalized}`
+      : `${APP_STATE_PREFIX}navigation`;
+  }
+  const namespacedKey = appStateKey(key);
+  return normalized ? `${namespacedKey}:${normalized}` : namespacedKey;
+}

package/corpus/templates/slides-2/shared/app-storage.ts

@@ -0,0 +1,9 @@
+import { SLIDES_2_APP_ID } from "./app-state-tabs";
+
+const APP_STORAGE_PREFIX = `${SLIDES_2_APP_ID}:`;
+
+export function appStorageKey(key: string): string {
+  return key.startsWith(APP_STORAGE_PREFIX)
+    ? key
+    : `${APP_STORAGE_PREFIX}${key}`;
+}

package/corpus/templates/slides-2/shared/aspect-ratios.ts

@@ -0,0 +1,49 @@
+export const ASPECT_RATIOS = {
+  "16:9": {
+    width: 960,
+    height: 540,
+    label: "16:9",
+    pptxInches: { w: 13.33, h: 7.5 },
+  },
+  "1:1": {
+    width: 1080,
+    height: 1080,
+    label: "1:1",
+    pptxInches: { w: 10, h: 10 },
+  },
+  "9:16": {
+    width: 540,
+    height: 960,
+    label: "9:16",
+    pptxInches: { w: 7.5, h: 13.33 },
+  },
+  "4:5": {
+    width: 864,
+    height: 1080,
+    label: "4:5",
+    pptxInches: { w: 8, h: 10 },
+  },
+  "4:3": {
+    width: 960,
+    height: 720,
+    label: "4:3",
+    pptxInches: { w: 10, h: 7.5 },
+  },
+} as const;
+
+export type AspectRatio = keyof typeof ASPECT_RATIOS;
+export const ASPECT_RATIO_VALUES = [
+  "16:9",
+  "1:1",
+  "9:16",
+  "4:5",
+  "4:3",
+] as const;
+export const DEFAULT_ASPECT_RATIO: AspectRatio = "16:9";
+
+export function getAspectRatioDims(ratio: AspectRatio | undefined | null) {
+  if (ratio && Object.prototype.hasOwnProperty.call(ASPECT_RATIOS, ratio)) {
+    return ASPECT_RATIOS[ratio];
+  }
+  return ASPECT_RATIOS[DEFAULT_ASPECT_RATIO];
+}

package/corpus/templates/slides-2/shared/blank-slide.ts

@@ -0,0 +1,179 @@
+import { parseHTML } from "linkedom/worker";
+
+export function stripHtml(html: string): string {
+  return html
+    .replace(/<br\s*\/?>/gi, "\n")
+    .replace(/<[^>]+>/g, " ")
+    .replace(/&[a-z]+;/gi, " ")
+    .replace(/&#x[0-9a-f]+;/gi, "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function hasVisibleBackgroundClass(html: string): boolean {
+  const { document } = parseHTML(html);
+  const attributeMatches = (
+    type: string,
+    value: string | null | undefined,
+    expected: string,
+  ) =>
+    type.toLowerCase() === "aria"
+      ? value?.toLowerCase() === expected.toLowerCase()
+      : value === expected;
+
+  return Array.from(document.querySelectorAll("*")).some((element) => {
+    const classNames =
+      element.getAttribute("class") ?? element.getAttribute("className") ?? "";
+    return classNames.split(/\s+/).some((className) => {
+      const variants =
+        className.match(
+          /^(?:(?:[\w-]+(?:-\[[^\]]+\])?(?:\/[\w-]+)?|\[[^\]]+\]):)+/,
+        )?.[0] ?? "";
+      const variantNames =
+        variants.slice(0, -1).match(/(?:\[[^\]]*\]|[^:])+/g) ?? [];
+      const hasInactiveState = variantNames.some((variant) => {
+        const selectorVariant = variant.match(/^(has|not)-\[(.+)\]$/i);
+        if (selectorVariant) {
+          const [, mode, selector] = selectorVariant;
+          let matches: boolean;
+          try {
+            matches =
+              mode.toLowerCase() === "has"
+                ? element.matches(`:has(${selector.replaceAll("_", " ")})`)
+                : element.matches(selector.replaceAll("_", " "));
+          } catch {
+            // coercion-ok: invalid variants stay active.
+            return false;
+          }
+          return mode.toLowerCase() === "has" ? !matches : matches;
+        }
+
+        const relatedAttribute = variant.match(
+          /^(group|peer)-(aria|data)-\[([\w-]+)=([^\]]+)\](?:\/([\w-]+))?$/i,
+        );
+        if (relatedAttribute) {
+          const [
+            ,
+            relation,
+            attributeType,
+            attributeName,
+            rawExpected,
+            relationName,
+          ] = relatedAttribute;
+          const attributeNameWithType = `${attributeType}-${attributeName}`;
+          const relationClass = `${relation.toLowerCase()}${relationName ? `/${relationName}` : ""}`;
+          const expected = rawExpected.replace(/^['"]|['"]$/g, "");
+          const matches = (candidate: Element | null | undefined) =>
+            attributeMatches(
+              attributeType,
+              candidate?.getAttribute(attributeNameWithType),
+              expected,
+            );
+          if (relation.toLowerCase() === "group") {
+            for (
+              let ancestor = element.parentElement;
+              ancestor;
+              ancestor = ancestor.parentElement
+            ) {
+              if (
+                ancestor.classList.contains(relationClass) &&
+                matches(ancestor)
+              ) {
+                return false;
+              }
+            }
+            return true;
+          }
+
+          for (
+            let sibling = element.previousElementSibling;
+            sibling;
+            sibling = sibling.previousElementSibling
+          ) {
+            if (sibling.classList.contains(relationClass) && matches(sibling)) {
+              return false;
+            }
+          }
+          return true;
+        }
+
+        // ponytail: dynamic group/peer pseudo states remain unknown; extend related-node checks as needed.
+        if (
+          /^(?:hover|focus(?:-visible|-within)?|active|visited|disabled|enabled|checked|indeterminate|required|optional|valid|invalid|in-range|out-of-range|placeholder-shown|autofill|read-only|read-write|open|modal|fullscreen|target|group-.+|peer-.+|has-.+|not-.+)$/i.test(
+            variant,
+          )
+        ) {
+          return true;
+        }
+
+        const aria = variant.match(/^aria-([\w-]+)$/i);
+        if (aria) {
+          const name = `aria-${aria[1]}`;
+          const expected =
+            aria[1].toLowerCase() === "current" ? "page" : "true";
+          return !attributeMatches(
+            "aria",
+            element.getAttribute(name),
+            expected,
+          );
+        }
+
+        const attribute = variant.match(/^(aria|data)-\[([\w-]+)=([^\]]+)\]$/i);
+        if (attribute) {
+          const name = `${attribute[1]}-${attribute[2]}`;
+          const expected = attribute[3].replace(/^['"]|['"]$/g, "");
+          return !attributeMatches(
+            attribute[1],
+            element.getAttribute(name),
+            expected,
+          );
+        }
+
+        return /^(?:aria|data)-/i.test(variant);
+      });
+      if (hasInactiveState) {
+        return false;
+      }
+      return /^bg-(?!(?:none|transparent)(?:\/|$)|opacity-|clip-|origin-|blend-|repeat(?:-|\/|$)|size-|position-|attachment-|(?:auto|cover|contain|fixed|local|scroll|center|top|bottom|left|right|no-repeat)(?:\/|$))\S+/i.test(
+        className.slice(variants.length),
+      );
+    });
+  });
+}
+
+export function isBlankSlideContent(html: string): boolean {
+  if (stripHtml(html)) return false;
+  return !(
+    hasVisibleBackgroundClass(html) ||
+    /<(?:img|svg|video|canvas|table|iframe|object|embed)\b|data-slide-object-id|fmd-img-placeholder/i.test(
+      html,
+    ) ||
+    /(?:background(?:-color|-image)?|border(?:-(?:top|right|bottom|left))?(?:-(?:width|style|color))?|box-shadow)\s*:\s*(?!none\b|transparent\b)/i.test(
+      html,
+    )
+  );
+}
+
+// SlideRenderer draws a parsed excalidrawData with elements instead of the
+// slide's HTML, so such a slide is real whatever its content says.
+function hasExcalidrawElements(data: unknown): boolean {
+  if (typeof data !== "string") return false;
+  try {
+    const elements = JSON.parse(data)?.elements;
+    return Array.isArray(elements) && elements.length > 0;
+  } catch {
+    // coercion-ok: the renderer also falls back to content on unparseable data.
+    return false;
+  }
+}
+
+export function isRealSlide(slide: unknown): boolean {
+  const { content, excalidrawData } = (slide ?? {}) as {
+    content?: unknown;
+    excalidrawData?: unknown;
+  };
+  return (
+    hasExcalidrawElements(excalidrawData) ||
+    !isBlankSlideContent(typeof content === "string" ? content : "")
+  );
+}

package/corpus/templates/slides-2/shared/client-compatibility.ts

@@ -0,0 +1,2 @@
+// Bump when changing required browser action payload fields.
+export const CLIENT_COMPATIBILITY_VERSION = "slides-write-v1";