stagebook 0.1.0

package/dist/components/index.d.ts

@@ -0,0 +1,400 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React$1 from 'react';
+import { b as DiscussionType, i as MetadataType, C as Condition } from '../evaluateConditions-DzlC6fez.js';
+export { al as MediaPlayer, am as MediaPlayerProps, V as VideoEvent } from '../evaluateConditions-DzlC6fez.js';
+import 'zod';
+
+interface StagebookContext {
+    resolve(reference: string, position?: string): unknown[];
+    save(key: string, value: unknown, scope?: "player" | "shared"): void;
+    getElapsedTime(): number;
+    submit(): void;
+    getAssetURL(path: string): string;
+    getTextContent(path: string): Promise<string>;
+    progressLabel: string;
+    playerId: string;
+    position: number | undefined;
+    playerCount: number | undefined;
+    isSubmitted: boolean;
+    setAllowIdle?: (allow: boolean) => void;
+    renderDiscussion?: (config: DiscussionType) => React$1.ReactNode;
+    renderSharedNotepad?: (config: {
+        padName: string;
+    }) => React$1.ReactNode;
+    renderTalkMeter?: () => React$1.ReactNode;
+    renderSurvey?: (config: {
+        surveyName: string;
+        onComplete: (results: unknown) => void;
+    }) => React$1.ReactNode;
+}
+declare function StagebookProvider({ value, children, }: {
+    value: StagebookContext;
+    children: React$1.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useStagebookContext(): StagebookContext;
+declare function useResolve(reference: string, position?: string): unknown[];
+declare function useSave(): StagebookContext["save"];
+declare function useElapsedTime(): number;
+interface TextContentResult {
+    data: string | undefined;
+    isLoading: boolean;
+    error: Error | undefined;
+}
+declare function useTextContent(path: string): TextContentResult;
+
+interface ElementConfig {
+    type: string;
+    name?: string;
+    file?: string;
+    style?: "" | "thin" | "regular" | "thick";
+    reference?: string;
+    position?: string;
+    shared?: boolean;
+    buttonText?: string;
+    url?: string;
+    source?: string;
+    displayText?: string;
+    helperText?: string;
+    urlParams?: Array<{
+        key: string;
+        value?: unknown;
+        reference?: string;
+        position?: string;
+    }>;
+    width?: number;
+    startTime?: number;
+    endTime?: number;
+    displayTime?: number;
+    hideTime?: number;
+    warnTimeRemaining?: number;
+    surveyName?: string;
+    [key: string]: unknown;
+}
+interface ElementProps {
+    element: ElementConfig;
+    onSubmit: () => void;
+    stageDuration?: number;
+}
+declare function Element({ element, onSubmit, stageDuration }: ElementProps): string | number | bigint | boolean | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null;
+
+interface StageConfig {
+    name: string;
+    duration?: number;
+    elements: ElementConfig[];
+    discussion?: DiscussionType;
+}
+interface StageProps {
+    stage: StageConfig;
+    onSubmit: () => void;
+}
+declare function Stage({ stage, onSubmit }: StageProps): react_jsx_runtime.JSX.Element;
+
+interface ButtonProps {
+    children: React$1.ReactNode;
+    onClick?: React$1.MouseEventHandler<HTMLButtonElement> | null;
+    className?: string;
+    style?: React$1.CSSProperties;
+    primary?: boolean;
+    type?: "button" | "submit" | "reset";
+    autoFocus?: boolean;
+    disabled?: boolean;
+    id?: string;
+    "data-testid"?: string;
+}
+declare function Button({ children, onClick, className, style, primary, type, autoFocus, disabled, id, "data-testid": dataTestId, }: ButtonProps): react_jsx_runtime.JSX.Element;
+
+interface SeparatorProps {
+    style?: "" | "thin" | "regular" | "thick";
+}
+declare function Separator({ style }: SeparatorProps): react_jsx_runtime.JSX.Element;
+
+interface RadioOption {
+    key: string;
+    value: string;
+}
+type RadioLayout = "vertical" | "horizontal";
+interface RadioGroupProps {
+    options: RadioOption[];
+    value?: string;
+    onChange: (e: React$1.ChangeEvent<HTMLInputElement>) => void;
+    label?: string;
+    layout?: RadioLayout;
+    id?: string;
+    "data-testid"?: string;
+}
+declare function RadioGroup({ options, value, onChange, label, layout, id, "data-testid": dataTestId, }: RadioGroupProps): react_jsx_runtime.JSX.Element;
+
+interface CheckboxOption {
+    key: string;
+    value: string;
+}
+type CheckboxLayout = "vertical" | "horizontal";
+interface CheckboxGroupProps {
+    options: CheckboxOption[];
+    value: string[];
+    onChange: (selected: string[]) => void;
+    label?: string;
+    layout?: CheckboxLayout;
+    id?: string;
+    "data-testid"?: string;
+}
+declare function CheckboxGroup({ options, value, onChange, label, layout, id, "data-testid": dataTestId, }: CheckboxGroupProps): react_jsx_runtime.JSX.Element;
+
+interface TypingStats {
+    type: "typingStats";
+    totalKeystrokes: number;
+    avgInterval: number;
+    stdDev: number;
+}
+interface PasteAttempt {
+    type: "pasteAttempt";
+    length: number;
+    timestamp: number;
+}
+type DebugMessage = TypingStats | PasteAttempt;
+interface TextAreaProps {
+    defaultText?: string;
+    onChange?: (value: string) => void;
+    onDebugMessage?: (message: DebugMessage) => void;
+    value?: string;
+    rows?: number;
+    showCharacterCount?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    debounceDelay?: number;
+    id?: string;
+}
+declare function TextArea({ defaultText, onChange, onDebugMessage, value, rows, showCharacterCount, minLength, maxLength, debounceDelay, id, }: TextAreaProps): react_jsx_runtime.JSX.Element;
+
+interface SliderProps {
+    min?: number;
+    max?: number;
+    interval?: number;
+    labelPts?: number[];
+    labels?: string[];
+    value?: number;
+    onChange?: (value: number) => void;
+}
+declare function Slider({ min, max, interval, labelPts, labels, value, onChange, }: SliderProps): react_jsx_runtime.JSX.Element;
+
+interface ListSorterProps {
+    items: string[];
+    onChange: (reordered: string[]) => void;
+}
+declare function ListSorter({ items, onChange }: ListSorterProps): react_jsx_runtime.JSX.Element;
+
+interface MarkdownProps {
+    text: string;
+    resolveURL?: (path: string) => string;
+}
+declare function Markdown({ text, resolveURL }: MarkdownProps): react_jsx_runtime.JSX.Element;
+
+interface LoadingProps {
+    size?: "sm" | "md" | "lg";
+}
+declare function Loading({ size }: LoadingProps): react_jsx_runtime.JSX.Element;
+
+interface DisplayProps {
+    reference: string;
+    position?: string;
+    values: unknown[];
+}
+declare function Display({ reference, values }: DisplayProps): react_jsx_runtime.JSX.Element;
+
+interface SubmitButtonProps {
+    onSubmit: () => void;
+    name: string;
+    buttonText?: string;
+    save: (key: string, value: unknown) => void;
+}
+declare function SubmitButton({ onSubmit, name, buttonText, save, }: SubmitButtonProps): react_jsx_runtime.JSX.Element;
+
+interface AudioElementProps {
+    src: string;
+    save?: (key: string, value: unknown) => void;
+    name?: string;
+}
+declare function AudioElement({ src, save, name }: AudioElementProps): null;
+
+interface ImageElementProps {
+    src: string;
+    width?: number;
+}
+declare function ImageElement({ src, width }: ImageElementProps): react_jsx_runtime.JSX.Element | null;
+
+interface KitchenTimerProps {
+    startTime: number;
+    endTime: number;
+    warnTimeRemaining?: number;
+    getElapsedTime: () => number;
+}
+declare function KitchenTimer({ startTime, endTime, warnTimeRemaining, getElapsedTime, }: KitchenTimerProps): react_jsx_runtime.JSX.Element;
+
+interface ResolvedParam$1 {
+    key: string;
+    value: string;
+}
+interface TrackedLinkProps {
+    name: string;
+    url: string;
+    displayText: string;
+    helperText?: string;
+    resolvedParams?: ResolvedParam$1[];
+    save: (key: string, value: unknown) => void;
+    getElapsedTime: () => number;
+    progressLabel: string;
+    setAllowIdle?: (allow: boolean) => void;
+}
+declare function TrackedLink({ name, url, displayText, helperText, resolvedParams, save, getElapsedTime, progressLabel, setAllowIdle, }: TrackedLinkProps): react_jsx_runtime.JSX.Element;
+
+interface PromptProps {
+    metadata: MetadataType;
+    body: string;
+    responseItems: string[];
+    name: string;
+    file?: string;
+    shared?: boolean;
+    value: unknown;
+    save: (key: string, value: unknown, scope?: "player" | "shared") => void;
+    resolveURL?: (path: string) => string;
+    renderSharedNotepad?: (config: {
+        padName: string;
+        defaultText?: string;
+        rows?: number;
+    }) => React$1.ReactNode;
+}
+declare function Prompt({ metadata, body, responseItems, name, file, shared, value, save, resolveURL, renderSharedNotepad, }: PromptProps): react_jsx_runtime.JSX.Element;
+
+interface ResolvedParam {
+    key: string;
+    value: string;
+}
+interface QualtricsProps {
+    url: string;
+    resolvedParams?: ResolvedParam[];
+    participantId?: string;
+    groupId?: string;
+    save: (key: string, value: unknown) => void;
+    onComplete: () => void;
+}
+declare function Qualtrics({ url, resolvedParams, participantId, groupId, save, onComplete, }: QualtricsProps): react_jsx_runtime.JSX.Element;
+
+interface TimelineProps {
+    source: string;
+    name: string;
+    selectionType: "range" | "point";
+    selectionScope?: "track" | "all";
+    multiSelect?: boolean;
+    showWaveform?: boolean;
+    trackLabels?: string[];
+    /**
+     * Previously saved selections to restore on mount. Element.tsx resolves
+     * this from `timeline.<name>` so participants who reload the stage see
+     * their existing marks. Untrusted shape — validated before use.
+     */
+    initialSelections?: unknown;
+    save: (key: string, value: unknown) => void;
+}
+declare function Timeline({ source, name, selectionType, selectionScope, multiSelect, showWaveform, trackLabels, initialSelections, save, }: TimelineProps): react_jsx_runtime.JSX.Element;
+
+interface TimeConditionalRenderProps {
+    displayTime?: number;
+    hideTime?: number;
+    getElapsedTime: () => number;
+    children: React$1.ReactNode;
+}
+declare function TimeConditionalRender({ displayTime, hideTime, getElapsedTime, children, }: TimeConditionalRenderProps): react_jsx_runtime.JSX.Element | null;
+
+interface PositionConditionalRenderProps {
+    showToPositions?: number[];
+    hideFromPositions?: number[];
+    position: number | undefined;
+    children: React$1.ReactNode;
+}
+declare function PositionConditionalRender({ showToPositions, hideFromPositions, position, children, }: PositionConditionalRenderProps): react_jsx_runtime.JSX.Element | null;
+
+interface ConditionsConditionalRenderProps {
+    conditions: Condition[];
+    resolve: (reference: string, position?: string) => unknown[];
+    children: React$1.ReactNode;
+    fallback?: React$1.ReactNode;
+}
+declare function ConditionsConditionalRender({ conditions, resolve, children, fallback, }: ConditionsConditionalRenderProps): react_jsx_runtime.JSX.Element;
+
+interface SubmissionConditionalRenderProps {
+    isSubmitted: boolean;
+    playerCount: number | undefined;
+    children: React$1.ReactNode;
+}
+declare function SubmissionConditionalRender({ isSubmitted, playerCount, children, }: SubmissionConditionalRenderProps): react_jsx_runtime.JSX.Element;
+
+interface ScrollIndicatorProps {
+    visible: boolean;
+}
+declare function ScrollIndicator({ visible }: ScrollIndicatorProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * Detects when new content appears below the viewport and either:
+ * - Auto-scrolls to "peek" the content if user is near bottom
+ * - Shows an indicator if user is not near bottom
+ */
+declare function useScrollAwareness(containerRef: React.RefObject<HTMLElement | null>, options?: {
+    threshold?: number;
+}): {
+    showIndicator: boolean;
+    dismissIndicator: () => void;
+};
+
+/** Unified playback interface. Both HTML5 VideoCore and YouTubePlayer expose this via ref. */
+interface PlaybackHandle {
+    play(): void;
+    pause(): void;
+    seekTo(seconds: number): void;
+    getCurrentTime(): number;
+    getDuration(): number;
+    isPaused(): boolean;
+    /** True when backed by the YouTube IFrame API; frame-step controls should be hidden. */
+    readonly isYouTube: boolean;
+    /** Number of audio channels in the media. 0 until waveform capture starts. */
+    readonly channelCount: number;
+    /**
+     * Per-channel waveform peaks. One Float32Array per channel, containing
+     * interleaved min/max pairs per time bucket. Empty until capture starts.
+     * Shared across all timelines — read-only.
+     *
+     * IMPORTANT: these arrays are mutated in place during capture. Consumers
+     * that need to know when the data changed should read `peaksVersion`,
+     * which bumps every time a frame is accumulated.
+     */
+    readonly peaks: Float32Array[];
+    /**
+     * Monotonically increasing counter that bumps every time `peaks` is
+     * mutated by the capture loop. Use this as a render-token in React effects
+     * (e.g., a canvas redraw effect) so they re-run when peaks change despite
+     * the array reference being stable.
+     */
+    readonly peaksVersion: number;
+    /**
+     * Request the MediaPlayer to start capturing waveform data.
+     * Lazily creates AudioContext + AnalyserNodes on first call.
+     * No-op on subsequent calls. No-op for YouTube sources.
+     */
+    requestWaveformCapture(): void;
+}
+
+declare function PlaybackProvider({ children }: {
+    children: React$1.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Register a PlaybackHandle under `name` for the duration of the component's
+ * life. Safe to call without a PlaybackProvider — silently no-ops.
+ */
+declare function useRegisterPlayback(name: string, handle: PlaybackHandle): void;
+/**
+ * Look up a PlaybackHandle by the name registered by a sibling MediaPlayer.
+ * Returns `undefined` if no player with that name is mounted yet.
+ * Must be called inside a PlaybackProvider.
+ */
+declare function usePlayback(source: string): PlaybackHandle | undefined;
+
+export { AudioElement, type AudioElementProps, Button, type ButtonProps, CheckboxGroup, type CheckboxGroupProps, type CheckboxOption, Condition, ConditionsConditionalRender, type ConditionsConditionalRenderProps, type DebugMessage, Display, type DisplayProps, Element, type ElementConfig, type ElementProps, ImageElement, type ImageElementProps, KitchenTimer, type KitchenTimerProps, ListSorter, type ListSorterProps, Loading, type LoadingProps, Markdown, type MarkdownProps, type PasteAttempt, type PlaybackHandle, PlaybackProvider, PositionConditionalRender, type PositionConditionalRenderProps, Prompt, type PromptProps, Qualtrics, type QualtricsProps, RadioGroup, type RadioGroupProps, type RadioOption, type ResolvedParam$1 as ResolvedParam, ScrollIndicator, type ScrollIndicatorProps, Separator, type SeparatorProps, Slider, type SliderProps, Stage, type StageConfig, type StageProps, type StagebookContext, StagebookProvider, SubmissionConditionalRender, type SubmissionConditionalRenderProps, SubmitButton, type SubmitButtonProps, TextArea, type TextAreaProps, type TextContentResult, TimeConditionalRender, type TimeConditionalRenderProps, Timeline, type TimelineProps, TrackedLink, type TrackedLinkProps, type TypingStats, useElapsedTime, usePlayback, useRegisterPlayback, useResolve, useSave, useScrollAwareness, useStagebookContext, useTextContent };