@orangelogic/design-system 2.19.0-pr77202.21

package/library/packages/organisms/src/downloader/data/core/worker/events/EventHandler.d.ts

@@ -0,0 +1,16 @@
+import { Event } from './Event';
+import { IEventHub } from './IEventHub';
+
+export declare abstract class EventHandler<T extends Event> {
+    eventType: string;
+    protected hub: IEventHub;
+    private unsubscribeFunc;
+    constructor(eventType: string, hub: IEventHub);
+    abstract handle(event: T): Promise<void>;
+    dispose(): void;
+}
+export declare class CustomEventHandler<T extends Event> extends EventHandler<T> {
+    private action;
+    constructor(eventType: string, hub: IEventHub, action: (event: T) => Promise<void>);
+    handle(event: T): Promise<void>;
+}

package/library/packages/organisms/src/downloader/data/core/worker/events/index.d.ts

@@ -0,0 +1,6 @@
+import { Event } from './Event';
+import { CustomEventHandler, EventHandler } from './EventHandler';
+import { IEventHub } from './IEventHub';
+
+export { Event, EventHandler, CustomEventHandler };
+export type { IEventHub };

package/library/packages/organisms/src/downloader/data/core/worker/external/IDownloadApiClient.d.ts

@@ -0,0 +1,60 @@
+export interface IDownloadApiClient {
+    /** Download actual file chunk */
+    downloadFileChunk: (request: DownloadFileChunkRequest) => Promise<ArrayBuffer>;
+    /** Download actual file chunk directly from cloud */
+    downloadFileChunkFromCloud: (request: DownloadFileChunkFromCloudRequest) => Promise<ArrayBuffer>;
+    /** Get Asset cloud URL */
+    getAssetCloudURL: (request: GetAssetCloudLinkRequest) => Promise<GetAssetCloudLinkResponse>;
+    /** Get all files in download transaction */
+    getFilesInDownloadTransaction: (request: GetFilesInDownloadTransactionRequest) => Promise<GetFilesInDownloadTransactionResponse>;
+}
+export type GetFilesInDownloadTransactionRequest = {
+    transactionID: string;
+};
+export type GetFilesInDownloadTransactionResponse = {
+    directoryName: string;
+    files: FileToDownload[];
+    transactionID: string;
+};
+export type FileToDownload = {
+    /** Approximate file size in bytes (used when file to download is still waiting on Cortex processing) */
+    approximativeSize: number;
+    cloudURLs: string[];
+    exactSize: number;
+    hasRangeRequestSupport: boolean;
+    index: number;
+    path: string;
+    state: FileToDownloadState;
+    supportsDirectCloudURL: boolean;
+};
+export declare enum FileToDownloadState {
+    Missing = "Missing",
+    ReadyForDownload = "ReadyForDownload",
+    WaitingServerProcessing = "WaitingServerProcessing"
+}
+export type DownloadFileChunkRequest = {
+    fileIndex: number;
+    fileSize: number;
+    fromByte: number;
+    onProgressHandler: (downloadedBytes: number) => void;
+    toByte: number;
+    transactionID: string;
+};
+export type DownloadFileChunkFromCloudRequest = {
+    directCloudURL: string;
+    fromByte: number;
+    onProgressHandler: (downloadedBytes: number) => void;
+    toByte: number;
+};
+export type GetAssetCloudLinkRequest = {
+    fileIndex: number;
+    fileSize: number;
+    transactionID: string;
+};
+export type GetAssetCloudLinkResponse = {
+    allCloudURLs: string[];
+    cloudURL: string;
+    fileExists: boolean;
+    fileSize: number;
+    supportsDirectCloudURL: boolean;
+};

package/library/packages/organisms/src/downloader/data/core/worker/external/index.d.ts

@@ -0,0 +1,4 @@
+import { DownloadFileChunkFromCloudRequest, DownloadFileChunkRequest, FileToDownload, FileToDownloadState, GetAssetCloudLinkRequest, GetAssetCloudLinkResponse, GetFilesInDownloadTransactionRequest, GetFilesInDownloadTransactionResponse, IDownloadApiClient } from './IDownloadApiClient';
+
+export { FileToDownloadState };
+export type { DownloadFileChunkFromCloudRequest, DownloadFileChunkRequest, FileToDownload, GetAssetCloudLinkRequest, GetAssetCloudLinkResponse, GetFilesInDownloadTransactionRequest, GetFilesInDownloadTransactionResponse, IDownloadApiClient, };

