react-iiif-vault 0.9.6 → 0.9.9

package/dist/index.d.ts

@@ -1,80 +1,26 @@
-import React, { FC } from 'react';
+import * as _atlas_viewer_atlas from '@atlas-viewer/atlas';
+import * as React from 'react';
+import React__default, { ReactNode, RefObject } from 'react';
+import * as _iiif_presentation_3 from '@iiif/presentation-3';
+import { InternationalString, ImageService, AnnotationPageNormalized, ContentResource, IIIFExternalWebResource, SpecificResource, AnnotationNormalized, CanvasNormalized, CollectionNormalized, Reference, ManifestNormalized, RangeNormalized, SearchService, Annotation, ExternalWebResource as ExternalWebResource$1, W3CAnnotationTarget, Selector } from '@iiif/presentation-3';
+import { AtlasProps } from '@atlas-viewer/atlas/dist/types/modules/react-reconciler/Atlas';
 import { Vault, VaultOptions, ReduxStore, NormalizedEntity, IIIFStore } from '@iiif/vault';
+import { ExternalWebResource } from '@iiif/presentation-3/resources/annotation';
+import { ImageCandidate, ImageServiceLoader, ImageCandidateRequest } from '@atlas-viewer/iiif-image-api';
 import * as _iiif_vault__ from '@iiif/vault/*';
-import { CanvasNormalized, InternationalString, ImageService, AnnotationPageNormalized, ContentResource, IIIFExternalWebResource, SpecificResource, AnnotationNormalized, CollectionNormalized, Reference, ManifestNormalized, RangeNormalized, SearchService, Annotation, ExternalWebResource, W3CAnnotationTarget, Selector } from '@iiif/presentation-3';
-import { ImageServiceLoader, ImageCandidateRequest, ImageCandidate } from '@atlas-viewer/iiif-image-api';
 import * as _iiif_vault_helpers from '@iiif/vault-helpers';
 
