@aperture-browser/session-react 0.0.0-init.0

package/dist/headless.d.ts

@@ -0,0 +1,313 @@
+import { CSSProperties, DependencyList, ReactNode } from "react";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import { BrowserInputMessage, CollaborationCursor, CollaborationError, CollaborationLeaseMode, CollaborationPaintEvent, CollaborationPaintPoint, CollaborationParticipant, CollaborationPhase, CollaborationRole, CollaborationRole as CollaborationRole$1, LiveSessionCommandResult, LiveSessionConnection, LiveSessionError, LiveSessionError as LiveSessionError$1, LiveSessionPresentation, LiveSessionPresentationQuality, LiveSessionRasterFrame, LiveSessionTarget, ViewportPreset } from "@aperture-browser/live-session";
+import { ApiCredentials, ApiServices, BrowserStatus, IceServer, Recording } from "@aperture-browser/api-client";
+import * as ManagedRuntime from "effect/ManagedRuntime";
+
+//#region src/hooks/use-live-session.d.ts
+interface InputDimensions {
+  width: number;
+  height: number;
+}
+interface LiveSessionMediaSize {
+  width: number;
+  height: number;
+  deviceScaleFactor: number;
+  canvasWidth: number;
+  canvasHeight: number;
+}
+type LiveSessionMediaSelection = {
+  kind: "jpeg";
+} | {
+  kind: "webrtc";
+  quality: LiveSessionPresentationQuality;
+} | {
+  kind: "webrtc-retry";
+};
+interface CollaborationControl {
+  phase: CollaborationPhase;
+  role: CollaborationRole;
+  clientId: string;
+  holderClientId: string | null;
+  leaseMode: CollaborationLeaseMode | null;
+  hasControl: boolean;
+  canRequestControl: boolean;
+  lastError: CollaborationError | null;
+  participants: readonly CollaborationParticipant[];
+  cursors: ReadonlyMap<string, CollaborationCursor>;
+  paintEvents: Stream.Stream<CollaborationPaintEvent>;
+  followingClientId: string | null;
+  claim: (targetId: string, mode: CollaborationLeaseMode) => boolean;
+  release: () => boolean;
+  setActiveTarget: (targetId: string | null) => boolean;
+  follow: (clientId: string | null) => boolean;
+  sendCursor: (targetId: string, x: number, y: number, dimensions: InputDimensions) => boolean;
+  sendPaintPoint: (point: CollaborationPaintPoint) => boolean;
+  clearCursor: () => boolean;
+  sendInput: (message: BrowserInputMessage, dimensions: InputDimensions) => boolean;
+}
+interface UseLiveSessionOptions {
+  sessionId: string | null;
+  displayName?: string | null;
+  credentials: ApiCredentials | null;
+  sessionToken?: string;
+  role: CollaborationRole;
+  enabled: boolean;
+  webrtcSupported: boolean;
+  iceServers: readonly IceServer[];
+}
+interface LiveSessionControl {
+  phase: "idle" | "connecting" | "connected" | "disconnected" | "error";
+  targets: readonly LiveSessionTarget[];
+  activeTargetId: string | null;
+  /** The newest raster frame, starting with the current one. */
+  frames: Stream.Stream<LiveSessionRasterFrame | null>;
+  mediaStream: MediaStream | null;
+  mediaSize: LiveSessionMediaSize | null;
+  transport: "webrtc" | "websocket" | null;
+  presentation: LiveSessionPresentation | null;
+  mediaSwitching: boolean;
+  recordings: readonly Recording[];
+  collaboration: CollaborationControl;
+  sendBrowserInput: (message: BrowserInputMessage, dimensions: InputDimensions) => boolean;
+  selectTarget: (targetId: string) => boolean;
+  requestSelectTarget: (targetId: string) => Effect.Effect<void, LiveSessionConnection.LiveSessionError>;
+  command: (type: string, payload?: Record<string, unknown>) => boolean;
+  request: (type: string, payload?: Record<string, unknown>) => Effect.Effect<LiveSessionCommandResult, LiveSessionConnection.LiveSessionError>;
+  selectPresentation: (selection: LiveSessionMediaSelection) => Effect.Effect<void, LiveSessionConnection.LiveSessionError>;
+  reconnect: () => void;
+}
+declare const collaborationPaintLifetimeMs = 7000;
+declare function useLiveSession({
+  sessionId,
+  displayName,
+  credentials,
+  sessionToken,
+  role,
+  enabled,
+  webrtcSupported,
+  iceServers
+}: UseLiveSessionOptions): LiveSessionControl;
+//#endregion
+//#region src/hooks/use-browser-control.d.ts
+interface SessionNotice {
+  readonly level: "error" | "success";
+  readonly message: string;
+}
+interface UseBrowserControlOptions {
+  sessionId: string | null;
+  credentials: ApiCredentials | null;
+  displayName?: string | null;
+  sessionToken?: string;
+  collaborationRole?: CollaborationRole$1;
+  enabled?: boolean;
+  webrtcProducerSupported?: boolean;
+  webrtcIceServers?: readonly IceServer[];
+  onNotice?: (notice: SessionNotice) => void;
+}
+interface BrowserViewportSize {
+  width: number;
+  height: number;
+}
+interface BrowserCommands {
+  readonly navigate: (url: string) => Effect.Effect<void, LiveSessionError$1>;
+  readonly historyBack: () => Effect.Effect<void, LiveSessionError$1>;
+  readonly historyForward: () => Effect.Effect<void, LiveSessionError$1>;
+  readonly reload: (targetId?: string) => Effect.Effect<void, LiveSessionError$1>;
+  readonly stopLoading: () => Effect.Effect<void, LiveSessionError$1>;
+  readonly createTarget: (url?: string) => Effect.Effect<string | null, LiveSessionError$1>;
+  readonly closeTarget: (targetId: string) => Effect.Effect<void, LiveSessionError$1>;
+  readonly activateTarget: (targetId: string) => Effect.Effect<void, LiveSessionError$1>;
+}
+type BrowserMediaPath = "webrtc-live" | "websocket-live";
+type BrowserMediaPhase = "idle" | "connecting" | "live" | "failed";
+interface UseBrowserControlResult {
+  phase: LiveSessionControl["phase"];
+  targets: readonly LiveSessionTarget[];
+  activeTargetId: string | null;
+  activeTarget: LiveSessionTarget | null;
+  frames: Stream.Stream<LiveSessionRasterFrame | null>;
+  mediaPhase: BrowserMediaPhase;
+  mediaStream: MediaStream | null;
+  mediaStreamSettings: LiveSessionPresentationQuality | null;
+  mediaVideoProfiles: LiveSessionPresentation["profiles"];
+  mediaSize: {
+    width: number;
+    height: number;
+    deviceScaleFactor: number;
+    canvasWidth: number;
+    canvasHeight: number;
+  } | null;
+  mediaPath: BrowserMediaPath;
+  mediaTargetId: string | null;
+  mediaSwitching: boolean;
+  viewport: ViewportPreset;
+  browserViewportSize: BrowserViewportSize | null;
+  viewportAutoSync: boolean;
+  captured: boolean;
+  recordings: readonly Recording[];
+  recordingBusy: boolean;
+  remoteCursorEnabled: boolean;
+  collaboration: CollaborationControl;
+  commands: BrowserCommands;
+  setCaptured: (captured: boolean) => void;
+  setInputDimensions: (size: BrowserViewportSize) => void;
+  setViewport: (viewport: ViewportPreset) => void;
+  setBrowserViewportSize: (size: BrowserViewportSize) => void;
+  setViewportAutoSync: (enabled: boolean) => void;
+  setViewportToBrowserSize: () => void;
+  setWebRTCStreamSettings: (settings: LiveSessionPresentationQuality) => boolean;
+  selectMediaStream: (selection: LiveSessionMediaSelection) => boolean;
+  sendInput: (message: BrowserInputMessage) => boolean;
+  activateTarget: (targetId: string) => void;
+  reorderTargets: (sourceTargetId: string, destinationTargetId: string, placement: "before" | "after") => void;
+  createTarget: (url?: string) => void;
+  duplicateTarget: (target: LiveSessionTarget) => void;
+  closeTarget: (targetId: string) => void;
+  navigate: (url: string) => void;
+  reload: (targetId: string) => void;
+  stopLoading: () => void;
+  historyBack: () => void;
+  historyForward: () => void;
+  startRecording: (mode: "tab" | "viewer") => void;
+  stopRecording: (recordingId: string) => void;
+  cancelRecording: (recordingId: string) => void;
+  setRemoteCursorEnabled: (enabled: boolean) => void;
+  reconnect: () => void;
+}
+declare function useBrowserControl({
+  sessionId,
+  credentials,
+  displayName,
+  sessionToken,
+  collaborationRole,
+  enabled,
+  webrtcProducerSupported,
+  webrtcIceServers,
+  onNotice
+}: UseBrowserControlOptions): UseBrowserControlResult;
+//#endregion
+//#region src/components/session-viewport.d.ts
+interface SessionViewportProps {
+  control: UseBrowserControlResult;
+  viewport?: ViewportPreset;
+  localCursorEnabled?: boolean;
+  paintingEnabled?: boolean;
+  onPaintingEnabledChange?: (enabled: boolean) => void;
+  onNotice?: (notice: SessionNotice) => void;
+  className?: string;
+  style?: CSSProperties;
+  renderOverlay?: (overlay: SessionViewportOverlay) => ReactNode;
+}
+type SessionViewportStatus = "webrtc" | "websocket" | "offline";
+type SessionViewportPlaceholder = "connecting" | "connecting-media" | "switching" | "disconnected" | "waiting";
+interface SessionViewportOverlay {
+  readonly status: SessionViewportStatus;
+  readonly placeholder: SessionViewportPlaceholder | null;
+  readonly cursorHint: {
+    readonly text: string;
+    readonly x: number;
+    readonly y: number;
+  } | null;
+  readonly followedCursor: {
+    readonly name: string;
+    readonly x: number;
+    readonly y: number;
+  } | null;
+  readonly collaborationError: string | null;
+}
+declare function SessionViewport({
+  control,
+  viewport,
+  localCursorEnabled,
+  paintingEnabled,
+  onPaintingEnabledChange,
+  onNotice,
+  className,
+  style,
+  renderOverlay
+}: SessionViewportProps): import("react").JSX.Element;
+//#endregion
+//#region src/runtime.d.ts
+type ApertureRuntime = ManagedRuntime.ManagedRuntime<ApiServices, never>;
+interface ApertureRuntimeOptions {
+  readonly baseUrl?: string;
+}
+declare const makeApertureRuntime: (options?: ApertureRuntimeOptions) => ApertureRuntime;
+//#endregion
+//#region src/effect.d.ts
+declare const RuntimeProviderMissingError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "RuntimeProviderMissingError";
+} & Readonly<A>;
+/** A hook below needed the app runtime, but no RuntimeProvider is above the component. */
+declare class RuntimeProviderMissingError extends RuntimeProviderMissingError_base {
+  readonly message = "useRuntime must be used inside RuntimeProvider";
+}
+declare function RuntimeProvider({
+  runtime,
+  baseUrl,
+  children
+}: {
+  runtime: ApertureRuntime;
+  baseUrl?: string;
+  children: ReactNode;
+}): import("react").JSX.Element;
+declare function useRuntime(): ApertureRuntime;
+declare function useBaseUrl(): string | undefined;
+/**
+ * Runs an effect while the component is mounted, restarting it when `deps` change, like
+ * `useEffect`. Return `undefined` to run nothing. The fiber is interrupted synchronously
+ * on cleanup, so its synchronous finalizers have run before the next effect starts.
+ */
+declare function useFork(effect: () => Effect.Effect<unknown, never, ApiServices> | undefined, deps: DependencyList): void;
+/**
+ * Returns an event handler that forks the effect `callback` builds. Fibers still running
+ * when the component unmounts are interrupted.
+ */
+declare function useEffectCallback<Args extends ReadonlyArray<unknown>>(callback: (...args: Args) => Effect.Effect<unknown, never, ApiServices>, deps: DependencyList): (...args: Args) => void;
+/**
+ * Returns a function that runs an API call for promise-based callers such as TanStack
+ * Query. Aborting the signal interrupts the request.
+ */
+declare function useRunApi(): <A, E>(call: Effect.Effect<A, E, ApiServices>, options?: {
+  readonly signal?: AbortSignal;
+}) => Promise<A>;
+//#endregion
+//#region src/provider.d.ts
+interface ApertureProviderProps {
+  readonly baseUrl?: string;
+  readonly children?: ReactNode;
+}
+declare function ApertureProvider({
+  baseUrl,
+  children
+}: ApertureProviderProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/shared-session.d.ts
+interface ShareToken {
+  readonly token: string;
+  readonly sessionId: string;
+  readonly role: "editor" | "viewer";
+}
+declare function parseShareToken(token: string): ShareToken | null;
+type SharedSessionStatus = "invalid" | "loading" | "expired" | "unavailable" | "ready";
+interface UseSharedSessionOptions {
+  readonly token: string;
+  readonly displayName?: string | null;
+  readonly onNotice?: (notice: SessionNotice) => void;
+}
+interface UseSharedSessionResult {
+  readonly status: SharedSessionStatus;
+  readonly share: ShareToken | null;
+  readonly browser: BrowserStatus | null;
+  readonly control: UseBrowserControlResult;
+}
+declare function useSharedSession({
+  token,
+  displayName,
+  onNotice
+}: UseSharedSessionOptions): UseSharedSessionResult;
+//#endregion
+export { ApertureProvider, ApertureProviderProps, ApertureRuntime, ApertureRuntimeOptions, BrowserCommands, BrowserMediaPath, BrowserMediaPhase, CollaborationControl, type CollaborationCursor, type CollaborationError, type CollaborationLeaseMode, type CollaborationPaintEvent, type CollaborationPaintPoint, type CollaborationParticipant, type CollaborationPhase, type CollaborationRole, LiveSessionControl, LiveSessionError, LiveSessionMediaSelection, LiveSessionMediaSize, RuntimeProvider, RuntimeProviderMissingError, SessionNotice, SessionViewport, SessionViewportOverlay, SessionViewportPlaceholder, SessionViewportProps, SessionViewportStatus, ShareToken, SharedSessionStatus, UseBrowserControlResult, UseSharedSessionOptions, UseSharedSessionResult, collaborationPaintLifetimeMs, makeApertureRuntime, parseShareToken, useBaseUrl, useBrowserControl, useEffectCallback, useFork, useLiveSession, useRunApi, useRuntime, useSharedSession };
+//# sourceMappingURL=headless.d.ts.map

package/dist/headless.js

@@ -0,0 +1,2 @@
+import { a as makeApertureRuntime, c as collaborationPaintLifetimeMs, d as RuntimeProviderMissingError, f as useBaseUrl, g as useRuntime, h as useRunApi, i as ApertureProvider, l as useLiveSession, m as useFork, n as parseShareToken, o as useBrowserControl, p as useEffectCallback, r as useSharedSession, s as SessionViewport, t as LiveSessionError, u as RuntimeProvider } from "./headless-CKFacFX3.js";
+export { ApertureProvider, LiveSessionError, RuntimeProvider, RuntimeProviderMissingError, SessionViewport, collaborationPaintLifetimeMs, makeApertureRuntime, parseShareToken, useBaseUrl, useBrowserControl, useEffectCallback, useFork, useLiveSession, useRunApi, useRuntime, useSharedSession };

package/dist/index.d.ts

@@ -0,0 +1,99 @@
+import { ApertureProvider, ApertureProviderProps, ApertureRuntime, ApertureRuntimeOptions, BrowserCommands, BrowserMediaPath, BrowserMediaPhase, CollaborationControl, CollaborationCursor, CollaborationError, CollaborationLeaseMode, CollaborationPaintEvent, CollaborationPaintPoint, CollaborationParticipant, CollaborationPhase, CollaborationRole, LiveSessionControl, LiveSessionError, LiveSessionMediaSelection, LiveSessionMediaSize, RuntimeProvider, RuntimeProviderMissingError, SessionNotice, SessionViewport, SessionViewportOverlay, SessionViewportPlaceholder, SessionViewportProps, SessionViewportStatus, ShareToken, SharedSessionStatus, UseBrowserControlResult, UseSharedSessionOptions, UseSharedSessionResult, collaborationPaintLifetimeMs, makeApertureRuntime, parseShareToken, useBaseUrl, useBrowserControl, useEffectCallback, useFork, useLiveSession, useRunApi, useRuntime, useSharedSession } from "./headless.js";
+import { ReactNode } from "react";
+import * as Effect from "effect/Effect";
+import { CollaborationRole as CollaborationRole$1 } from "@aperture-browser/live-session";
+
+//#region src/features.d.ts
+interface SessionFeatures {
+  readonly tabs?: boolean;
+  readonly navigation?: boolean;
+  readonly addressBar?: boolean;
+  readonly presence?: boolean;
+  readonly drawing?: boolean;
+  readonly devTools?: boolean;
+  readonly menus?: boolean;
+  readonly statusBadge?: boolean;
+}
+interface ApertureSessionFeatures extends SessionFeatures {
+  readonly toaster?: boolean;
+}
+type ResolvedSessionFeatures = Required<SessionFeatures>;
+declare function resolveSessionFeatures(features?: SessionFeatures): ResolvedSessionFeatures;
+//#endregion
+//#region src/aperture-session.d.ts
+interface SharedSessionProps {
+  readonly token: string;
+  readonly features?: SessionFeatures;
+  readonly leading?: ReactNode;
+}
+interface ApertureSessionProps extends SharedSessionProps {
+  readonly baseUrl?: string;
+  readonly features?: ApertureSessionFeatures;
+  readonly theme?: "light" | "dark" | "system";
+  readonly className?: string;
+}
+declare function ApertureSession({
+  baseUrl,
+  theme,
+  className,
+  ...props
+}: ApertureSessionProps): import("react").JSX.Element;
+declare function SharedSession({
+  token,
+  features,
+  leading
+}: SharedSessionProps): import("react").JSX.Element;
+declare function devToolsUrl(origin: string, cdpUrl: string, sessionToken: string): string;
+//#endregion
+//#region src/clipboard.d.ts
+declare const ClipboardError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "ClipboardError";
+} & Readonly<A>;
+/** The browser refused to write to the clipboard. */
+declare class ClipboardError extends ClipboardError_base<{
+  readonly cause?: unknown;
+}> {
+  readonly message = "Clipboard write is unavailable";
+}
+declare const copyText: (value: string) => Effect.Effect<void, ClipboardError>;
+/** Copies `value`, then runs `onCopied`, or shows an error toast if the copy fails. */
+declare const copyTextWithToast: (value: string, onCopied?: () => void) => Effect.Effect<void, never, never>;
+//#endregion
+//#region src/components/browser-control-pane.d.ts
+type BrowserControlPaneProps = {
+  control: UseBrowserControlResult;
+  leading?: ReactNode;
+  features?: SessionFeatures;
+  collaborationRole: CollaborationRole$1;
+  cdpUrl: string | null;
+  shareUrls: {
+    editor: string;
+    viewer: string;
+  } | null;
+  onSessionDetails?: () => void;
+};
+declare function BrowserControlPane({
+  control,
+  leading,
+  features: featureOverrides,
+  collaborationRole,
+  cdpUrl,
+  shareUrls,
+  onSessionDetails
+}: BrowserControlPaneProps): import("react").JSX.Element;
+//#endregion
+//#region src/components/browser-viewport.d.ts
+interface BrowserViewportProps extends Omit<SessionViewportProps, "renderOverlay" | "onNotice"> {
+  statusBadge?: boolean;
+}
+declare function BrowserViewport({
+  statusBadge,
+  className,
+  ...props
+}: BrowserViewportProps): import("react").JSX.Element;
+//#endregion
+//#region src/notices.d.ts
+declare function showNotice(notice: SessionNotice): void;
+//#endregion
+export { ApertureProvider, ApertureProviderProps, ApertureRuntime, ApertureRuntimeOptions, ApertureSession, ApertureSessionFeatures, ApertureSessionProps, BrowserCommands, BrowserControlPane, BrowserMediaPath, BrowserMediaPhase, BrowserViewport, BrowserViewportProps, ClipboardError, CollaborationControl, type CollaborationCursor, type CollaborationError, type CollaborationLeaseMode, type CollaborationPaintEvent, type CollaborationPaintPoint, type CollaborationParticipant, type CollaborationPhase, type CollaborationRole, LiveSessionControl, LiveSessionError, LiveSessionMediaSelection, LiveSessionMediaSize, ResolvedSessionFeatures, RuntimeProvider, RuntimeProviderMissingError, SessionFeatures, SessionNotice, SessionViewport, SessionViewportOverlay, SessionViewportPlaceholder, SessionViewportProps, SessionViewportStatus, ShareToken, SharedSession, SharedSessionProps, SharedSessionStatus, UseBrowserControlResult, UseSharedSessionOptions, UseSharedSessionResult, collaborationPaintLifetimeMs, copyText, copyTextWithToast, devToolsUrl, makeApertureRuntime, parseShareToken, resolveSessionFeatures, showNotice, useBaseUrl, useBrowserControl, useEffectCallback, useFork, useLiveSession, useRunApi, useRuntime, useSharedSession };
+//# sourceMappingURL=index.d.ts.map