package/library/packages/organisms/src/downloader/data/core/worker/models/BaseModel.d.ts

@@ -0,0 +1,11 @@
+import { Event } from '../events';
+
+export declare abstract class BaseModel {
+    readonly id: string;
+    version: number;
+    private _events;
+    addEvent(event: Event): void;
+    get events(): Event[];
+    resetEvents(): void;
+    constructor(id: string, version?: number);
+}

package/library/packages/organisms/src/downloader/data/core/worker/models/DownloadChunk.d.ts

@@ -0,0 +1,42 @@
+import { Event } from '../events';
+import { BaseModel } from './BaseModel';
+import { DownloadFile } from './DownloadFile';
+
+export declare class ChunkProcessedEvent extends Event {
+    chunkStart: number;
+    chunkEnd: number;
+    chunkSize: number;
+    fileID: string;
+    static readonly type: string;
+    constructor(chunkStart: number, chunkEnd: number, chunkSize: number, fileID: string);
+}
+export declare class ChunkRetriedEvent extends Event {
+    retryCount: number;
+    fileID: string;
+    static readonly type: string;
+    constructor(retryCount: number, fileID: string);
+}
+/** Download chunk */
+export declare class DownloadChunk extends BaseModel {
+    readonly fromByte: number;
+    readonly toByte: number;
+    readonly path: string;
+    private retryCount;
+    readonly maxRetryCount: number;
+    private processed;
+    readonly file: DownloadFile;
+    constructor(id: string, fromByte: number, toByte: number, path: string, retryCount: number, maxRetryCount: number, processed: boolean, file: DownloadFile, version?: number);
+    static create(file: DownloadFile, fromByte: number, toByte: number, maxRetryCount: number): DownloadChunk;
+    get size(): number;
+    equals(chunk: DownloadChunk): boolean;
+    clone(): DownloadChunk;
+    isProcessed(): boolean;
+    hasFailed(): boolean;
+    inProgress(): boolean;
+    markProcessed(): void;
+    getRetryCount(): number;
+    retry(msg?: string | undefined): void;
+    fail(msg?: string | undefined): void;
+    createProcessedEvent(): ChunkProcessedEvent;
+    createRetriedEvent(): ChunkRetriedEvent;
+}

package/library/packages/organisms/src/downloader/data/core/worker/models/DownloadFile.d.ts

