react-iiif-vault 0.9.15 → 0.9.18

package/.build/types/canvas-panel/Viewer.d.ts

@@ -1,5 +1,5 @@
 import { ReactNode } from 'react';
-import { AtlasProps } from '@atlas-viewer/atlas/dist/types/modules/react-reconciler/Atlas';
+import { AtlasProps } from '@atlas-viewer/atlas';
 export declare function Viewer({ children, errorFallback, outerContainerProps, ...props }: AtlasProps & {
     height?: number | string;
     width?: number | string;

package/.build/types/canvas-panel/index.d.ts

@@ -1,6 +1,7 @@
 import { Viewer } from './Viewer';
 import { RenderCanvas } from './render/Canvas';
 import { RenderImage } from './render/Image';
+import { CanvasBackground } from './render/CanvasBackground';
 export declare const CanvasPanel: {
     RenderImage: typeof RenderImage;
     RenderCanvas: typeof RenderCanvas;
@@ -15,4 +16,5 @@ export declare const CanvasPanel: {
         interactive?: boolean | undefined;
     }>;
     Viewer: typeof Viewer;
+    CanvasBackground: typeof CanvasBackground;
 };

package/.build/types/canvas-panel/render/Canvas.d.ts

@@ -1,8 +1,10 @@
 import { ReactNode } from 'react';
+import { BoxStyle } from '@atlas-viewer/atlas';
 import { ChoiceDescription } from '../../features/rendering-strategy/choice-types';
 import { StrategyActions } from '../../hooks/useRenderingStrategy';
-import { MediaStrategy, RenderingStrategy } from '../../features/rendering-strategy/strategies';
+import { EmptyStrategy, MediaStrategy, RenderingStrategy } from '../../features/rendering-strategy/strategies';
 import { SingleImageStrategy } from '../../features/rendering-strategy/image-strategy';
+import { ImageWithOptionalService } from '../../features/rendering-strategy/resource-types';
 declare type CanvasProps = {
     x?: number;
     y?: number;
@@ -15,9 +17,12 @@ declare type CanvasProps = {
     }>;
     isStatic?: boolean;
     children?: ReactNode;
-    renderViewerControls?: (strategy: SingleImageStrategy) => ReactNode;
+    renderViewerControls?: (strategy: SingleImageStrategy | EmptyStrategy) => ReactNode;
     renderMediaControls?: (strategy: MediaStrategy) => ReactNode;
     strategies?: Array<RenderingStrategy['type']>;
+    backgroundStyle?: BoxStyle;
+    alwaysShowBackground?: boolean;
+    onClickPaintingAnnotation?: (id: string, image: ImageWithOptionalService, e: any) => void;
 };
-export declare function RenderCanvas({ x, y, onChoiceChange, registerActions, defaultChoices, isStatic, renderViewerControls, renderMediaControls, strategies, children, }: CanvasProps): JSX.Element | null;
+export declare function RenderCanvas({ x, y, onChoiceChange, registerActions, defaultChoices, isStatic, renderViewerControls, renderMediaControls, strategies, backgroundStyle, alwaysShowBackground, onClickPaintingAnnotation, children, }: CanvasProps): JSX.Element | null;
 export {};

package/.build/types/canvas-panel/render/CanvasBackground.d.ts

@@ -0,0 +1,4 @@
+import { BoxStyle } from '@atlas-viewer/atlas';
+export declare function CanvasBackground({ style }: {
+    style?: BoxStyle;
+}): JSX.Element | null;

package/.build/types/canvas-panel/render/Image.d.ts

@@ -1,13 +1,13 @@
 import { ImageCandidate } from '@atlas-viewer/iiif-image-api';
 import { ReactNode } from 'react';
 import { ImageWithOptionalService } from '../../features/rendering-strategy/resource-types';
-export declare function RenderImage({ id, image, thumbnail, isStatic, x, y, annotations, children, }: {
+export declare function RenderImage({ id, image, thumbnail, isStatic, x, y, children, onClick, }: {
     id: string;
     image: ImageWithOptionalService;
     thumbnail?: ImageCandidate;
     isStatic?: boolean;
     x?: number;
     y?: number;
-    annotations?: ReactNode;
     children?: ReactNode;
+    onClick?: (e: any) => void;
 }): JSX.Element;

package/.build/types/context/AnnotationPageContext.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+export declare function AnnotationPageContext({ annotationPage, children }: {
+    annotationPage: string;
+    children: ReactNode;
+}): JSX.Element;

package/.build/types/context/ContextBridge.d.ts

@@ -5,15 +5,7 @@ export declare function useContextBridge(): {
         setVaultInstance: (vault: import("@iiif/vault/*").Vault) => void;
     };
     ResourceContext: import("./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;
-    };
+    SimpleViewerReactContext: import("..").SimpleViewerContext;
     VisibleCanvasReactContext: string[];
 };
 export declare function ContextBridge(props: {

package/.build/types/context/PortalContext.d.ts

@@ -1,6 +1,7 @@
 import React, { ReactNode } from 'react';
-export declare const PortalContext: React.Context<HTMLDivElement | null>;
-export declare const OverlayPortalContext: React.Context<HTMLDivElement | null>;
+import { Root } from 'react-dom/client';
+export declare const PortalContext: React.Context<Root | null>;
+export declare const OverlayPortalContext: React.Context<Root | null>;
 export declare function CanvasPortal({ children, overlay }: {
     children: ReactNode;
     overlay?: boolean;

package/.build/types/context/ResourceContext.d.ts

@@ -5,6 +5,7 @@ export declare type ResourceContextType = {
     range?: string;
     canvas?: string;
     annotation?: string;
+    annotationPage?: string;
 };
 export declare const ResourceReactContext: React.Context<ResourceContextType>;
 export declare const useResourceContext: () => ResourceContextType;

package/.build/types/features/rendering-strategy/3d-strategy.d.ts

@@ -2,7 +2,7 @@ import { CanvasNormalized } from '@iiif/presentation-3';
 import { Paintables } from './rendering-utils';
 import { AnnotationPageDescription } from './resource-types';
 import { ChoiceDescription } from './choice-types';
-import { ExternalWebResource } from '@iiif/presentation-3/resources/annotation';
+import { ExternalWebResource } from '@iiif/presentation-3';
 import { RenderingStrategy } from './strategies';
 export declare type Single3DModelStrategy = {
     type: '3d-model';

package/.build/types/features/rendering-strategy/rendering-utils.d.ts

@@ -1,12 +1,14 @@
-import { AnnotationNormalized, ContentResource, IIIFExternalWebResource, SpecificResource } from '@iiif/presentation-3';
+import { AnnotationNormalized, CanvasNormalized, ContentResource, IIIFExternalWebResource, PointSelector, SpecificResource, W3CAnnotationTarget } from '@iiif/presentation-3';
 import { Vault } from '@iiif/vault';
 import { ChoiceDescription } from './choice-types';
 import { UseRenderingStrategy } from '../../hooks/useRenderingStrategy';
+import { BoxSelector, SupportedTarget, TemporalBoxSelector } from '@iiif/vault-helpers';
 export declare function parseSpecificResource(resource: ContentResource): any[];
 export interface Paintables {
     choice: ChoiceDescription | null;
     types: string[];
     items: Array<{
+        annotationId: string;
         type: string;
         resource: IIIFExternalWebResource | SpecificResource;
         target: any;
@@ -14,8 +16,10 @@ export interface Paintables {
     }>;
 }
 export declare function getPaintables(vault: Vault, paintingAnnotations: AnnotationNormalized[], enabledChoices: string[]): Paintables;
+export declare function getParsedTargetSelector(canvas: CanvasNormalized, target: W3CAnnotationTarget | W3CAnnotationTarget[]): [TemporalBoxSelector | BoxSelector | PointSelector | null, SupportedTarget['source']];
 export declare const emptyActions: {
     makeChoice: () => void;
 };
 export declare const unknownResponse: UseRenderingStrategy[0];
 export declare const unsupportedStrategy: (reason: string) => UseRenderingStrategy[0];
+export declare const emptyStrategy: (width: number, height: number) => UseRenderingStrategy[0];

package/.build/types/features/rendering-strategy/resource-types.d.ts

@@ -2,6 +2,7 @@ import { AnnotationPageNormalized, ImageService } from '@iiif/presentation-3';
 import { BoxSelector, TemporalBoxSelector, TemporalSelector } from '@iiif/vault-helpers/annotation-targets';
 export declare type ImageWithOptionalService = {
     id: string;
+    annotationId: string;
     type: 'Image';
     service?: ImageService;
     width?: number;
@@ -15,6 +16,7 @@ export declare type ImageWithOptionalService = {
 };
 export declare type SingleAudio = {
     type: 'Sound';
+    annotationId: string;
     url: string;
     format: string;
     duration: number;
@@ -23,6 +25,7 @@ export declare type SingleAudio = {
 };
 export declare type SingleVideo = {
     type: 'Video';
+    annotationId: string;
     url: string;
     format: string;
     duration: number;

package/.build/types/features/rendering-strategy/strategies.d.ts

@@ -2,6 +2,7 @@ import { AnnotationPageDescription, AudioSequence, ImageWithOptionalService, Sin
 import { ChoiceDescription } from './choice-types';
 import { SingleImageStrategy } from './image-strategy';
 import { Single3DModelStrategy } from './3d-strategy';
+import { TextualContentStrategy } from './textual-content-strategy';
 export declare type MediaStrategy = {
     type: 'media';
     media: SingleAudio | SingleVideo | AudioSequence | VideoSequence;
@@ -14,9 +15,17 @@ export declare type ComplexTimelineStrategy = {
     choice?: ChoiceDescription;
     annotations?: AnnotationPageDescription;
 };
+export declare type EmptyStrategy = {
+    type: 'empty';
+    image: null;
+    images: [];
+    height: number;
+    width: number;
+    annotations?: AnnotationPageDescription;
+};
 export declare type UnknownStrategy = {
     type: 'unknown';
     reason?: string;
     annotations?: AnnotationPageDescription;
 };
-export declare type RenderingStrategy = SingleImageStrategy | MediaStrategy | ComplexTimelineStrategy | Single3DModelStrategy | UnknownStrategy;
+export declare type RenderingStrategy = SingleImageStrategy | MediaStrategy | ComplexTimelineStrategy | Single3DModelStrategy | TextualContentStrategy | UnknownStrategy | EmptyStrategy;

package/.build/types/features/rendering-strategy/textual-content-strategy.d.ts

@@ -0,0 +1,17 @@
+import { CanvasNormalized, InternationalString } from '@iiif/presentation-3';
+import { ChoiceDescription } from './choice-types';
+import { AnnotationPageDescription } from './resource-types';
+import { Paintables } from './rendering-utils';
+import { RenderingStrategy } from './strategies';
+import { SupportedTarget } from '@iiif/vault-helpers';
+export declare type TextualContentStrategy = {
+    type: 'textual-content';
+    items: {
+        annotationId: string;
+        text: InternationalString;
+        target: SupportedTarget | null;
+    }[];
+    choice?: ChoiceDescription;
+    annotations?: AnnotationPageDescription;
+};
+export declare function getTextualContentStrategy(canvas: CanvasNormalized, paintables: Paintables): RenderingStrategy;

package/.build/types/future-helpers/ranges.d.ts

@@ -0,0 +1,6 @@
+import { Vault } from '@iiif/vault';
+import { ManifestNormalized, RangeNormalized, Reference } from '@iiif/presentation-3';
+export declare function findFirstCanvasFromRange(vault: Vault, range: RangeNormalized): null | Reference<'Canvas'>;
+export declare function findAllCanvasesInRange(vault: Vault, range: RangeNormalized): Array<Reference<'Canvas'>>;
+export declare function findManifestSelectedRange(vault: Vault, manifest: ManifestNormalized, canvasId: string): null | RangeNormalized;
+export declare function findSelectedRange(vault: Vault, range: RangeNormalized, canvasId: string): null | RangeNormalized;

package/.build/types/future-helpers/sequences.d.ts

@@ -0,0 +1,6 @@
+import { ManifestNormalized, RangeNormalized, Reference } from '@iiif/presentation-3';
+import { Vault } from '@iiif/vault';
+export declare function getVisibleCanvasesFromCanvasId(vault: Vault, manifestOrRange: ManifestNormalized | RangeNormalized, canvasId: string | null, preventPaged?: boolean): Reference<'Canvas'>[];
+export declare function getManifestSequence(vault: Vault, manifestOrRange: ManifestNormalized | RangeNormalized, { disablePaging }?: {
+    disablePaging?: boolean;
+}): [Reference<'Canvas'>[], number[][]];

package/.build/types/hooks/useAnnotationPage.d.ts

@@ -0,0 +1,8 @@
+import { AnnotationPageNormalized } from '@iiif/presentation-3';
+export declare function useAnnotationPage(options?: {
+    id: string;
+}): AnnotationPageNormalized | undefined;
+export declare function useAnnotationPage<T>(options?: {
+    id: string;
+    selector: (annotation: AnnotationPageNormalized) => T;
+}, deps?: any[]): T | undefined;

package/.build/types/hooks/useCanvasSubset.d.ts

@@ -0,0 +1,2 @@
+import { Reference } from '@iiif/presentation-3';
+export declare function useCanvasSubset(idsOrRefs?: Array<string | Reference>): Reference<"Canvas">[];

package/.build/types/index.d.ts

@@ -1,5 +1,6 @@
 export * from './canvas-panel';
 export * from './context/AnnotationContext';
+export * from './context/AnnotationPageContext';
 export * from './context/CanvasContext';
 export * from './context/CollectionContext';
 export * from './context/ManifestContext';
@@ -18,10 +19,12 @@ export * from './features/rendering-strategy/rendering-utils';
 export * from './features/rendering-strategy/resource-types';
 export * from './features/rendering-strategy/strategies';
 export * from './hooks/useAnnotation';
+export * from './hooks/useAnnotationPage';
 export * from './hooks/useAnnotationPageManager';
 export * from './hooks/useAnnotationsAtTime';
 export * from './hooks/useCanvas';
 export * from './hooks/useCanvasClock';
+export * from './hooks/useCanvasSubset';
 export * from './hooks/useCollection';
 export * from './hooks/useDispatch';
 export * from './hooks/useEventListener';
@@ -52,3 +55,7 @@ export * from './hooks/useRenderingStrategy';
 export * from '@iiif/vault-helpers/annotation-targets';
 export * from './utility/flatten-annotation-page-ids';
 export * from './viewers/SimpleViewerContext';
+export * from './viewers/SimpleViewerContext.hooks';
+export * from './viewers/SimpleViewerContext.types';
+export * from './future-helpers/sequences';
+export * from './future-helpers/ranges';

package/.build/types/viewers/SimpleViewerContext.d.ts

@@ -1,18 +1,6 @@
-import React, { ReactNode } from 'react';
-declare type SimpleViewerContext = {
-    setCurrentCanvasId: (newId: string | ((prev: string) => string)) => void;
-    setCurrentCanvasIndex: (newId: number | ((prev: number) => number)) => void;
-    currentCanvasIndex: number;
-    pagingView: boolean;
-    totalCanvases: number;
-    nextCanvas: () => void;
-    previousCanvas: () => void;
-};
+import React from 'react';
+import { SimpleViewerContext, SimpleViewerProps } from './SimpleViewerContext.types';
 export declare const SimpleViewerReactContext: React.Context<SimpleViewerContext>;
-export declare function SimpleViewerProvider(props: {
-    manifest: string;
-    pagingEnabled?: boolean;
-    children: ReactNode;
-}): JSX.Element;
+export declare function InnerViewerProvider(props: SimpleViewerProps): JSX.Element;
+export declare function SimpleViewerProvider(props: SimpleViewerProps): JSX.Element;
 export declare function useSimpleViewer(): SimpleViewerContext;
-export {};

package/.build/types/viewers/SimpleViewerContext.hooks.d.ts

@@ -0,0 +1,14 @@
+export declare function useCanvasSequence({ startCanvas, disablePaging }: {
+    startCanvas?: string;
+    disablePaging?: boolean;
+}): {
+    visibleItems: string[];
+    cursor: number;
+    items: import("@iiif/presentation-3").Reference<"Canvas">[];
+    sequence: number[][];
+    setSequenceIndex: import("react").Dispatch<import("react").SetStateAction<number>>;
+    setCanvasIndex: (index: number) => void;
+    setCanvasId: (id: string) => void;
+    next: () => void;
+    previous: () => void;
+};

package/.build/types/viewers/SimpleViewerContext.types.d.ts

@@ -0,0 +1,42 @@
+import { Reference } from '@iiif/presentation-3';
+import { ReactNode } from 'react';
+export declare type SimpleViewerContext = {
+    items: Reference<'Canvas'>[];
+    sequence: number[][];
+    setSequenceIndex: (newId: number) => void;
+    setCurrentCanvasId: (newId: string) => void;
+    setCurrentCanvasIndex: (newId: number) => void;
+    currentSequenceIndex: number;
+    nextCanvas: () => void;
+    previousCanvas: () => void;
+};
+export declare type SimpleViewerProps = {
+    manifest: string;
+    pagingEnabled?: boolean;
+    children: ReactNode;
+    startCanvas?: string;
+    rangeId?: string;
+};
+export declare type SimpleViewerReducerState = {
+    sequence: number[][];
+    availableCanvases: Reference<'Canvas'>[];
+    visibleCanvases: Reference<'Canvas'>[];
+    currentCanvas: string | null;
+    isPaged: boolean;
+    rangeId: string | null;
+};
+export interface SimpleViewerActions {
+    setCurrentCanvasId(newId: string): void;
+    setCurrentCanvasIndex(newId: number): void;
+    nextCanvas(): void;
+    previousCanvas(): void;
+    setCurrentRange(newId: string): void;
+    clearRange(): void;
+    setPagingEnabled(isEnabled: boolean): void;
+}
+export declare type SimpleViewerActionsType = {
+    [T in keyof SimpleViewerActions]: {
+        type: T;
+        payload: Parameters<SimpleViewerActions[T]>[0];
+    };
+}[keyof SimpleViewerActions];