@orangelogic/design-system 2.108.0 → 2.109.0

package/library/packages/hybrid/book-reader/src/react/page-flip/render/HTMLRender.d.ts

@@ -0,0 +1,58 @@
+import { PageFlip } from '../PageFlip';
+import { FlipSetting } from '../Settings';
+import { Render } from './Render';
+
+/**
+ * Class responsible for rendering the HTML book
+ */
+export declare class HTMLRender extends Render {
+    /** Parent HTML Element */
+    private readonly element;
+    /** Pages List as HTMLElements */
+    private outerShadow;
+    private innerShadow;
+    private hardShadow;
+    private hardInnerShadow;
+    /**
+     * @constructor
+     *
+     * @param {PageFlip} app - PageFlip object
+     * @param {FlipSetting} setting - Configuration object
+     * @param {HTMLElement} element - Parent HTML Element
+     */
+    constructor(app: PageFlip, setting: FlipSetting, element: HTMLElement);
+    private createShadows;
+    clearShadow(): void;
+    reload(): void;
+    /**
+     * Draw inner shadow to the hard page
+     */
+    private drawHardInnerShadow;
+    /**
+     * Draw outer shadow to the hard page
+     */
+    private drawHardOuterShadow;
+    /**
+     * Draw inner shadow to the soft page
+     */
+    private drawInnerShadow;
+    /**
+     * Draw outer shadow to the soft page
+     */
+    private drawOuterShadow;
+    /**
+     * Draw left static page
+     */
+    private drawLeftPage;
+    /**
+     * Draw right static page
+     */
+    private drawRightPage;
+    /**
+     * Draw the next page at the time of flipping
+     */
+    private drawBottomPage;
+    protected drawFrame(): void;
+    private clear;
+    update(): void;
+}

package/library/packages/hybrid/book-reader/src/react/page-flip/render/Render.d.ts