@@ -0,0 +1,170 @@
+import { Event } from '../events';
+import { BaseModel } from './BaseModel';
+import { DownloadChunk } from './DownloadChunk';
+
+export declare class FileAddedEvent extends Event {
+    fileID: string;
+    name: string;
+    path: string;
+    state: DownloadFileState;
+    stateDetails: string;
+    progress: number;
+    size: number;
+    paused: boolean;
+    createDate: number;
+    static readonly type: string;
+    constructor(fileID: string, name: string, path: string, state: DownloadFileState, stateDetails: string, progress: number, size: number, paused: boolean, createDate: number);
+}
+export declare class FileDeletedEvent extends Event {
+    fileID: string;
+    static readonly type: string;
+    constructor(fileID: string);
+}
+export declare class FileModifiedEvent extends Event {
+    fileID: string;
+    name: string;
+    path: string;
+    state: DownloadFileState;
+    stateDetails: string;
+    progress: number;
+    size: number;
+    paused: boolean;
+    createDate: number;
+    static readonly type: string;
+    /**
+     *
+     * @param fileID
+     */
+    constructor(fileID: string, name: string, path: string, state: DownloadFileState, stateDetails: string, progress: number, size: number, paused: boolean, createDate: number);
+}
+export declare class FileMetadataUpdatedEvent extends Event {
+    fileID: string;
+    static readonly type: string;
+    constructor(fileID: string);
+}
+export declare class FileProgressUpdatedEvent extends Event {
+    currentProgress: number;
+    fileSize: number;
+    static readonly type: string;
+    constructor(currentProgress: number, fileSize: number);
+}
+export declare class FileStateChangedEvent extends Event {
+    fileID: string;
+    currentState: DownloadFileState;
+    transactionID: string;
+    static readonly type: string;
+    constructor(fileID: string, currentState: DownloadFileState, transactionID: string);
+}
+export declare class FilePausedEvent extends Event {
+    fileID: string;
+    static readonly type: string;
+    constructor(fileID: string);
+}
+export declare class FileResumedEvent extends Event {
+    fileID: string;
+    static readonly type: string;
+    constructor(fileID: string);
+}
+export declare class FileCancelledEvent extends Event {
+    fileID: string;
+    static readonly type: string;
+    constructor(fileID: string);
+}
+export declare class FileRetriedEvent extends Event {
+    fileID: string;
+    static readonly type: string;
+    constructor(fileID: string);
+}
+/** State of download file */
+export declare enum DownloadFileState {
+    Assembling = "Assembling",
+    Cancelled = "Cancelled",
+    Completed = "Completed",
+    Downloading = "Downloading",
+    Failed = "Failed",
+    Missing = "Missing",
+    ReadyForDownload = "ReadyForDownload",
+    WaitingServerProcessing = "WaitingServerProcessing"
+}
+export declare enum DownloadFileStateDetails {
+    MissingFileErrorMessage = "MissingFileErrorMessage",
+    NetworkErrorMessage = "NetworkErrorMessage",
+    NotEnoughStorageErrorMessage = "NotEnoughStorageErrorMessage"
+}
+export declare const PLACEHOLDER_CLOUD_URL = "__PLACEHOLDER_CLOUD_URL__";
+/** Download file */
+export declare class DownloadFile extends BaseModel {
+    readonly index: number;
+    private exactSize;
+    private approximateSize;
+    private state;
+    stateDetails: string;
+    private progress;
+    private createDate;
+    readonly transactionID: string;
+    private paused;
+    cloudURLs: string[];
+    private _name;
+    get name(): string;
+    private _path;
+    get path(): string;
+    set path(value: string);
+    constructor(id: string, index: number, name: string, path: string, exactSize: number, approximateSize: number, state: DownloadFileState, stateDetails: string, progress: number, createDate: number, transactionID: string, paused?: boolean, cloudURLs?: string[], version?: number);
+    private setState;
+    static create(transactionID: string, index: number, path: string, exactSize?: number, approximateSize?: number, state?: DownloadFileState, directCloudURLs?: string[]): DownloadFile;
+    equals(file: DownloadFile): boolean;
+    clone(): DownloadFile;
+    getProgress(): number;
+    getState(): DownloadFileState;
+    getExactSize(): number;
+    getApproximateSize(): number;
+    get size(): number;
+    isEmpty(): boolean;
+    markReady(): void;
+    markMissing(): void;
+    hasCompleted(): boolean;
+    complete(): void;
+    fail(msg?: string): void;
+    hasFailedOrMissing(): boolean;
+    needToFetchCloudURL(): boolean;
+    canCancel(): boolean;
+    cancel(): void;
+    isCancelled(): boolean;
+    canRetry(): boolean;
+    retry(): void;
+    isPaused(): boolean;
+    canPause(): boolean;
+    pause(): void;
+    canResume(): boolean;
+    resume(): void;
+    startDownloading(): void;
+    hasFinishedDownloading(): boolean;
+    isDownloading(): boolean;
+    updateMetadata(exactSize: number, approxSize: number, path: string, directCloudURLs: string[]): void;
+    increaseProgress(bytes: number): void;
+    createFileAddedEvent(): FileAddedEvent;
+    createFileDeleted(): FileDeletedEvent;
+    createFileModifiedEvent(): FileModifiedEvent;
+    createFileMetadataUpdatedEvent(): FileMetadataUpdatedEvent;
+    createFileProgressUpdatedEvent(): FileProgressUpdatedEvent;
+    createFileStateChangedEvent(): FileStateChangedEvent;
+    createFilePausedEvent(): FilePausedEvent;
+    createFileResumedEvent(): FileResumedEvent;
+    createFileCancelledEvent(): FileCancelledEvent;
+    createFileRetriedEvent(): FileRetriedEvent;
+}
+/** Download file chunks info */
+export declare class ChunkedDownloadFile extends BaseModel {
+    readonly file: DownloadFile;
+    readonly inProgressChunks: DownloadChunk[];
+    readonly inProgressChunksLimit: number;
+    private _nextChunkOffset;
+    get nextChunkOffset(): number;
+    constructor(file: DownloadFile, nextChunkOffset: number, inProgressChunks: DownloadChunk[], inProgressChunksLimit: number, version?: number);
+    static create(file: DownloadFile, chunksLimit: number): ChunkedDownloadFile;
+    equals(chunkedFile: ChunkedDownloadFile): boolean;
+    clone(): ChunkedDownloadFile;
+    hasBeenChunked(): boolean;
+    completelyChunked(): boolean;
+    createChunks(chunkSize: number, maxChunkRetryCount: number, limit?: number): void;
+}

