react-iiif-vault 1.5.10 → 2.0.1

package/dist/index-yy_738ck.d.ts

@@ -0,0 +1,643 @@
+import { ViewerMode, Runtime, BoxStyle, AtlasProps, Preset } from '@atlas-viewer/atlas';
+import * as React$1 from 'react';
+import React__default, { ReactNode, FC, ComponentType, RefObject, ForwardRefExoticComponent, RefAttributes } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as zustand from 'zustand';
+import { StoreApi } from 'zustand';
+import * as mitt from 'mitt';
+import { Emitter } from 'mitt';
+import * as polygon_editor from 'polygon-editor';
+import { RenderState, SlowState, InputShape, ValidTools, createHelper } from 'polygon-editor';
+import { Vault } from '@iiif/helpers/vault';
+import { Reference, FragmentSelector, SvgSelector, AnnotationPage } from '@iiif/presentation-3';
+import * as zustand_vanilla from 'zustand/vanilla';
+import { AnnotationPageNormalized, CanvasNormalized } from '@iiif/presentation-3-normalized';
+import { S as SingleAudio, a as SingleVideo, M as MediaStrategy, b as StrategyActions, c as SingleImageStrategy, E as EmptyStrategy, C as ComplexTimelineStrategy, R as RenderingStrategy, I as ImageWithOptionalService } from './useRenderingStrategy-PvoNjiMV.js';
+import { ChoiceDescription, ImageCandidate, BoxSelector } from '@iiif/helpers';
+
+type RenderContextProps = {
+    canvasId?: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    close: () => void;
+};
+declare const useContextMenuStore: zustand.UseBoundStore<zustand.StoreApi<{
+    isMenuOpen: boolean;
+    menuPosition: {
+        x: number;
+        y: number;
+    };
+    open(position: {
+        x: number;
+        y: number;
+    }): void;
+    toggle(position: {
+        x: number;
+        y: number;
+    }): void;
+    setMenuPosition(position: {
+        x: number;
+        y: number;
+    }): void;
+    setIsMenuOpen(isMenuOpen: boolean | ((prev: boolean) => boolean)): void;
+    close(): void;
+}>>;
+declare function useAtlasContextMenu(id: string, canvasId?: string, renderContextMenu?: (props: RenderContextProps) => React.ReactNode): readonly [react_jsx_runtime.JSX.Element, {
+    onContextMenu: (e: any) => void;
+}, {
+    readonly open: (position: {
+        x: number;
+        y: number;
+    }) => void;
+    readonly close: () => void;
+    readonly toggle: (position: {
+        x: number;
+        y: number;
+    }) => void;
+    readonly isMenuOpen: boolean;
+    readonly setIsMenuOpen: (isMenuOpen: boolean | ((prev: boolean) => boolean)) => void;
+    readonly menuPosition: {
+        x: number;
+        y: number;
+    };
+    readonly setMenuPosition: (position: {
+        x: number;
+        y: number;
+    }) => void;
+}];
+
+interface SvgEditorOptions {
+    image: {
+        height: number;
+        width: number;
+    };
+    hideShapeLines?: boolean;
+    onChange?: (shape: InputShape) => void;
+    theme?: Partial<SVGTheme>;
+}
+declare const defaultSvgTheme: {
+    shapeFill: string;
+    shapeStroke: string;
+    lineStroke: string;
+    ghostLineStroke: string;
+    activeLineStroke: string;
+    boundingBoxDottedStroke: string;
+    boundingBoxStroke: string;
+    controlFill: string;
+};
+type SVGTheme = typeof defaultSvgTheme;
+declare function useSvgEditor(options: SvgEditorOptions): {
+    currentTool: polygon_editor.ValidTools;
+    setCurrentTool: (tool: polygon_editor.ValidTools) => void;
+    helper: {
+        state: RenderState;
+        setState: (newState: Partial<SlowState>) => void;
+        emitter: mitt.Emitter<polygon_editor.PolygonEvents>;
+        modifiers: {
+            reset(): void;
+            getForType(type: string | null): Record<string, string>;
+            set(modifier: string): void;
+            unset(modifier: string): void;
+        };
+        stamps: {
+            set(selectedStamp: InputShape | null): void;
+            clear(): void;
+            square(): void;
+            triangle(): void;
+            pentagon(): void;
+            hexagon(): void;
+            circle(): void;
+        };
+        history: {
+            undo: () => void;
+            redo: () => void;
+            readonly canUndo: boolean;
+            readonly canRedo: boolean;
+        };
+        key: {
+            down(inputKey: string): boolean | undefined;
+            up(inputKey: string): void;
+        };
+        setScale: (scale: number) => void;
+        clock: {
+            set: (renderFunc: polygon_editor.RenderFunc) => void;
+            start: (renderFunc?: polygon_editor.RenderFunc | undefined, setStateFunc?: polygon_editor.SetState | undefined) => void;
+            stop: () => void;
+            step: (deltaTime?: number | undefined) => void;
+        };
+        pointer: (pointers: ([number, number] | [number, number, number, number, number, number])[]) => void;
+        blur: () => void;
+        pointerDown: () => void;
+        pointerUp: () => void;
+        setShape: (shape: InputShape | null) => void;
+        label: (type: string | null) => string;
+        tools: {
+            setTool: (tool: polygon_editor.ValidTools) => void;
+            unsetTool: (tool: polygon_editor.ValidTools) => void;
+            toggleTool: (tool: polygon_editor.ValidTools) => void;
+            updateVisibility: (tool: polygon_editor.ValidTools) => void;
+            setCanDelete(canDelete: boolean): void;
+            setCanDeselect(canDeselect: boolean): void;
+            lockToolSwitching(): void;
+            unlockToolSwitching(): void;
+            toggleToolSwitching(): void;
+            shortcuts: {
+                [k: string]: string;
+            };
+            getValidIntents(tool?: polygon_editor.ValidTools | undefined): {
+                actions: polygon_editor.ActionIntent[];
+                transitions: polygon_editor.TransitionIntent[];
+                keys: polygon_editor.ActionIntent[];
+                all: Record<string, string>;
+                current: Record<string, string>;
+            };
+            getToolInfo(): {
+                name: polygon_editor.ValidTools;
+                cursor: string;
+                selectionCount: number;
+                pointCount: number;
+                isOpen: boolean;
+            };
+            smartSelect(): void;
+            clearSelection(): void;
+            autoSelect(): void;
+        };
+        snap: {
+            enabled: () => boolean;
+            enable: () => void;
+            disable: () => void;
+            toggle: () => void;
+            pointsEnabled: () => boolean;
+            enablePoints: () => void;
+            disablePoints: () => void;
+            togglePoints: () => void;
+            linesEnabled: () => boolean;
+            enableLines: () => void;
+            disableLines: () => void;
+            toggleLines: () => void;
+            intersectionsEnabled: () => boolean;
+            enableIntersections: () => void;
+            disableIntersections: () => void;
+            toggleIntersections: () => void;
+            gridEnabled: () => boolean;
+            enableGrid: () => void;
+            disableGrid: () => void;
+            toggleGrid: () => void;
+            parallelEnabled: () => boolean;
+            enableParallel: () => void;
+            disableParallel: () => void;
+            toggleParallel: () => void;
+            getThreshold: () => number;
+            setThreshold: (threshold: number) => void;
+            isActive: () => boolean;
+            getSnapPoint: () => ([number, number] | [number, number, number, number, number, number]) | null;
+            getActiveGuides: () => polygon_editor.SnapGuide[];
+            getTargets: () => polygon_editor.SnapTarget[];
+        };
+        selectAllPoints: () => void;
+        setBounds: (bounds: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        } | null) => void;
+        lockAspectRatio: () => void;
+        unlockAspectRatio: () => void;
+    };
+    currentShape: InputShape | null;
+    state: SlowState;
+    isAddingPoint: boolean;
+    isSplitting: boolean;
+    isStamping: boolean | null;
+    isHoveringPoint: boolean;
+    transitionDirection: string | null;
+    transitionRotate: boolean;
+    defs: react_jsx_runtime.JSX.Element;
+    editor: react_jsx_runtime.JSX.Element | null;
+};
+
+type SimpleViewerContext = {
+    items: Reference<'Canvas'>[];
+    sequence: number[][];
+    hasNext: boolean;
+    hasPrevious: boolean;
+    setSequenceIndex: (newId: number) => void;
+    setCurrentCanvasId: (newId: string) => void;
+    setCurrentCanvasIndex: (newId: number) => void;
+    currentSequenceIndex: number;
+    nextCanvas: () => void;
+    previousCanvas: () => void;
+};
+type SimpleViewerProps = {
+    vault?: Vault;
+    manifest: string;
+    pagingEnabled?: boolean;
+    children: ReactNode;
+    startCanvas?: string;
+    rangeId?: string;
+};
+type SimpleViewerReducerState = {
+    sequence: number[][];
+    availableCanvases: Reference<'Canvas'>[];
+    visibleCanvases: Reference<'Canvas'>[];
+    currentCanvas: string | null;
+    isPaged: boolean;
+    rangeId: string | null;
+};
+interface SimpleViewerActions {
+    setCurrentCanvasId(newId: string): void;
+    setCurrentCanvasIndex(newId: number): void;
+    nextCanvas(): void;
+    previousCanvas(): void;
+    setCurrentRange(newId: string): void;
+    clearRange(): void;
+    setPagingEnabled(isEnabled: boolean): void;
+}
+type SimpleViewerActionsType = {
+    [T in keyof SimpleViewerActions]: {
+        type: T;
+        payload: Parameters<SimpleViewerActions[T]>[0];
+    };
+}[keyof SimpleViewerActions];
+
+type Polygons = ReturnType<typeof createHelper>;
+type Point = [number, number] | [number, number, number, number, number, number];
+type AnnotationRequest = {
+    annotationPopup?: React.ReactNode;
+    arguments?: Record<string, any>;
+    svgTheme?: Partial<SVGTheme>;
+    selectByDefault?: boolean;
+    bounds?: null | {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+} & ({
+    type: 'polygon' | 'draw';
+    noBox?: boolean;
+    points?: Array<Point>;
+    open?: boolean;
+    selector?: undefined;
+} | {
+    type: 'target';
+    selector: null | {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+} | {
+    type: 'box';
+    selector?: null | {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+});
+type AnnotationRequestOptions = {
+    requestId: string;
+    canvasId?: string | null;
+    toolId?: keyof AtlasStore['switchTool'];
+};
+interface AtlasStore {
+    mode: ViewerMode;
+    tool: {
+        enabled: boolean;
+        requestId: string | null;
+        canvasId: string | null;
+    };
+    requestType: null | 'polygon' | 'target' | 'box' | 'draw';
+    metadata: Record<string, any>;
+    requests: Record<string, AnnotationRequest>;
+    switchTool: {
+        draw(): void;
+        pen(): void;
+        line(): void;
+        lineBox(): void;
+        box(): void;
+        triangle(): void;
+        hexagon(): void;
+        circle(): void;
+        remove(): void;
+        hand(): void;
+        pointer(): void;
+    };
+    history: {
+        canUndo: boolean;
+        canRedo: boolean;
+        undo(): void;
+        redo(): void;
+    };
+    stableViewport: null | {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        zoom: number;
+    };
+    canvasRelativePositions: Record<string, {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    canvasViewports: Record<string, {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        zoom?: number;
+    }>;
+    validRequestIds: string[];
+    polygon: InputShape | null;
+    polygons: Polygons;
+    polygonState: SlowState;
+    setPolygonState: (state: SlowState | ((prev: SlowState) => SlowState)) => void;
+    setToolCanvasId: (canvasId: string) => void;
+    setMetadata(data: Record<string, any>, requestId?: string): void;
+    getRequestId(): {
+        requestId: string;
+        clear: () => void;
+    };
+    requestAnnotation(req: AnnotationRequest, options: AnnotationRequestOptions): Promise<AnnotationResponse | null>;
+    setAtlasRuntime(runtime: Runtime): void;
+    setCanvasRelativePosition(canvasId: string, position: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): void;
+    clearCanvasRelativePosition(canvasId: string): void;
+    clearAtlasRuntime(): void;
+    completeRequest(requestId?: string): void;
+    cancelRequest(requestId?: string): void;
+    reset(): void;
+    changeMode(mode: ViewerMode): void;
+    nudgeLeft(): void;
+    nudgeRight(): void;
+    nudgeUp(): void;
+    nudgeDown(): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    goHome(): void;
+}
+declare function polygonToTarget(polygon: InputShape, on?: {
+    width: number;
+    height: number;
+} | null): FragmentSelector | SvgSelector | null;
+declare function requestToAnnotationResponse(request: AnnotationRequest): Omit<AnnotationResponse, 'id'>;
+type AnnotationResponse = {
+    id: string;
+    canvasId?: string | null;
+    polygon: InputShape | null;
+    cancelled?: boolean;
+    requestType: 'draw' | 'polygon' | 'target' | 'box';
+    target: FragmentSelector | SvgSelector | null;
+    boundingBox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    metadata: Record<string, any>;
+    arguments: Record<string, any>;
+};
+type AtlasStoreEvents = {
+    'atlas.canvas-click': {
+        canvasId: string;
+        target: {
+            x: number;
+            y: number;
+        };
+        worldTarget: {
+            x: number;
+            y: number;
+        };
+    };
+    'atlas.viewport-change': {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        zoom: number;
+    };
+    'atlas.ready': {
+        runtime: Runtime;
+    };
+    'atlas.annotation-completed': AnnotationResponse;
+    'atlas.annotation-request': {
+        id: string;
+    };
+    'atlas.request-cancelled': {
+        id: string;
+    };
+    'atlas.polygon-render': {
+        state: RenderState;
+        slowState: SlowState;
+        dt: number;
+    };
+    'atlas.polygon-update': {
+        id?: string;
+        points: Array<Point>;
+        open: boolean;
+    };
+};
+interface CreateAtlasStoreProps {
+    events: Emitter<AtlasStoreEvents>;
+    keyboardShortcutsEnabled?: boolean;
+    keyboardShortcutMapping?: Record<string, string>;
+    enabledTools?: Array<ValidTools>;
+    debug?: boolean;
+}
+declare function createAtlasStore({ events, enabledTools, keyboardShortcutMapping, keyboardShortcutsEnabled, debug, }: CreateAtlasStoreProps): zustand_vanilla.StoreApi<AtlasStore>;
+
+declare const AtlasStoreReactContext: React$1.Context<StoreApi<AtlasStore> | null>;
+declare function useAtlasStore(): StoreApi<AtlasStore>;
+declare function getAtlasStoreByName(name?: string): AtlasStore;
+declare function AtlasStoreProvider({ children, name, existing, atlasStoreConfig, }: {
+    name?: string;
+    children: React.ReactNode;
+    existing?: StoreApi<AtlasStore>;
+    atlasStoreConfig?: Partial<CreateAtlasStoreProps>;
+}): react_jsx_runtime.JSX.Element;
+
+declare const RenderAnnotation: FC<{
+    id: string;
+    className?: string;
+    style?: BoxStyle;
+    interactive?: boolean;
+}>;
+
+declare const RenderAnnotationPage: FC<{
+    page: AnnotationPage | AnnotationPageNormalized;
+    className?: string;
+}>;
+
+interface AudioComponentProps {
+    media: SingleAudio;
+    startTime?: number | null;
+    children: ReactNode;
+}
+declare function AudioHTML({ media, startTime, children }: AudioComponentProps): react_jsx_runtime.JSX.Element;
+declare function Audio({ media, mediaControlsDeps, audioCopmonent, children, }: {
+    media: SingleAudio;
+    mediaControlsDeps?: any[];
+    children: ReactNode;
+    audioCopmonent?: ComponentType<AudioComponentProps>;
+}): null;
+
+interface VideoComponentProps {
+    element: RefObject<HTMLVideoElement>;
+    media: SingleVideo;
+    playPause: () => void;
+    canvas: CanvasNormalized;
+    poster?: string;
+    startTime?: number;
+    captions?: MediaStrategy['captions'];
+}
+declare function VideoHTML({ element, media, startTime, playPause, poster, }: VideoComponentProps): react_jsx_runtime.JSX.Element;
+declare function Video({ media, mediaControlsDeps, children, videoComponent, captions, }: {
+    media: SingleVideo;
+    mediaControlsDeps?: any[];
+    children: ReactNode;
+    posterCanvasId?: string;
+    videoComponent?: ComponentType<VideoComponentProps>;
+    captions?: MediaStrategy['captions'];
+}): null;
+
+type CanvasProps = {
+    x?: number;
+    y?: number;
+    onCreated?: any;
+    onChoiceChange?: (choice?: ChoiceDescription) => void;
+    registerActions?: (actions: StrategyActions) => void;
+    defaultChoices?: Array<{
+        id: string;
+        opacity?: number;
+    }>;
+    isStatic?: boolean;
+    keepCanvasScale?: boolean;
+    children?: ReactNode;
+    renderViewerControls?: (strategy: SingleImageStrategy | EmptyStrategy) => ReactNode;
+    viewControlsDeps?: any[];
+    renderMediaControls?: (strategy: MediaStrategy) => ReactNode;
+    renderComplexTimelineControls?: (strategy: ComplexTimelineStrategy) => ReactNode;
+    complexTimelineControlsDeps?: any[];
+    mediaControlsDeps?: any[];
+    strategies?: Array<RenderingStrategy['type']>;
+    backgroundStyle?: BoxStyle;
+    alwaysShowBackground?: boolean;
+    enableSizes?: boolean;
+    enableYouTube?: boolean;
+    ignoreSize?: boolean;
+    throwOnUnknown?: boolean;
+    renderContextMenu?: (options: RenderContextProps) => ReactNode;
+    onClickPaintingAnnotation?: (id: string, image: ImageWithOptionalService, e: any) => void;
+    components?: {
+        Video?: React__default.ComponentType<VideoComponentProps>;
+        Audio?: React__default.ComponentType<AudioComponentProps>;
+    };
+    annotationPopup?: React__default.ReactNode;
+    svgTheme?: Partial<SVGTheme>;
+    renderAnnotationContextMenu?: (options: RenderContextProps) => React__default.ReactNode;
+};
+declare function RenderCanvas({ x, y, onChoiceChange, registerActions, defaultChoices, isStatic, renderViewerControls, renderMediaControls, renderComplexTimelineControls, complexTimelineControlsDeps, viewControlsDeps, mediaControlsDeps, strategies, throwOnUnknown, backgroundStyle, alwaysShowBackground, keepCanvasScale, enableSizes, enableYouTube, onClickPaintingAnnotation, components, children, annotationPopup, svgTheme, renderContextMenu, renderAnnotationContextMenu, }: CanvasProps): react_jsx_runtime.JSX.Element;
+
+declare function CanvasBackground({ style }: {
+    style?: BoxStyle;
+}): react_jsx_runtime.JSX.Element | null;
+
+declare function RenderImage({ id, image, thumbnail, isStatic, x, y, children, selector, onClick, enableSizes, }: {
+    id: string;
+    image: ImageWithOptionalService;
+    thumbnail?: ImageCandidate;
+    isStatic?: boolean;
+    enableSizes?: boolean;
+    selector?: BoxSelector;
+    x?: number;
+    y?: number;
+    children?: ReactNode;
+    onClick?: (e: any) => void;
+}): react_jsx_runtime.JSX.Element;
+
+declare function ModelHTML({ model }: {
+    model: any;
+}): react_jsx_runtime.JSX.Element;
+declare function Model({ model, name }: {
+    model: any;
+    name?: string;
+}): null;
+
+interface PlaceholderCanvasProps {
+    renderViewerControls?: (strategy: SingleImageStrategy | EmptyStrategy) => ReactNode;
+}
+declare function PlaceholderCanvas(props: PlaceholderCanvasProps): react_jsx_runtime.JSX.Element | null;
+
+type ViewerProps = AtlasProps & {
+    name?: string;
+    height?: number | string;
+    width?: number | string;
+    resizeHash?: number;
+    containerProps?: any;
+    outerContainerProps?: any;
+    aspectRatio?: number;
+    errorFallback?: any;
+    renderPreset?: Preset;
+    worldScale?: number;
+    updateViewportTimeout?: number;
+} & {
+    children: ReactNode;
+};
+declare function Viewer(props: ViewerProps): react_jsx_runtime.JSX.Element;
+
+interface CanvasPanelProps {
+    manifest: string;
+    startCanvas?: string;
+    rangeId?: string;
+    pagingEnabled?: boolean;
+    header?: ReactNode;
+    children?: ReactNode;
+    mode?: ViewerMode;
+    reuseAtlas?: boolean;
+    runtimeOptions?: any;
+    renderPreset?: any;
+    name?: string;
+    height?: number;
+    spacing?: number;
+    components?: {
+        ViewerControls?: FC;
+        MediaControls?: FC;
+        ComplexTimelineControls?: FC;
+    };
+    canvasProps?: Omit<Partial<CanvasProps>, 'x'>;
+    annotations?: ReactNode;
+    annotationPopup?: ReactNode;
+    svgTheme?: SVGTheme;
+    updateViewportTimeout?: number;
+    renderContextMenu?: (options: RenderContextProps) => ReactNode;
+    keepCanvasScale?: boolean;
+    renderAnnotationContextMenu?: (options: RenderContextProps) => ReactNode;
+}
+type CanvasPanelType = ForwardRefExoticComponent<CanvasPanelProps & RefAttributes<SimpleViewerContext>> & {
+    RenderImage: typeof RenderImage;
+    RenderCanvas: typeof RenderCanvas;
+    RenderAnnotationPage: typeof RenderAnnotationPage;
+    RenderAnnotation: typeof RenderAnnotation;
+    Viewer: typeof Viewer;
+    CanvasBackground: typeof CanvasBackground;
+    Audio: typeof Audio;
+    Video: typeof Video;
+    Model: typeof Model;
+    AudioHTML: typeof AudioHTML;
+    VideoHTML: typeof VideoHTML;
+    ModelHTML: typeof ModelHTML;
+    PlaceholderCanvas: typeof PlaceholderCanvas;
+    getAtlasStoreByName: typeof getAtlasStoreByName;
+};
+declare const CanvasPanel: CanvasPanelType;
+
+export { type AudioComponentProps as A, type CanvasPanelProps as C, type RenderContextProps as R, type SVGTheme as S, type VideoComponentProps as V, type SimpleViewerContext as a, type AtlasStore as b, type AnnotationRequest as c, type AnnotationResponse as d, type AnnotationRequestOptions as e, type SimpleViewerProps as f, CanvasPanel as g, type AtlasStoreEvents as h, type CreateAtlasStoreProps as i, createAtlasStore as j, AtlasStoreReactContext as k, useAtlasStore as l, getAtlasStoreByName as m, AtlasStoreProvider as n, RenderAnnotation as o, polygonToTarget as p, RenderAnnotationPage as q, requestToAnnotationResponse as r, useContextMenuStore as s, useAtlasContextMenu as t, useSvgEditor as u, defaultSvgTheme as v, type SimpleViewerReducerState as w, type SimpleViewerActions as x, type SimpleViewerActionsType as y };