@@ -0,0 +1,233 @@
+import { PageRect, Point, RectPoints } from '../BasicTypes';
+import { FlipDirection } from '../flip/Flip';
+import { Page } from '../page/Page';
+import { PageFlip } from '../PageFlip';
+import { FlipSetting } from '../Settings';
+
+export type FrameAction = () => void;
+type AnimationSuccessAction = () => void;
+/**
+ * Type describing calculated values for drop shadows
+ */
+export type Shadow = {
+    /** The angle of the shadows relative to the book */
+    angle: number;
+    /** Flipping Direction, the direction of the shadow gradients */
+    direction: FlipDirection;
+    /** Base shadow opacity */
+    opacity: number;
+    /** Shadow Position Start Point */
+    pos: Point;
+    /** Flipping progress in percent (0 - 100) */
+    progress: number;
+    /** Base width shadow */
+    width: number;
+};
+/**
+ * Type describing the animation process
+ * Only one animation process can be started at a same time
+ */
+type AnimationProcess = {
+    /** Total animation duration */
+    duration: number;
+    /** Animation duration of one frame */
+    durationFrame: number;
+    /** List of frames in playback order. Each frame is a function. */
+    frames: FrameAction[];
+    /** Сallback at the end of the animation */
+    onAnimateEnd: AnimationSuccessAction;
+    /** Animation start time (Global Timer) */
+    startedAt: number;
+};
+/**
+ * Book orientation
+ */
+export declare const enum Orientation {
+    LANDSCAPE = "landscape",
+    PORTRAIT = "portrait"
+}
+/**
+ * Class responsible for rendering the book
+ */
+export declare abstract class Render {
+    protected setting: FlipSetting;
+    protected readonly app: PageFlip;
+    /** Left static book page */
+    protected leftPage: Page | null;
+    /** Right static book page */
+    protected rightPage: Page | null;
+    /** Page currently flipping */
+    protected flippingPage: Page | null;
+    /** Next page at the time of flipping */
+    protected bottomPage: Page | null;
+    /** Current flipping direction */
+    protected direction: FlipDirection | null;
+    /** Current book orientation */
+    protected orientation: Orientation | null;
+    /** Сurrent state of the shadows */
+    protected shadow: Shadow | null;
+    /** Сurrent animation process */
+    protected animation: AnimationProcess | null;
+    /** Page borders while flipping */
+    protected pageRect: RectPoints | null;
+    /** Current book area */
+    private boundsRect;
+    private isStop;
+    /** Timer started from start of rendering */
+    protected timer: number;
+    /**
+     * Safari browser definitions for resolving a bug with a css property clip-area
+     *
+     * https://bugs.webkit.org/show_bug.cgi?id=126207
+     */
+    private safari;
+    protected constructor(app: PageFlip, setting: FlipSetting);
+    /**
+     * Rendering action on each requestAnimationFrame call. The entire rendering process is performed only in this method
+     */
+    protected abstract drawFrame(): void;
+    /**
+     * Reload the render area, after update pages
+     */
+    abstract reload(): void;
+    /**
+     * Executed when requestAnimationFrame is called. Performs the current animation process and call drawFrame()
+     *
+     * @param timer
+     */
+    render(timer: number): void;
+    /**
+     * Running requestAnimationFrame, and rendering process
+     */
+    start(): void;
+    /**
+     * Start a new animation process
+     *
+     * @param {FrameAction[]} frames - Frame list
+     * @param {number} duration - total animation duration
+     * @param {AnimationSuccessAction} onAnimateEnd - Animation callback function
+     */
+    startAnimation(frames: FrameAction[], duration: number, onAnimateEnd: AnimationSuccessAction): void;
+    /**
+     * End the current animation process and call the callback
+     */
+    finishAnimation(): void;
+    /**
+     * Recalculate the size of the displayed area, and update the page orientation
+     */
+    update(): void;
+    /**
+     * Calculate the size and position of the book depending on the parent element and configuration parameters
+     */
+    private calculateBoundsRect;
+    /**
+     * Set the current parameters of the drop shadow
+     *
+     * @param {Point} pos - Shadow Position Start Point
+     * @param {number} angle - The angle of the shadows relative to the book
+     * @param {number} progress - Flipping progress in percent (0 - 100)
+     * @param {FlipDirection} direction - Flipping Direction, the direction of the shadow gradients
+     */
+    setShadowData(pos: Point, angle: number, progress: number, direction: FlipDirection): void;
+    /**
+     * Clear shadow
+     */
+    clearShadow(): void;
+    /**
+     * Get parent block offset width
+     */
+    getBlockWidth(): number;
+    /**
+     * Get parent block offset height
+     */
+    getBlockHeight(): number;
+    /**
+     * Get current flipping direction
+     */
+    getDirection(): FlipDirection | null;
+    /**
+     * Сurrent size and position of the book
+     */
+    getRect(): PageRect | null;
+    /**
+     * Get configuration object
+     */
+    getSettings(): FlipSetting;
+    /**
+     * Get current book orientation
+     */
+    getOrientation(): Orientation | null;
+    /**
+     * Set page area while flipping
+     *
+     * @param direction
+     */
+    setPageRect(pageRect: RectPoints): void;
+    /**
+     * Set flipping direction
+     *
+     * @param direction
+     */
+    setDirection(direction: FlipDirection): void;
+    /**
+     * Set right static book page
+     *
+     * @param page
+     */
+    setRightPage(page: Page | null): void;
+    /**
+     * Set left static book page
+     * @param page
+     */
+    setLeftPage(page: Page | null): void;
+    /**
+     * Set next page at the time of flipping
+     * @param page
+     */
+    setBottomPage(page: Page | null): void;
+    /**
+     * Set currently flipping page
+     *
+     * @param page
+     */
+    setFlippingPage(page: Page | null): void;
+    /**
+     * Coordinate conversion function. Window coordinates -> to book coordinates
+     *
+     * @param {Point} pos - Global coordinates relative to the window
+     * @returns {Point} Coordinates relative to the book
+     */
+    convertToBook(pos: Point): Point;
+    isSafari(): boolean;
+    /**
+     * Coordinate conversion function. Window coordinates -> to current coordinates of the working page
+     *
+     * @param {Point} pos - Global coordinates relative to the window
+     * @param {FlipDirection} direction  - Current flipping direction
+     *
+     * @returns {Point} Coordinates relative to the work page
+     */
+    convertToPage(pos: Point, direction?: FlipDirection): Point;
+    /**
+     * Coordinate conversion function. Coordinates relative to the work page -> Window coordinates
+     *
+     * @param {Point} pos - Coordinates relative to the work page
+     * @param {FlipDirection} direction  - Current flipping direction
+     *
+     * @returns {Point} Global coordinates relative to the window
+     */
+    convertToGlobal(pos: Point, direction?: FlipDirection): Point | null;
+    /**
+     * Casting the coordinates of the corners of the rectangle in the coordinates relative to the window
+     *
+     * @param {RectPoints} rect - Coordinates of the corners of the rectangle relative to the work page
+     * @param {FlipDirection} direction  - Current flipping direction
+     *
+     * @returns {RectPoints} Coordinates of the corners of the rectangle relative to the window
+     */
+    convertRectToGlobal(rect: RectPoints, direction?: FlipDirection): RectPoints;
+    updateSetting(setting: FlipSetting): void;
+    getFlippingPage(): Page | null;
+    stop(): void;
+}
+export {};

