@imtf/dms-core 1.0.0-beta.1

package/core/containers/PDFTronViewer/components/LightViewer/index.d.ts

@@ -0,0 +1,6 @@
+import { Inode } from "../../../../providers/Inodes/types";
+type LightViewerProps = {
+    inode: Inode;
+};
+declare const _default: import("react").MemoExoticComponent<({ inode }: LightViewerProps) => import("react/jsx-runtime").JSX.Element>;
+export default _default;

package/core/containers/PDFTronViewer/components/LightViewer/utils.d.ts

@@ -0,0 +1,5 @@
+import { Core, WebViewerInstance } from "@pdftron/webviewer";
+/**
+ * Whether to turn every form inputs (widget annotations) readonly or not
+ */
+export declare const toggleFormReadOnly: (instance: WebViewerInstance, annotations: (typeof Core.Annotations)[], readOnly: boolean) => void;

package/core/containers/PDFTronViewer/components/Viewer/types.d.ts

@@ -0,0 +1,7 @@
+import { Core } from "@pdftron/webviewer";
+import { Locale } from "../../../../providers/Localization/types";
+export type CustomStamps = Core.Tools.RubberStampCreateTool.CustomStampData & {
+    title?: Record<Locale, string | undefined>;
+    subtitle?: Record<Locale, string | undefined>;
+};
+export type ViewerStatus = "viewing" | "editing" | "saving";

package/core/containers/PDFTronViewer/constants.d.ts

@@ -0,0 +1,22 @@
+export declare const CSS_PDFTRON: string;
+export declare const ACCEPT_IMAGE = "image/x-png,image/gif,image/jpeg,image/png";
+export declare const MODAL_TYPES: {
+    readonly ABORT: "imtf/PDFTronViewer/modal/ABORT";
+};
+export declare const SUPPORTED_MIME_TYPES: {
+    "application/pdf": string;
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": string;
+    "application/msword": string;
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": string;
+    "application/vnd.ms-excel": string;
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation": string;
+    "application/vnd.ms-powerpoint": string;
+    "image/bmp": string;
+    "image/gif": string;
+    "image/png": string;
+    "image/jpeg": string;
+    "application/xml": string;
+    "text/xml": string;
+    "application/json": string;
+    "text/plain": string;
+};

package/core/containers/PDFTronViewer/messages.d.ts

@@ -0,0 +1,123 @@
+declare const _default: {
+    warningAnnotation: {
+        id: string;
+        defaultMessage: string;
+    };
+    applySavedAnnotations: {
+        id: string;
+        defaultMessage: string;
+    };
+    cancelSavedAnnotations: {
+        id: string;
+        defaultMessage: string;
+    };
+    composeButton: {
+        id: string;
+        defaultMessage: string;
+    };
+    editCompanionButton: {
+        id: string;
+        defaultMessage: string;
+    };
+    saveButton: {
+        id: string;
+        defaultMessage: string;
+    };
+    savingButton: {
+        id: string;
+        defaultMessage: string;
+    };
+    savedButton: {
+        id: string;
+        defaultMessage: string;
+    };
+    annotationLost: {
+        id: string;
+        defaultMessage: string;
+    };
+    compareVersionsButton: {
+        id: string;
+        defaultMessage: string;
+    };
+    fileSaved: {
+        id: string;
+        defaultMessage: string;
+    };
+    compareFirstFile: {
+        id: string;
+        defaultMessage: string;
+    };
+    compareFirstFileColor: {
+        id: string;
+        defaultMessage: string;
+    };
+    compareSecondFile: {
+        id: string;
+        defaultMessage: string;
+    };
+    compareSecondFileColor: {
+        id: string;
+        defaultMessage: string;
+    };
+    compareLastVersion: {
+        id: string;
+        defaultMessage: string;
+    };
+    compareFieldVersion: {
+        id: string;
+        defaultMessage: string;
+    };
+    compareRunCompare: {
+        id: string;
+        defaultMessage: string;
+    };
+    compareDescription: {
+        id: string;
+        defaultMessage: string;
+    };
+    compareReset: {
+        id: string;
+        defaultMessage: string;
+    };
+    fileSavingError: {
+        id: string;
+        defaultMessage: string;
+    };
+    fileLoadingError: {
+        id: string;
+        defaultMessage: string;
+    };
+    fileImageLoadingError: {
+        id: string;
+        defaultMessage: string;
+    };
+    pdfErrorProcess: {
+        id: string;
+        defaultMessage: string;
+    };
+    printButton: {
+        id: string;
+        defaultMessage: string;
+    };
+    downloadButton: {
+        id: string;
+        defaultMessage: string;
+    };
+    openFullScreen: {
+        id: string;
+        defaultMessage: string;
+    };
+    exitFullScreen: {
+        id: string;
+        defaultMessage: string;
+    };
+    editSignatureButton: {
+        id: string;
+        defaultMessage: string;
+    };
+    collectSignatureButton: {
+        id: string;
+        defaultMessage: string;
+    };
+};
+export default _default;