-declare const AnnotationContext: React.FC<{
-    annotation: string;
-}>;
-
-declare const CanvasContext: React.FC<{
-    canvas: string;
-}>;
-
-declare const CollectionContext: React.FC<{
-    collection: string;
-}>;
-
-declare const ManifestContext: React.FC<{
-    manifest: string;
-}>;
-
-declare const RangeContext: React.FC<{
-    range: string;
-}>;
-
-declare type ResourceContextType = {
-    collection?: string;
-    manifest?: string;
-    range?: string;
-    canvas?: string;
-    annotation?: string;
-};
-declare const ResourceReactContext: React.Context<ResourceContextType>;
-declare const useResourceContext: () => ResourceContextType;
-declare const ResourceProvider: React.FC<{
-    value: ResourceContextType;
-}>;
-
-declare const ReactVaultContext: React.Context<{
-    vault: Vault | null;
-    setVaultInstance: (vault: Vault) => void;
-}>;
-declare const VaultProvider: React.FC<{
-    vault?: Vault;
-    useGlobal?: boolean;
-    vaultOptions?: VaultOptions;
-    resources?: ResourceContextType;
-}>;
-
-declare function useContextBridge(): {
-    VaultContext: {
-        vault: _iiif_vault__.Vault | null;
-        setVaultInstance: (vault: _iiif_vault__.Vault) => void;
-    };
-    ResourceContext: ResourceContextType;
-    SimpleViewerReactContext: {
-        setCurrentCanvasId: (newId: string | ((prev: string) => string)) => void;
-        setCurrentCanvasIndex: (newId: number | ((prev: number) => number)) => void;
-        currentCanvasIndex: number;
-        pagingView: boolean;
-        totalCanvases: number;
-        nextCanvas: () => void;
-        previousCanvas: () => void;
-    };
-    VisibleCanvasReactContext: string[];
-};
-declare const ContextBridge: React.FC<{
-    bridge: ReturnType<typeof useContextBridge>;
-}>;
-
-declare const VisibleCanvasReactContext: React.Context<string[]>;
-declare function useVisibleCanvases(): CanvasNormalized[];
-
-declare const ImageServiceLoaderContext: React.Context<ImageServiceLoader>;
-declare function useImageServiceLoader(): ImageServiceLoader;
+declare function Viewer({ children, errorFallback, outerContainerProps, ...props }: AtlasProps & {
+    height?: number | string;
+    width?: number | string;
+    resizeHash?: number;
+    containerProps?: any;
+    outerContainerProps?: any;
+    aspectRatio?: number;
+    errorFallback?: any;
+} & {
+    children: ReactNode;
+}): JSX.Element;
 
 interface SingleChoice {
     type: 'single-choice';
@@ -171,8 +117,8 @@ declare type SingleVideo = {
     url: string;
     format: string;
     duration: number;
-    target: TemporalBoxSelector;
-    selector: TemporalBoxSelector;
+    target: TemporalSelector | TemporalBoxSelector;
+    selector: TemporalSelector | TemporalBoxSelector;
 };
 declare type AudioSequence = {
     type: 'SoundSequence';
@@ -186,6 +132,46 @@ declare type AnnotationPageDescription = {
     pages: AnnotationPageNormalized[];
 };
 
+declare type ImageServiceLoaderType = (imageService: any | undefined, { height, width }: {
+    height: number;
+    width: number;
+}) => ImageService | undefined;
+declare function useLoadImageService(): readonly [ImageServiceLoaderType, Record<string, string>];
+
+declare function parseSpecificResource(resource: ContentResource): any[];
+interface Paintables {
+    choice: ChoiceDescription | null;
+    types: string[];
+    items: Array<{
+        type: string;
+        resource: IIIFExternalWebResource | SpecificResource;
+        target: any;
+        selector: any;
+    }>;
+}
+declare function getPaintables(vault: Vault, paintingAnnotations: AnnotationNormalized[], enabledChoices: string[]): Paintables;
+declare const emptyActions: {
+    makeChoice: () => void;
+};
+declare const unknownResponse: UseRenderingStrategy[0];
+declare const unsupportedStrategy: (reason: string) => UseRenderingStrategy[0];
+
+declare type SingleImageStrategy = {
+    type: 'images';
+    image: ImageWithOptionalService;
+    images: Array<ImageWithOptionalService>;
+    choice?: ChoiceDescription;
+    annotations?: AnnotationPageDescription;
+};
+declare function getImageStrategy(canvas: CanvasNormalized, paintables: Paintables, loadImageService: ImageServiceLoaderType): RenderingStrategy;
+
+declare type Single3DModelStrategy = {
+    type: '3d-model';
+    model: ExternalWebResource;
+    choice?: ChoiceDescription;
+    annotations?: AnnotationPageDescription;
+};
+
 declare type MediaStrategy = {
     type: 'media';
     media: SingleAudio | SingleVideo | AudioSequence | VideoSequence;
@@ -203,13 +189,7 @@ declare type UnknownStrategy = {
     reason?: string;
     annotations?: AnnotationPageDescription;
 };
-declare type RenderingStrategy = SingleImageStrategy | MediaStrategy | ComplexTimelineStrategy | UnknownStrategy;
-
-declare type ImageServiceLoaderType = (imageService: any | undefined, { height, width }: {
-    height: number;
-    width: number;
-}) => ImageService | undefined;
-declare function useLoadImageService(): readonly [ImageServiceLoaderType, Record<string, string>];
+declare type RenderingStrategy = SingleImageStrategy | MediaStrategy | ComplexTimelineStrategy | Single3DModelStrategy | UnknownStrategy;
 
 declare type StrategyActions = {
     makeChoice: (id: string, options?: {
@@ -225,32 +205,184 @@ declare type UseRenderingStrategyOptions = {
 };
 declare function useRenderingStrategy(options?: UseRenderingStrategyOptions): UseRenderingStrategy;
 
-declare function parseSpecificResource(resource: ContentResource): any[];
-interface Paintables {
-    choice: ChoiceDescription | null;
-    types: string[];
-    items: Array<{
-        type: string;
-        resource: IIIFExternalWebResource | SpecificResource;
-        target: any;
-        selector: any;
+declare type CanvasProps = {
+    x?: number;
+    y?: number;
+    onCreated?: any;
+    onChoiceChange?: (choice?: ChoiceDescription) => void;
+    registerActions?: (actions: StrategyActions) => void;
+    defaultChoices?: Array<{
+        id: string;
+        opacity?: number;
     }>;
-}
-declare function getPaintables(vault: Vault, paintingAnnotations: AnnotationNormalized[], enabledChoices: string[]): Paintables;
-declare const emptyActions: {
-    makeChoice: () => void;
+    isStatic?: boolean;
+    children?: ReactNode;
+    renderViewerControls?: (strategy: SingleImageStrategy) => ReactNode;
+    renderMediaControls?: (strategy: MediaStrategy) => ReactNode;
+    strategies?: Array<RenderingStrategy['type']>;
 };
-declare const unknownResponse: UseRenderingStrategy[0];
-declare const unsupportedStrategy: (reason: string) => UseRenderingStrategy[0];
+declare function RenderCanvas({ x, y, onChoiceChange, registerActions, defaultChoices, isStatic, renderViewerControls, renderMediaControls, strategies, children, }: CanvasProps): JSX.Element | null;
 
-declare type SingleImageStrategy = {
-    type: 'images';
+declare function RenderImage({ id, image, thumbnail, isStatic, x, y, annotations, children, }: {
+    id: string;
     image: ImageWithOptionalService;
-    images: Array<ImageWithOptionalService>;
-    choice?: ChoiceDescription;
-    annotations?: AnnotationPageDescription;
+    thumbnail?: ImageCandidate;
+    isStatic?: boolean;
+    x?: number;
+    y?: number;
+    annotations?: ReactNode;
+    children?: ReactNode;
+}): JSX.Element;
+
+declare const CanvasPanel: {
+    RenderImage: typeof RenderImage;
+    RenderCanvas: typeof RenderCanvas;
+    RenderAnnotationPage: React.FC<{
+        page: _iiif_presentation_3.AnnotationPageNormalized | _iiif_presentation_3.AnnotationPage;
+        className?: string | undefined;
+    }>;
+    RenderAnnotation: React.FC<{
+        id: string;
+        className?: string | undefined;
+        style?: _atlas_viewer_atlas.BoxStyle | undefined;
+        interactive?: boolean | undefined;
+    }>;
+    Viewer: typeof Viewer;
 };
-declare function getImageStrategy(canvas: CanvasNormalized, paintables: Paintables, loadImageService: ImageServiceLoaderType): RenderingStrategy;
+
+declare function AnnotationContext({ annotation, children }: {
+    annotation: string;
+    children: ReactNode;
+}): JSX.Element;
+
+declare function CanvasContext({ canvas, children }: {
+    canvas: string;
+    children: ReactNode;
+}): JSX.Element;
+
+declare function CollectionContext({ collection, children }: {
+    collection: string;
+    children: ReactNode;
+}): JSX.Element;
+
+declare function ManifestContext({ manifest, children }: {
+    manifest: string;
+    children: ReactNode;
+}): JSX.Element;
+
+declare type MediaPlayerState = {
+    isPlaying: boolean;
+    isMuted: boolean;
+    playRequested: boolean;
+    volume: number;
+    isFinished: boolean;
+    duration: number;
+};
+declare type MediaPlayerActions = {
+    play(): void;
+    pause(): void;
+    playPause(): void;
+    mute(): void;
+    unmute(): void;
+    toggleMute(): void;
+    setVolume(volume: number): void;
+    setDurationPercent(percent: number): void;
+    setTime(time: number): void;
+};
+declare function formatTime(time: number): string;
+declare function useSimpleMediaPlayer(props: {
+    duration: number;
+}): readonly [
+    {
+        element: RefObject<HTMLAudioElement | HTMLVideoElement>;
+        currentTime: RefObject<HTMLDivElement>;
+        progress: RefObject<HTMLDivElement>;
+    },
+    MediaPlayerState,
+    MediaPlayerActions
+];
+
+declare function useMediaState(): MediaPlayerState;
+declare function useMediaActions(): MediaPlayerActions;
+declare function useMediaElements(): {
+    element: RefObject<HTMLAudioElement | HTMLVideoElement>;
+    currentTime: RefObject<HTMLDivElement>;
+    progress: RefObject<HTMLDivElement>;
+};
+declare function MediaPlayerProvider({ actions, state, children, currentTime, progress, element, }: {
+    actions: MediaPlayerActions;
+    state: MediaPlayerState;
+    children: ReactNode;
+    currentTime: RefObject<HTMLDivElement>;
+    progress: RefObject<HTMLDivElement>;
+    element: RefObject<HTMLAudioElement | HTMLVideoElement>;
+}): JSX.Element;
+
+declare const PortalContext: React__default.Context<HTMLDivElement | null>;
+declare const OverlayPortalContext: React__default.Context<HTMLDivElement | null>;
+declare function CanvasPortal({ children, overlay }: {
+    children: ReactNode;
+    overlay?: boolean;
+}): null;
+
+declare function RangeContext({ range, children }: {
+    range: string;
+    children: ReactNode;
+}): JSX.Element;
+
+declare type ResourceContextType = {
+    collection?: string;
+    manifest?: string;
+    range?: string;
+    canvas?: string;
+    annotation?: string;
+};
+declare const ResourceReactContext: React__default.Context<ResourceContextType>;
+declare const useResourceContext: () => ResourceContextType;
+declare function ResourceProvider({ value, children }: {
+    value: ResourceContextType;
+    children: ReactNode;
+}): JSX.Element;
+
+declare const ReactVaultContext: React__default.Context<{
+    vault: Vault | null;
+    setVaultInstance: (vault: Vault) => void;
+}>;
+declare function VaultProvider({ vault, vaultOptions, useGlobal, resources, children, }: {
+    vault?: Vault;
+    useGlobal?: boolean;
+    vaultOptions?: VaultOptions;
+    resources?: ResourceContextType;
+    children: ReactNode;
+}): JSX.Element;
+
+declare function useContextBridge(): {
+    VaultContext: {
+        vault: _iiif_vault__.Vault | null;
+        setVaultInstance: (vault: _iiif_vault__.Vault) => void;
+    };
+    ResourceContext: ResourceContextType;
+    SimpleViewerReactContext: {
+        setCurrentCanvasId: (newId: string | ((prev: string) => string)) => void;
+        setCurrentCanvasIndex: (newId: number | ((prev: number) => number)) => void;
+        currentCanvasIndex: number;
+        pagingView: boolean;
+        totalCanvases: number;
+        nextCanvas: () => void;
+        previousCanvas: () => void;
+    };
+    VisibleCanvasReactContext: string[];
+};
+declare function ContextBridge(props: {
+    bridge: ReturnType<typeof useContextBridge>;
+    children: ReactNode;
+}): JSX.Element;
+
+declare const VisibleCanvasReactContext: React__default.Context<string[]>;
+declare function useVisibleCanvases(): CanvasNormalized[];
+
+declare const ImageServiceLoaderContext: React__default.Context<ImageServiceLoader>;
+declare function useImageServiceLoader(): ImageServiceLoader;
 
 declare function useAnnotation(options?: {
     id: string;
@@ -424,9 +556,17 @@ declare function useVirtualAnnotationPage(): readonly [AnnotationPageNormalized
     readonly removeAnnotation: (id: string | Annotation | VaultActivatedAnnotation | AnnotationNormalized) => void;
 }];
 
+declare function useVirtualAnnotationPageContext(): readonly [AnnotationPageNormalized | null, {
+    readonly addAnnotation: (id: string | AnnotationNormalized | VaultActivatedAnnotation | Annotation, atIndex?: number | undefined) => void;
+    readonly removeAnnotation: (id: string | AnnotationNormalized | VaultActivatedAnnotation | Annotation) => void;
+}];
+declare function VirtualAnnotationProvider({ children }: {
+    children: any;
+}): JSX.Element;
+
 declare type SupportedTarget = {
     type: 'SpecificResource';
-    source: ExternalWebResource | {
+    source: ExternalWebResource$1 | {
         id: string;
         type: 'Unknown' | 'Canvas' | 'Range' | 'Manifest';
         partOf?: Array<{
@@ -464,11 +604,12 @@ declare type SimpleViewerContext = {
     nextCanvas: () => void;
     previousCanvas: () => void;
 };
-declare const SimpleViewerReactContext: React.Context<SimpleViewerContext>;
-declare const SimpleViewerProvider: FC<{
+declare const SimpleViewerReactContext: React__default.Context<SimpleViewerContext>;
+declare function SimpleViewerProvider(props: {
     manifest: string;
     pagingEnabled?: boolean;
-}>;
+    children: ReactNode;
+}): JSX.Element;
 declare function useSimpleViewer(): SimpleViewerContext;
 
-export { AnnotationContext, AnnotationPageDescription, AudioSequence, BoxSelector, CanvasContext, ChoiceDescription, CollectionContext, ComplexChoice, ComplexTimelineStrategy, ContextBridge, ImageServiceLoaderContext, ImageServiceLoaderType, ImageServiceRequestOptions, ImageWithOptionalService, ManifestContext, MediaStrategy, Paintables, ParsedSelector, PointSelector, RangeContext, ReactVaultContext, RenderingStrategy, ResourceContextType, ResourceProvider, ResourceReactContext, ResourceRequestOptions, SimpleViewerProvider, SimpleViewerReactContext, SingleAudio, SingleChoice, SingleImageStrategy, SingleVideo, StrategyActions, SupportedSelector, SupportedSelectors, SupportedTarget, TemporalBoxSelector, TemporalSelector, UnknownStrategy, UseRenderingStrategy, UseRenderingStrategyOptions, VaultActivatedAnnotation, VaultProvider, VideoSequence, VisibleCanvasReactContext, emptyActions, expandTarget, flattenAnnotationPageIds, getImageStrategy, getPaintables, parseSelector, parseSpecificResource, unknownResponse, unsupportedStrategy, useAnnotation, useAnnotationPageManager, useAnnotationsAtTime, useCanvas, useCanvasClock, useCollection, useContextBridge, useDispatch, useEventListener, useExistingVault, useExternalCollection, useExternalManifest, useExternalResource, useImageService, useImageServiceLoader, useImageTile, useLoadImageService, useManifest, usePaintables, usePaintingAnnotations, useRange, useRenderingStrategy, useResourceContext, useResourceEvents, useResources, useSearchService, useSimpleViewer, useStyleHelper, useStyles, useThumbnail, useVault, useVaultEffect, useVaultSelector, useVirtualAnnotationPage, useVisibleCanvases };
+export { AnnotationContext, AnnotationPageDescription, AudioSequence, BoxSelector, CanvasContext, CanvasPanel, CanvasPortal, ChoiceDescription, CollectionContext, ComplexChoice, ComplexTimelineStrategy, ContextBridge, ImageServiceLoaderContext, ImageServiceLoaderType, ImageServiceRequestOptions, ImageWithOptionalService, ManifestContext, MediaPlayerActions, MediaPlayerProvider, MediaPlayerState, MediaStrategy, OverlayPortalContext, Paintables, ParsedSelector, PointSelector, PortalContext, RangeContext, ReactVaultContext, RenderingStrategy, ResourceContextType, ResourceProvider, ResourceReactContext, ResourceRequestOptions, SimpleViewerProvider, SimpleViewerReactContext, SingleAudio, SingleChoice, SingleImageStrategy, SingleVideo, StrategyActions, SupportedSelector, SupportedSelectors, SupportedTarget, TemporalBoxSelector, TemporalSelector, UnknownStrategy, UseRenderingStrategy, UseRenderingStrategyOptions, VaultActivatedAnnotation, VaultProvider, VideoSequence, VirtualAnnotationProvider, VisibleCanvasReactContext, emptyActions, expandTarget, flattenAnnotationPageIds, formatTime, getImageStrategy, getPaintables, parseSelector, parseSpecificResource, unknownResponse, unsupportedStrategy, useAnnotation, useAnnotationPageManager, useAnnotationsAtTime, useCanvas, useCanvasClock, useCollection, useContextBridge, useDispatch, useEventListener, useExistingVault, useExternalCollection, useExternalManifest, useExternalResource, useImageService, useImageServiceLoader, useImageTile, useLoadImageService, useManifest, useMediaActions, useMediaElements, useMediaState, usePaintables, usePaintingAnnotations, useRange, useRenderingStrategy, useResourceContext, useResourceEvents, useResources, useSearchService, useSimpleMediaPlayer, useSimpleViewer, useStyleHelper, useStyles, useThumbnail, useVault, useVaultEffect, useVaultSelector, useVirtualAnnotationPage, useVirtualAnnotationPageContext, useVisibleCanvases };