package/library/packages/hybrid/book-reader/src/react/page-flip/ui/CanvasUI.d.ts

@@ -0,0 +1,17 @@
+import { PageFlip } from '../PageFlip';
+import { FlipSetting } from '../Settings';
+import { UI } from './UI';
+
+/**
+ * UI for canvas mode
+ */
+export declare class CanvasUI extends UI {
+    private readonly canvas;
+    constructor(inBlock: HTMLElement, app: PageFlip, setting: FlipSetting);
+    private resizeCanvas;
+    /**
+     * Get canvas element
+     */
+    getCanvas(): HTMLCanvasElement;
+    update(): void;
+}

package/library/packages/hybrid/book-reader/src/react/page-flip/ui/HTMLUI.d.ts

@@ -0,0 +1,19 @@
+import { PageFlip } from '../PageFlip';
+import { FlipSetting } from '../Settings';
+import { UI } from './UI';
+
+/**
+ * UI for HTML mode
+ */
+export declare class HTMLUI extends UI {
+    private items;
+    constructor(inBlock: HTMLElement, app: PageFlip, setting: FlipSetting, items: NodeListOf<HTMLElement> | HTMLElement[]);
+    clear(): void;
+    /**
+     * Update page list from HTMLElements
+     *
+     * @param {(NodeListOf<HTMLElement>|HTMLElement[])} items - List of pages as HTML Element
+     */
+    updateItems(items: NodeListOf<HTMLElement> | HTMLElement[]): void;
+    update(): void;
+}

package/library/packages/hybrid/book-reader/src/react/page-flip/ui/UI.d.ts

@@ -0,0 +1,78 @@
+import { Point } from '../BasicTypes';
+import { PageFlip } from '../PageFlip';
+import { Orientation } from '../render/Render';
+import { FlipSetting } from '../Settings';
+
+export type SwipeData = {
+    point: Point;
+    time: number;
+};
+/**
+ * UI Class, represents work with DOM
+ */
+export declare abstract class UI {
+    protected readonly parentElement: HTMLElement;
+    protected readonly app: PageFlip;
+    protected readonly wrapper: HTMLElement;
+    protected distElement: HTMLElement;
+    private touchPoint;
+    private readonly swipeTimeout;
+    private readonly swipeDistance;
+    protected inBlock: HTMLElement;
+    private onResize;
+    /**
+     * @constructor
+     *
+     * @param {HTMLElement} inBlock - Root HTML Element
+     * @param {PageFlip} app - PageFlip instanse
+     * @param {FlipSetting} setting - Configuration object
+     */
+    protected constructor(inBlock: HTMLElement, app: PageFlip, setting: FlipSetting);
+    /**
+     * Destructor. Remove all HTML elements and all event handlers
+     */
+    destroy(): void;
+    /**
+     * Updating child components when resizing
+     */
+    abstract update(): void;
+    /**
+     * Get parent element for book
+     *
+     * @returns {HTMLElement}
+     */
+    getDistElement(): HTMLElement;
+    /**
+     * Get wrapper element
+     *
+     * @returns {HTMLElement}
+     */
+    getWrapper(): HTMLElement;
+    /**
+     * Updates styles and sizes based on book orientation
+     *
+     * @param {Orientation} orientation - New book orientation
+     */
+    setOrientationStyle(orientation: Orientation): void;
+    protected removeHandlers(): void;
+    protected setHandlers(): void;
+    /**
+     * Convert global coordinates to relative book coordinates
+     *
+     * @param x
+     * @param y
+     */
+    private getMousePos;
+    private checkTarget;
+    private onMouseDown;
+    private onTouchStart;
+    private onMouseUp;
+    private onMouseMove;
+    private onTouchMove;
+    private onTouchEnd;
+    updateSize(width: number, height: number): void;
+    /**
+     * Destructor. Remove all HTML elements and all event handlers
+     */
+    clear(): void;
+}