package/core/containers/PDFTronViewer/slice.d.ts

@@ -0,0 +1,9 @@
+import { ViewerStatus } from "./components/Viewer/types";
+export type ViewerState = {
+    viewerStatus: ViewerStatus;
+};
+export declare const setStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    status: ViewerStatus;
+}, "viewer/setStatus">;
+declare const _default: import("redux").Reducer<ViewerState>;
+export default _default;

package/core/containers/SearchView/utils.d.ts

@@ -0,0 +1,8 @@
+export declare function createFacetsQueryParams(values: {
+    [key: string]: string | string[] | undefined;
+}, fixedQuery?: string, sort?: string, lastTouchedField?: string, loadFirst?: boolean): URLSearchParams;
+/**
+ * Returns a stable and sorted string from an URLSearchParams object
+ * @param searchParams A URLSearchParams object
+ */
+export declare function getInvariantStringFromUrlSearchParams(searchParams?: URLSearchParams): string;

package/core/containers/TreeView/actions.d.ts

@@ -0,0 +1,197 @@
+import { MouseEvent } from "react";
+import { SupportedItem } from "../../providers/App/types";
+import { CLEAR } from "./constants";
+export type ExtraParams = {
+    /**
+     * Injected items are pagined, so it corresponds to a part of some items's children.
+     * If length of items equal the pagination limit, we will assume that there is a next page.
+     */
+    pagined?: boolean;
+    /**
+     * An iterable list of items oid that will be displayed directly as expanded
+     * (can be usefull if we have to load and display a tree sctructure at once)
+     */
+    expandedItems?: string[];
+    /**
+     * Parent Oid of the items to add (if not provided, items will be added to the root)
+     */
+    oid?: "root" | string;
+    /**
+     * Set / change the root oid of the treeView
+     */
+    rootOid?: string;
+    /**
+     * Set / change the limit of the treeView
+     */
+    limit?: number;
+    /**
+     * Clear the existing items before or after getting the new ones
+     */
+    clear?: (typeof CLEAR)[keyof typeof CLEAR];
+};
+export declare function initialize(params: Record<string, any>): {
+    type: string;
+    payload: {
+        params: Record<string, any>;
+    };
+};
+/**
+ * Add provided items to the treeView according to treeView configuration.
+ */
+export declare function addItems(items: SupportedItem[], extraParams: ExtraParams): {
+    type: string;
+    payload: {
+        /**
+         * Injected items are pagined, so it corresponds to a part of some items's children.
+         * If length of items equal the pagination limit, we will assume that there is a next page.
+         */
+        pagined?: boolean;
+        /**
+         * An iterable list of items oid that will be displayed directly as expanded
+         * (can be usefull if we have to load and display a tree sctructure at once)
+         */
+        expandedItems?: string[];
+        /**
+         * Parent Oid of the items to add (if not provided, items will be added to the root)
+         */
+        oid?: "root" | string;
+        /**
+         * Set / change the root oid of the treeView
+         */
+        rootOid?: string;
+        /**
+         * Set / change the limit of the treeView
+         */
+        limit?: number;
+        /**
+         * Clear the existing items before or after getting the new ones
+         */
+        clear?: (typeof CLEAR)[keyof typeof CLEAR];
+        items: SupportedItem[];
+    };
+};
+/**
+ * Add provided item collections to the treeView according to treeView configuration.
+ * Please refer to addItems for settings
+ */
+export declare function addItemCollections(itemCollections: {
+    [oid: string]: {
+        [oid: string]: SupportedItem;
+    };
+}, extraParams?: Record<string, any>): {
+    type: string;
+    payload: {
+        itemCollections: {
+            [oid: string]: {
+                [oid: string]: SupportedItem;
+            };
+        };
+    };
+};
+/**
+ * Remove a list of items
+ */
+export declare function removeItems(items: SupportedItem[]): {
+    type: string;
+    payload: {
+        items: SupportedItem[];
+    };
+};
+/**
+ * Check if provided items list should be removed or added to the treeView
+ * e.g. check if a moved items (thus with new parentOid) are still present in the treeView
+ */
+export declare function checkItems(items: SupportedItem[], previousItems?: SupportedItem[], mergeOnNameConflict?: boolean): {
+    type: string;
+    payload: {
+        items: SupportedItem[];
+        previousItems: SupportedItem[] | undefined;
+        mergeOnNameConflict: boolean;
+    };
+};
+export declare function alterSelection(item: SupportedItem, orderedItemList: {
+    item: SupportedItem;
+}[], event?: MouseEvent<HTMLElement>): {
+    type: string;
+    payload: {
+        item: SupportedItem;
+        orderedItemList: {
+            item: SupportedItem;
+        }[];
+        keys: {
+            altKey: boolean | undefined;
+            metaKey: boolean | undefined;
+            ctrlKey: boolean | undefined;
+            shiftKey: boolean | undefined;
+        };
+        type: any;
+    };
+};
+export declare function setSelection(oids: string[]): {
+    type: string;
+    payload: {
+        oids: string[];
+    };
+};
+export declare function setLoading(loading?: boolean): {
+    type: string;
+    payload: {
+        loading: boolean;
+    };
+};
+export declare function expandItem(itemOid: string): {
+    type: string;
+    payload: {
+        itemOid: string;
+    };
+};
+export declare function setFields(fields: any): {
+    type: string;
+    payload: {
+        fields: any;
+    };
+};
+export declare function collapseItem(itemOid: string, orderedItemList: SupportedItem[]): {
+    type: string;
+    payload: {
+        itemOid: string;
+        orderedItemList: SupportedItem[];
+    };
+};
+export declare function clean(): {
+    type: string;
+};
+export declare function empty(params?: {}): {
+    type: string;
+    payload: {};
+};
+export declare function setOrder(order: any): {
+    type: string;
+    payload: {
+        order: any;
+    };
+};
+export declare function showSelectColumnsModal(originalFields: any, 
+/** The treeview fields key for settings purposes. */
+treeviewFieldsKey: string): {
+    payload: {
+        type: string;
+        props: Partial<{
+            [key: string]: unknown;
+            disableEscapeKeyDown: boolean;
+            disableBackdropClick: boolean;
+            correlationId: string;
+            fullWidth: boolean;
+            maxWidth: import("@mui/material").DialogProps["maxWidth"];
+            blocker: boolean;
+            onClose: () => void;
+        }> | undefined;
+    };
+    type: "modal/showModal";
+};
+export declare function expandAllChildren(itemOid: string): {
+    type: string;
+    payload: {
+        itemOid: string;
+    };
+};