package/library/packages/organisms/src/downloader/data/core/worker/models/DownloadTransaction.d.ts

@@ -0,0 +1,28 @@
+import { Event } from '../events';
+import { BaseModel } from './BaseModel';
+
+export declare class AllTransactionsDeletedEvent extends Event {
+    static readonly type: string;
+}
+/** Download transaction state */
+export declare enum DownloadTransactionState {
+    Completed = "Completed",
+    Failed = "Failed",
+    InProgress = "InProgress",
+    Ready = "Ready"
+}
+/** Download transaction */
+export declare class DownloadTransaction extends BaseModel {
+    readonly location: string;
+    private state;
+    constructor(id: string, location: string, state: DownloadTransactionState, version?: number);
+    static create(id: string, location: string): DownloadTransaction;
+    equals(transaction: DownloadTransaction): boolean;
+    clone(): DownloadTransaction;
+    canAddFiles(): boolean;
+    getState(): DownloadTransactionState;
+    ready(): void;
+    complete(): void;
+    fail(): void;
+    startProcessing(): void;
+}

package/library/packages/organisms/src/downloader/data/core/worker/models/index.d.ts

@@ -0,0 +1,5 @@
+import { ChunkProcessedEvent, ChunkRetriedEvent, DownloadChunk } from './DownloadChunk';
+import { ChunkedDownloadFile, DownloadFile, DownloadFileState, FileAddedEvent, FileDeletedEvent, FileModifiedEvent, FileProgressUpdatedEvent } from './DownloadFile';
+import { AllTransactionsDeletedEvent, DownloadTransaction, DownloadTransactionState } from './DownloadTransaction';
+
+export { DownloadTransaction, DownloadTransactionState, AllTransactionsDeletedEvent, DownloadFile, DownloadFileState, ChunkedDownloadFile, FileProgressUpdatedEvent, FileAddedEvent, FileDeletedEvent, FileModifiedEvent, DownloadChunk, ChunkProcessedEvent, ChunkRetriedEvent, };

package/library/packages/organisms/src/downloader/data/core/worker/storage/index.d.ts

@@ -0,0 +1,34 @@
+import { Event } from '../events';
+
+export declare class NotEnoughStorageSpaceEvent extends Event {
+    static readonly type: string;
+}
+export declare const RESERVED_DEFAULT_ROOT = "__DEFAULT_ROOT__";
+export declare enum StorageError {
+    NotEnoughStorage = "NOT_ENOUGH_STORAGE",
+    PathLimitExceeded = "PATH_LIMIT_EXCEEDED"
+}
+export interface IStorage {
+    combine: (path: string, chunks: Array<{
+        from: number;
+        path: string;
+        to: number;
+    }>) => Promise<boolean>;
+    createDefaultRoot: () => Promise<string | null>;
+    /**
+     * Create root path
+     * @param path
+     * @returns normalized path (i.e. append number if path is duplicate with existing path). NULL if this action was explicitly cancelled by user
+     */
+    createRoot: (path: string) => Promise<string | null>;
+    exists: (path: string) => Promise<boolean>;
+    flushStoredPartial: (path: string) => Promise<boolean>;
+    get: (path: string) => Promise<ArrayBuffer | null>;
+    getDefaultRootName: () => Promise<string | null>;
+    getSize: (path: string) => Promise<number>;
+    remove: (path: string) => Promise<boolean>;
+    removeDefaultRoot: () => Promise<void>;
+    store: (path: string, data: ArrayBuffer) => Promise<boolean>;
+    storePartial: (path: string, offset: number, data: ArrayBuffer) => Promise<boolean>;
+    writable: (path: string) => Promise<boolean>;
+}

package/library/packages/organisms/src/downloader/data/core/worker/utilities/FilePathFixer.d.ts