package/library/packages/hybrid/book-reader/src/react/types.d.ts

@@ -0,0 +1,206 @@
+import { RenderTask } from 'pdfjs-dist/types/src/display/api.js';
+import { DocumentProps, PageProps } from 'react-pdf';
+import { Localize } from './contexts/TranslationContext';
+
+export type Context = {
+    bookContext: {
+        bookBackground: {
+            value: string;
+        };
+        bookID: {
+            value: string;
+        };
+        bookName: {
+            value: string;
+        };
+        bookReaderMode: {
+            value: string;
+        };
+        isInColdStorage: {
+            value: boolean;
+        };
+        pageNumber: {
+            value: number;
+        };
+        showCover: {
+            value: boolean;
+        };
+        sourceUrl: {
+            value: string;
+        };
+        totalPages: {
+            value: number;
+        };
+        viewMode: {
+            value: string;
+        };
+    };
+    configurationData: {
+        darkMode: boolean;
+        enableContextMenuGetLink: boolean;
+        rangeChunkSize: number;
+    };
+    fetchCortexApi: (relativeUrl: string, init: any, params?: any) => any;
+    fireEvent: (event: string, data: any) => void;
+    localize: Localize;
+    onClosed: (callback: () => void) => void;
+    pdfWorkerUrl?: string;
+    sessionID: {
+        getEntityId: () => string;
+    };
+};
+export type ParsedContext = {
+    bookBackground: string;
+    bookID: string;
+    bookName: string;
+    bookReaderMode: BookReaderMode;
+    darkMode: boolean;
+    enableContextMenuGetLink: boolean;
+    isInColdStorage: boolean;
+    localize: Localize;
+    pageNumber: number;
+    rangeChunkSize: number;
+    showCover: boolean;
+    sourceUrl: string;
+    totalPages: number;
+    viewMode: string;
+};
+export type PDFTextMatch = Record<number | string, Array<{
+    begin: {
+        divIdx: number;
+        offset: number;
+    };
+    end: {
+        divIdx: number;
+        offset: number;
+    };
+    matchOrder: number;
+}>>;
+export type TextSearch = {
+    caseSensitive: boolean;
+    keyword: string;
+    matchWord: boolean;
+};
+export type MatchedPosition = {
+    index: number;
+    length: number;
+    matchOrder: number;
+    textItemIndex: number;
+};
+export type ResultPage = {
+    matchedPositions: MatchedPosition[];
+    pageNumber: number;
+};
+export type TextSearchResult = {
+    matchesCount: number;
+    pages: ResultPage[];
+    textSearch: TextSearch;
+};
+type LoadCallback = Required<DocumentProps>['onLoadSuccess'];
+type PageLoadCallback = Required<PageProps>['onLoadSuccess'];
+export type PDFDocumentProxy = Parameters<LoadCallback>[0];
+export type PDFPageProxy = Parameters<PageLoadCallback>[0];
+export type TextItem = {
+    dir: string;
+    fontName: string;
+    hasEOL: boolean;
+    height: number;
+    itemIndex: number;
+    pageIndex: number;
+    pageNumber: number;
+    str: string;
+    transform: number[];
+    width: number;
+};
+export type PageView = {
+    imageData?: ImageData | null;
+    isRendering?: boolean;
+    loading: boolean;
+    page: PDFPageProxy | null;
+    pageID: string;
+    pageNumber: number;
+    renderTask?: RenderTask | null;
+    renderedAt?: number;
+    representativeID?: string;
+    scale: number;
+    visitedAt?: number;
+};
+export type BookContext = {
+    onLoadedPDFPageProxy: (page: PDFPageProxy) => void;
+    pageViews: {
+        [key: number]: PageView;
+    };
+    requestPDFPageProxy: (pageNumbers: number[]) => void;
+    requestRenderPDFPage: (pageNumber: number) => Promise<null | ImageData | undefined>;
+} | null;
+export declare enum BookReaderMode {
+    IMAGE = "Image",
+    PDF = "Pdf"
+}
+export type SearchQuery = string;
+export type ImageTextPosition = {
+    matchOrder: number;
+    x1: number;
+    x2: number;
+    y1: number;
+    y2: number;
+};
+export type ImageTextSearchResultPage = {
+    matchedPositions: ImageTextPosition[];
+    pageNumber: number;
+};
+export type ImageTextSearchResult = {
+    matchesCount: number;
+    pages: ImageTextSearchResultPage[];
+    q: string;
+};
+export type PageCallback = PDFPageProxy & {
+    height: number;
+    originalHeight: number;
+    originalWidth: number;
+    width: number;
+};
+export type Asset = {
+    hasFormatInColdStorage: boolean;
+    height: number;
+    imageUrl: string;
+    originalUrl: string;
+    pageID: string;
+    pageName: string;
+    pageNumber: number;
+    representativeID?: string;
+    rotation?: number;
+    version?: string;
+    width: number;
+};
+export type AssetView = {
+    asset: Asset;
+    loading: boolean;
+};
+export interface BookHandle {
+    changePage: (pageNumber: number) => void;
+}
+export type ImageSearchResponsePar = {
+    boxes: Array<{
+        b: number;
+        l: number;
+        page: number;
+        r: number;
+        t: number;
+    }>;
+    page: number;
+};
+export type ImageSearchResponse = {
+    ia: string;
+    indexed: boolean;
+    matches: Array<{
+        par: ImageSearchResponsePar[];
+        text: string;
+    }>;
+    page_count: number;
+    q: string;
+};
+export type BreakpointsContext = {
+    containerWidth: number;
+} | null;
+export {};