package/core/containers/TreeView/constants.d.ts

@@ -0,0 +1,36 @@
+export declare const INITIALIZE = "imtf/TreeView/INITIALIZE";
+export declare const ADD_ITEMS = "imtf/TreeView/ADD_ITEMS";
+export declare const ADD_ITEM_COLLECTIONS = "imtf/TreeView/ADD_ITEM_COLLECTIONS";
+export declare const REMOVE_ITEMS = "imtf/TreeView/REMOVE_ITEMS";
+export declare const CHECK_ITEMS = "imtf/TreeView/CHECK_ITEMS";
+export declare const ALTER_SELECTION = "imtf/TreeView/ALTER_SELECTION";
+export declare const SET_SELECTION = "imtf/TreeView/SET_SELECTION";
+export declare const SET_LOADING = "imtf/TreeView/SET_LOADING";
+export declare const COLLAPSE_ITEM = "imtf/TreeView/COLLAPSE_ITEM";
+export declare const EXPAND_ITEM = "imtf/TreeView/EXPAND_ITEM";
+export declare const EXPAND_ALL_CHILDREN = "imtf/TreeView/EXPAND_ALL_CHILDREN";
+export declare const CLEAN = "imtf/TreeView/CLEAN";
+export declare const EMPTY = "imtf/TreeView/EMPTY";
+export declare const SET_FIELDS = "imtf/TreeView/SET_FIELDS";
+export declare const SET_ORDER = "imtf/TreeView/SET_ORDER";
+export declare const IDENTIFIER: {
+    readonly MAIN: "MAIN";
+    readonly FAVORITES: "FAVORITES";
+    readonly SEARCH: "SEARCH";
+    readonly INSPECTOR_DOCUMENT_LIST: "INSPECTOR_DOCUMENT_LIST";
+    readonly SEARCH_FILING: "SEARCH_FILING";
+    readonly TRASH: "TRASH";
+};
+export declare const CLEAR: {
+    readonly LEADING: "LEADING";
+    readonly TRAILING: "TRAILING";
+};
+export declare const MODAL_TYPES: {
+    readonly SELECT_COLUMNS: "imtf/TreeView/modal/SELECT_COLUMNS";
+};
+export declare const MIN_COLUMN_WIDTH = 60;
+export declare const HORIZONTAL_MARGINS = 10;
+export declare const SCROLLBAR_WIDTH = 17;
+export declare const HEADER_HEIGHT = 48;
+export declare const PAGINATION_SIZE_DEFAULT = 50;
+export declare const DEFAULT_ROW_HEIGHT = 48;