@@ -0,0 +1,17 @@
+import { ILogger, IUserPromptService } from '.';
+import { DownloadFile } from '../models';
+import { IStorage } from '../storage';
+
+export declare class FilePathFixer {
+    private storage;
+    private userPromptService;
+    private logger;
+    static transactionPathAction: {
+        skipAll: Set<string>;
+        truncateAll: Set<string>;
+    };
+    constructor(storage: IStorage, userPromptService: IUserPromptService, logger: ILogger);
+    shouldFixPath(file: DownloadFile): Promise<boolean>;
+    private truncatePath;
+    tryFixPath(file: DownloadFile, invalidPaths: string[]): Promise<void>;
+}

package/library/packages/organisms/src/downloader/data/core/worker/utilities/IUserPromptService.d.ts

@@ -0,0 +1,27 @@
+export declare enum PromptType {
+    PromptTruncatePath = "PROMPT_TRUNCATE_PATH"
+}
+type BasePrompt = {
+    id?: string;
+};
+export type TruncatePathPrompt = {
+    invalidPaths: string[];
+    type: PromptType.PromptTruncatePath;
+} & BasePrompt;
+export type UserPrompt = TruncatePathPrompt;
+type BasePromptResponse = {
+    replyTo?: string;
+};
+export declare enum TruncatePathAction {
+    Cancel = "CANCEL",
+    TruncateAndDownload = "TRUNCATE_AND_DOWNLOAD"
+}
+export type TruncatePathPromptResponse = {
+    action: TruncatePathAction;
+    type: PromptType.PromptTruncatePath;
+} & BasePromptResponse;
+export type UserPromptResponse = TruncatePathPromptResponse;
+export interface IUserPromptService {
+    prompt: (prompt: UserPrompt) => Promise<UserPromptResponse | null>;
+}
+export {};

package/library/packages/organisms/src/downloader/data/core/worker/utilities/index.d.ts

@@ -0,0 +1,18 @@
+import { BroadcastChannel } from 'broadcast-channel';
+import { WorkerRequest } from '../Requests';
+import { WorkerResponse } from '../Responses';
+import { FilePathFixer } from './FilePathFixer';
+import { ILocker } from './ILocker';
+import { ILogger } from './ILogger';
+import { IRetrier } from './IRetrier';
+import { IUserPromptService, TruncatePathPrompt, TruncatePathPromptResponse, UserPrompt, UserPromptResponse } from './IUserPromptService';
+
+export type { IRetrier, ILogger, ILocker };
+export type { IUserPromptService, UserPrompt, TruncatePathPrompt, UserPromptResponse, TruncatePathPromptResponse, };
+export { FilePathFixer };
+export declare function getFilenameFromPath(path: string): string;
+export declare function getFileNameWithoutExtension(filename: string): string;
+export declare function getExtension(filename: string): string;
+export declare function sendAndWait<V extends WorkerResponse>(port: MessagePort, request: WorkerRequest, timeout?: number | null): Promise<V>;
+export declare function send(port: MessagePort | BroadcastChannel, msg: WorkerRequest): void;
+export declare function reply(port: MessagePort, msg: WorkerResponse): void;

package/library/packages/organisms/src/downloader/downloader.constants.d.ts

@@ -0,0 +1,34 @@
+export declare const PREFERENCE_DOWNLOADER_VISIBLE = "downloaderIsVisible";
+export declare const storageKey: {
+    COOKIES_FOR_DOWNLOADER_V2_REJECTED: string;
+    OPENED_TABS: string;
+    SKIP_DELETE_CONFIRM: string;
+    TAB_ID: string;
+};
+export declare const STATUS_COLORS: {
+    downloading: string;
+    assembling: string;
+    waitingServerProcessing: string;
+    paused: string;
+    completed: string;
+    failed: string;
+    cancelled: string;
+};
+export declare const ICON_COLORS: {
+    downloading: string;
+    assembling: string;
+    waitingServerProcessing: string;
+    paused: string;
+    completed: string;
+    failed: string;
+    cancelled: string;
+};
+export declare const STATUS_VARIANTS_MAP: {
+    downloading: string;
+    assembling: string;
+    waitingServerProcessing: string;
+    paused: string;
+    completed: string;
+    failed: string;
+    cancelled: string;
+};