package/library/packages/hybrid/book-reader/src/react/utils/CalculateScale.d.ts

@@ -0,0 +1 @@
+export declare const calculateScale: (parentRect: DOMRect, pageWidth: number, pageHeight: number, viewMode: number, scaleOption: string) => number;

package/library/packages/hybrid/book-reader/src/react/utils/EscapeRegex.d.ts

@@ -0,0 +1,2 @@
+declare const escapeRegex: (str: string) => string;
+export default escapeRegex;

package/library/packages/hybrid/book-reader/src/react/utils/Fullscreen.d.ts

@@ -0,0 +1,4 @@
+export declare const requestFullscreen: (element?: HTMLElement) => void;
+export declare const isFullscreen: () => any;
+export declare const exitFullscreen: () => void;
+export declare const isFullscreenEnabled: () => boolean;

package/library/packages/hybrid/book-reader/src/react/utils/GetActivePage.d.ts

@@ -0,0 +1 @@
+export declare const getActivePage: (page: number, viewMode: number, showCover: boolean) => number[];

package/library/packages/hybrid/book-reader/src/react/utils/GetIIIFImageUrl.d.ts

@@ -0,0 +1,7 @@
+export declare const getIIIFImageUrl: (urlTemplate: string, width?: number, height?: number, version?: string) => string;
+/**
+ * Get IIIF url but specific for GIFs
+ * @param urlTemplate
+ * @param version
+ */
+export declare const getIIIFImageUrlGif: (urlTemplate: string, version?: string) => string;

package/library/packages/hybrid/book-reader/src/react/utils/GetVisiblePageNumber.d.ts

@@ -0,0 +1 @@
+export declare const getVisiblePageNumber: (root?: ParentNode | null) => number[];

package/library/packages/hybrid/book-reader/src/react/utils/IsImageBook.d.ts

@@ -0,0 +1,3 @@
+import { BookReaderMode } from '../types';
+
+export declare const isImageBook: (bookMode: BookReaderMode) => bookMode is BookReaderMode.IMAGE;

package/library/packages/hybrid/book-reader/src/react/utils/IsPDFBook.d.ts

@@ -0,0 +1,3 @@
+import { BookReaderMode } from '../types';
+
+export declare const isPDFBook: (bookMode: BookReaderMode) => bookMode is BookReaderMode.PDF;

package/library/packages/hybrid/book-reader/src/react/utils/MergeRefs.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A function that merges React refs into one.
+ * Supports both functions and ref objects created using createRef() and useRef().
+ *
+ * Usage:
+ * ```tsx
+ * <div ref={mergeRefs(ref1, ref2, ref3)} />
+ * ```
+ *
+ * @param {(React.Ref<T> | undefined)[]} inputRefs Array of refs
+ * @returns {React.Ref<T> | React.RefCallback<T>} Merged refs
+ */
+declare function mergeRefs<T>(...inputRefs: Array<React.Ref<T> | undefined>): React.Ref<T> | React.RefCallback<T>;
+export default mergeRefs;

package/library/packages/hybrid/book-reader/src/react/utils/NormalizeString.d.ts

@@ -0,0 +1 @@
+export declare const normalizeString: (str: string) => string;