package/core/containers/TreeView/types.d.ts

@@ -0,0 +1,46 @@
+import { Map, MapOf, Set } from "immutable";
+import type { SupportedItem } from "../../providers/App/types";
+import { SearchMask } from "../../providers/Definitions/types";
+import { COLUMN_TYPES } from "../../../core/components/TreeViewCell/constants";
+import { LOAD_MORE } from "../../../core/constants/kinds";
+export type TreeViewState = MapOf<{
+    loading: boolean;
+    items: Set<string>;
+    rootOid: string | null;
+    limit: number;
+    offsets: Map<string, number>;
+    selectedItems: string[];
+    expandedItems: string[];
+    fields: TreeViewField[] | undefined;
+    fieldsHash: string | undefined;
+    order: string[] | undefined;
+}>;
+export type TreeViewFieldKey = "DOSSIER" | "FOLDER" | "HOME" | "FAVORITES" | "TRASH" | "ACCOUNT_PROFILES" | `SEARCH_MASK_${SearchMask["name"]}`;
+export type TreeViewField<T = keyof typeof COLUMN_TYPES> = {
+    align?: "left" | "right" | "center";
+    kind?: "dms-core.ui.TableHeaderCell";
+    hidden?: boolean;
+    label: string;
+    message?: string;
+    margin?: number;
+    maxWidth?: number | `${string}%` | `${string}px`;
+    minWidth?: number | `${string}%` | `${string}px`;
+    name: string;
+    origin?: string;
+    resizable?: boolean;
+    type: T;
+    width?: number | `${string}%` | `${string}px`;
+};
+export type TableRow = {
+    kind: "dms-core.ui.TableRow";
+    cells: {
+        kind: "dms-core.ui.ItemTableCell";
+        value: string;
+    }[];
+    item: SupportedItem | {
+        kind: typeof LOAD_MORE;
+        oid: string;
+        [key: string]: any;
+    };
+    status: string;
+};

package/core/providers/Actions/Context.d.ts

@@ -0,0 +1,3 @@
+import { ActionsContextType } from "./types";
+declare const ActionsContext: import("react").Context<ActionsContextType>;
+export default ActionsContext;

package/core/providers/Actions/constants.d.ts

@@ -0,0 +1,74 @@
+export declare const ACTION_GROUPS: {
+    readonly EDIT_ELEMENT: "EDIT_ELEMENT";
+    readonly EXTRA_ACTION: "EXTRA_ACTION";
+    readonly FOLDER_OPTIONS: "FOLDER_OPTIONS";
+    readonly LINK_TO_OTHER: "LINK_TO_OTHER";
+    readonly EDIT_GLOBAL: "EDIT_GLOBAL";
+    readonly ADMIN: "ADMIN";
+    readonly OTHER: "OTHER";
+    readonly DROPZONE: "DROPZONE";
+    readonly SEARCH: "SEARCH";
+};
+export declare const DOWNLOAD_UNSOPPORTED_FILES = true;
+export declare const TRIGGER_TARGET: {
+    readonly SELF: "SELF";
+    readonly NEW_TAB: "NEW_TAB";
+    readonly NEW_WINDOW: "NEW_WINDOW";
+};
+export declare const ACTION_GROUPS_ELEMENTS: readonly [{
+    readonly id: "EDIT_ELEMENT";
+    readonly name: {
+        id: string;
+        defaultMessage: string;
+    };
+    readonly orderingWeight: 3;
+}, {
+    readonly id: "EXTRA_ACTION";
+    readonly name: {
+        id: string;
+        defaultMessage: string;
+    };
+    readonly orderingWeight: 4;
+}, {
+    readonly id: "FOLDER_OPTIONS";
+    readonly name: {
+        id: string;
+        defaultMessage: string;
+    };
+    readonly orderingWeight: 5;
+}, {
+    readonly id: "LINK_TO_OTHER";
+    readonly name: {
+        id: string;
+        defaultMessage: string;
+    };
+    readonly orderingWeight: 8;
+}, {
+    readonly id: "EDIT_GLOBAL";
+    readonly name: {
+        id: string;
+        defaultMessage: string;
+    };
+    readonly orderingWeight: 9;
+}, {
+    readonly id: "ADMIN";
+    readonly name: {
+        id: string;
+        defaultMessage: string;
+    };
+    readonly orderingWeight: 10;
+}, {
+    readonly id: "SEARCH";
+    readonly name: {
+        id: string;
+        defaultMessage: string;
+    };
+    readonly orderingWeight: 12;
+}, {
+    readonly id: "OTHER";
+    readonly name: {
+        id: string;
+        defaultMessage: string;
+    };
+    readonly orderingWeight: 13;
+}];

package/core/providers/Actions/index.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from "react";
+import { ActionDefinitionCreator, ActionsContextType } from "./types";
+declare const registeredAsyncActions: ActionsContextType["getAsyncActions"][];
+export declare const registerActions: (actions: ActionDefinitionCreator[], getAsyncActions?: (typeof registeredAsyncActions)[number]) => void;
+export default function ActionsProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/core/providers/Actions/messages.d.ts

@@ -0,0 +1,39 @@
+declare const _default: {
+    actionGroupEditElement: {
+        id: string;
+        defaultMessage: string;
+    };
+    actionExtendedGroupEditElement: {
+        id: string;
+        defaultMessage: string;
+    };
+    actionGroupFolderOptions: {
+        id: string;
+        defaultMessage: string;
+    };
+    actionGroupEditGlobal: {
+        id: string;
+        defaultMessage: string;
+    };
+    actionGroupSearch: {
+        id: string;
+        defaultMessage: string;
+    };
+    actionGroupLinkOther: {
+        id: string;
+        defaultMessage: string;
+    };
+    actionGroupAdmin: {
+        id: string;
+        defaultMessage: string;
+    };
+    actionGroupOther: {
+        id: string;
+        defaultMessage: string;
+    };
+    openEachInodeInNewTabOrWindowLimitError: {
+        id: string;
+        defaultMessage: string;
+    };
+};
+export default _default;

package/core/providers/Actions/types.d.ts

@@ -0,0 +1,85 @@
+import { Set } from "immutable";
+import { ContextType, ReactNode } from "react";
+import { IntlShape, MessageDescriptor } from "react-intl";
+import { Location } from "react-router-dom";
+import useEnvironment from "../App/hooks/useEnvironment";
+import { AppCapabilities, SupportedItem } from "../App/types";
+import UploadContext from "../Uploader/Context";
+import { TRIGGER_TARGET } from "./constants";
+export type Items = SupportedItem[];
+export type ActionsContextType = {
+    getActions: (items: Items, extraActions?: ActionDefinition[], extraActionParams?: Record<string, any>) => Action[];
+    getAsyncActions: (items: Items, params?: Partial<ActionParams>) => Promise<ActionDefinition[]>;
+    registerActions: (actions: ActionDefinitionCreator[], getAsyncActions: ActionsContextType["getAsyncActions"]) => void;
+    triggerItems: (items: Items, target?: keyof typeof TRIGGER_TARGET) => void;
+    getRegisteredActions: () => ActionDefinition[];
+};
+export type ActionParams = {
+    alter?: (action: ActionDefinition) => ActionDefinition;
+    filter?: (params: ActionParams, def: ActionDefinition) => boolean;
+    capabilities: AppCapabilities;
+    dirty?: boolean;
+    formatMessage: IntlShape["formatMessage"];
+    dropZoneItems: Items;
+    dropZoneStackOids: Set<string>;
+    environment: ReturnType<typeof useEnvironment>;
+    meta?: string;
+    openEachInodeInNewTabOrWindow: (inodes: Items, shouldOpenInNewWindow: boolean) => void;
+    promptUpdateBinary: ContextType<typeof UploadContext>["promptUpdateBinary"];
+    promptUpload: ContextType<typeof UploadContext>["promptUpload"];
+    treeViewIdentifier?: string;
+    triggerItems: (items: Items, target?: (typeof TRIGGER_TARGET)[keyof typeof TRIGGER_TARGET]) => void;
+    auditMessage?: string;
+    location: Location;
+    accessToken: string | undefined;
+    /**
+     * is a DropZone stack
+     */
+    isStack?: boolean;
+    companionScanDPIResolution: number;
+};
+export type ActionDefinitionCreator = ActionDefinition | (((items: Items, params: Partial<ActionParams>) => ActionDefinition) & {
+    id?: string;
+});
+export type ActionDefinition = {
+    id: string;
+    label: string | MessageDescriptor;
+    group?: string;
+    orderingWeight?: number;
+    shortcut?: string | {
+        label: string;
+        keys: string;
+    };
+    disabled?: boolean;
+    condition?: (items: Items, params: ActionParams) => boolean;
+    action?: (items: Items, params: ActionParams, actionDefinition: ActionDefinition) => void;
+    ActionComponent?: React.ComponentType<{
+        items: SupportedItem[];
+        params: ActionParams;
+        actionDefinition: ActionDefinition;
+        callback: () => void;
+        extra?: Record<string, any>;
+    }>;
+    nonModifying?: boolean;
+    auditMessage?: {
+        messages: {
+            title?: string | ReactNode;
+            text?: string | ReactNode;
+            confirm?: string | ReactNode;
+        };
+    };
+    validation?: {
+        messages: {
+            title?: string | ReactNode;
+            text?: string | ReactNode;
+        };
+    };
+};
+export type Action = {
+    id: ActionDefinition["id"];
+    shortcut: ActionDefinition["shortcut"];
+    group: ActionDefinition["group"];
+    label: ReactNode;
+    action: (() => void) | undefined;
+    disabled: boolean | undefined;
+};

package/core/providers/Actions/utils.d.ts

@@ -0,0 +1,4 @@
+import { Action, ActionDefinition, ActionParams, Items } from "./types";
+export declare function getActions(actionsDefinition: (ActionDefinition | (((items: Items, params: ActionParams) => ActionDefinition) & {
+    id?: string;
+}))[], items: Items, params: ActionParams): Action[];