@knime/product-features 2.2.2 → 2.3.0

package/dist/src/dataTransfer/upload/core/uploadClient/uploadClient.d.ts

@@ -0,0 +1,59 @@
+import { FetchOptions } from 'ofetch';
+/**
+ * What `prepareUpload` actually needs to build a
+ * correct manifest request. Kept structural (rather than requiring a real
+ * `File`) so callers that don't have a materialized file - e.g. a streaming
+ * upload whose final size isn't known yet - can pass a plain metadata object
+ * instead.
+ */
+type UploadCandidate = {
+    name: string;
+    size: number;
+    type: string;
+};
+type PrepareUploadItem<T extends UploadCandidate> = {
+    /**
+     * The manifest key: the path (relative to `parentId`) this item should be
+     * created at.
+     */
+    path: string;
+    file: T;
+};
+type CreateUploadClientOptions = {
+    /**
+     * Options to customize the fetch client used internally to make http requests.
+     * e.g: headers, baseUrl, etc
+     */
+    customFetchClientOptions?: FetchOptions;
+};
+export type UploadClient = ReturnType<typeof createUploadClient>;
+/**
+ * Creates the raw upload lifecycle client:
+ *
+ * (1) - prepare a batch of items for upload
+ * (2) - resolve a presigned URL for a given file part
+ * (3) - complete an upload once all its parts are uploaded, or cancel one in progress.
+ */
+export declare const createUploadClient: (options?: CreateUploadClientOptions) => {
+    prepareUpload: <T extends UploadCandidate>(parentId: string, items: Array<PrepareUploadItem<T>>) => Promise<Array<{
+        uploadId: string;
+        file: T;
+        path: string;
+    }>>;
+    resolveFilePartUploadURL: (uploadId: string, partNumber: number) => Promise<{
+        method: string;
+        url: string;
+        header: {
+            Host: string;
+        };
+    }>;
+    completeUpload: (uploadId: string, partIds: Record<number, string>) => Promise<void>;
+    cancelUpload: (uploadId: string) => Promise<any>;
+    getUploadStatus: (uploadIds: string[]) => Promise<{
+        uploadId: string;
+        status: "PREPARED" | "ANALYSIS_PENDING" | "COMPLETED" | "ABORTED" | "FAILED";
+        statusMessage: string;
+    }[]>;
+};
+export {};
+//# sourceMappingURL=uploadClient.d.ts.map

package/dist/src/dataTransfer/upload/core/uploadClient/uploadClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadClient.d.ts","sourceRoot":"","sources":["../../../../../../src/dataTransfer/upload/core/uploadClient/uploadClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAM3C;;;;;;GAMG;AACH,KAAK,eAAe,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpE,KAAK,iBAAiB,CAAC,CAAC,SAAS,eAAe,IAAI;IAClD;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,CAAC,CAAC;CACT,CAAC;AAEF,KAAK,yBAAyB,GAAG;IAC/B;;;OAGG;IACH,wBAAwB,CAAC,EAAE,YAAY,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEjE;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAAI,UAAS,yBAA8B;oBAGjD,CAAC,SAAS,eAAe,YACpC,MAAM,SACT,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,KACjC,OAAO,CAAC,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;yCAsClB,MAAM,cAAc,MAAM;gBAE1D,MAAM;aACT,MAAM;gBACH;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE;;+BAUhB,MAAM,WACP,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;6BAQD,MAAM;iCAMF,MAAM,EAAE;kBAE9B,MAAM;gBAEd,UAAU,GAAG,kBAAkB,GAAG,WAAW,GAAG,SAAS,GAAG,QAAQ;uBACvD,MAAM;;CAkB1B,CAAC"}

package/dist/src/dataTransfer/upload/{manager/index.d.ts → core/uploadManager/chunkedUploadManager.d.ts}

@@ -1,50 +1,5 @@
-export declare const UploadStates: {
-    readonly IDLE: "idle";
-    readonly IN_PROGRESS: "inprogress";
-    readonly CANCELLED: "cancelled";
-    readonly FAILED: "failed";
-    readonly COMPLETE: "complete";
-};
-export type UploadStateName = (typeof UploadStates)[keyof typeof UploadStates];
-export type PartUploadResponse = {
-    partId: string;
-};
-export type UploaderManagerConfig = {
-    /**
-     * Function to resolve the metadata for a request to upload a file part
-     * @param uploadId
-     * @param partNumber
-     * @returns
-     */
-    resolveFilePartUploadURL: (uploadId: string, partNumber: number) => Promise<{
-        method: string;
-        url: string;
-    }>;
-    /**
-     * Callback that gets triggered when the whole file is uploaded.
-     * @param
-     * @returns
-     */
-    onFileUploadComplete?: (payload: {
-        /**
-         * Identifier of the upload for this file (must be unique)
-         */
-        uploadId: string;
-        /**
-         * Ids of all the uploaded file parts
-         */
-        filePartIds: Record<number, string>;
-    }) => void;
-    /**
-     * Callback that gets triggered when an upload has failed.
-     * @param uploadId
-     * @param error the error that cause the failure if it exists
-     * @returns
-     */
-    onFileUploadFailed?: (payload: {
-        uploadId: string;
-        error: Error;
-    }) => void;
+import { BaseUploadManagerConfig } from './types';
+export type ChunkUploadManagerConfig = BaseUploadManagerConfig & {
     /**
      * Callback that gets triggered when the progress of a file part upload
      * for a specific upload id is updated
@@ -54,14 +9,6 @@ export type UploaderManagerConfig = {
      */
     onProgress?: (uploadId: string, progress: number) => void;
 };
-type UploadState = {
-    uploadId: string;
-    file: File;
-    completedChunkCount: number;
-    uploadedByteCount: number;
-    state: UploadStateName;
-    abortController: AbortController;
-};
 /**
  * Creates and returns an `uploadManager`, a comprehensive multi-file, multi-part upload handler.
  *
@@ -85,8 +32,12 @@ type UploadState = {
  *   it manages retries and stops any failed uploads after the retry limit is reached, marking them as failed.
  *   This ensures that the promise it returns completes gracefully without uncaught exceptions.
  *
+ * This is the "slice-based" manager: it needs each file's complete bytes to already be
+ * available (as a real `File`/`Blob` with a known `.size`), since it produces each part via
+ * `file.slice()`. For uploading from a source whose total size isn't known upfront (e.g. a
+ * stream of compressed output), see `createStreamingUploadManager` instead.
  */
-export declare const createUploadManager: (config: UploaderManagerConfig) => {
+export declare const createUploadManager: (config: ChunkUploadManagerConfig) => {
     uploadFiles: (files: Array<{
         uploadId: string;
         file: File;
@@ -95,11 +46,21 @@ export declare const createUploadManager: (config: UploaderManagerConfig) => {
         cancelled: string[];
         failed: string[];
     }>;
-    getUploadState: (uploadId: string) => UploadState | undefined;
+    getUploadState: (uploadId: string) => {
+        uploadId: string;
+        fileDescriptor?: {
+            name: string;
+            type: string;
+        };
+        completedChunkCount: number;
+        uploadedByteCount: number;
+        state: import('./types').UploadStateName;
+        abortController: AbortController;
+    } | undefined;
     isFailed: (uploadId: string) => boolean;
     isCancelled: (uploadId: string) => boolean;
     cancel: (uploadId: string) => void;
-    setFailed: (uploadId: string, error: Error) => void;
+    cancelAll: () => void;
+    setFailed: (uploadId: string) => void;
 };
-export {};
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=chunkedUploadManager.d.ts.map

package/dist/src/dataTransfer/upload/core/uploadManager/chunkedUploadManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunkedUploadManager.d.ts","sourceRoot":"","sources":["../../../../../../src/dataTransfer/upload/core/uploadManager/chunkedUploadManager.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAGvD,MAAM,MAAM,wBAAwB,GAAG,uBAAuB,GAAG;IAC/D;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CAC3D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ,wBAAwB;yBA8GtC,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,IAAI,CAAA;KAAE,CAAC;;;;;;;;;;;;;;;;;;;;;CAoBpE,CAAC"}

package/dist/src/dataTransfer/upload/core/uploadManager/config.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Configuration constants shared by the upload managers
+ */
+export declare const CONFIG: Readonly<{
+    /** Size, in bytes, of each uploaded file part. */
+    CHUNK_SIZE: number;
+    /** Max number of retries for a failed request (part-url resolution or the chunk upload itself). */
+    DEFAULT_RETRY_COUNT: 5;
+    /** Delay, in ms, between retries. */
+    DEFAULT_RETRY_DELAY_MS: 50;
+}>;
+//# sourceMappingURL=config.d.ts.map

package/dist/src/dataTransfer/upload/core/uploadManager/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../../../src/dataTransfer/upload/core/uploadManager/config.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,MAAM;IACjB,kDAAkD;;IAElD,mGAAmG;;IAEnG,qCAAqC;;EAErC,CAAC"}

package/dist/src/dataTransfer/upload/core/uploadManager/index.d.ts

@@ -0,0 +1,5 @@
+export * from './chunkedUploadManager';
+export * from './streamingUploadManager';
+export type { UploadStateName } from './types';
+export { UploadStates } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/dataTransfer/upload/core/uploadManager/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/dataTransfer/upload/core/uploadManager/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC"}

package/dist/src/dataTransfer/upload/core/uploadManager/state.d.ts

@@ -0,0 +1,30 @@
+import { UploadStateName } from './types';
+type UploadState = {
+    uploadId: string;
+    fileDescriptor?: {
+        name: string;
+        type: string;
+    };
+    completedChunkCount: number;
+    uploadedByteCount: number;
+    state: UploadStateName;
+    abortController: AbortController;
+};
+export declare const createStateManager: () => {
+    get: (uploadId: string) => UploadState | undefined;
+    set: (uploadId: string, state: Partial<UploadState>) => void;
+    isFailed: (uploadId: string) => boolean;
+    isCancelled: (uploadId: string) => boolean;
+    cancel: (uploadId: string) => void;
+    cancelAll: () => void;
+    setCompleted: (uploadId: string, completedChunkCount: number) => void;
+    setFailed: (uploadId: string) => void;
+    abortInFlightUpload: (uploadId: string, reason: string) => void;
+    flush: () => {
+        completed: string[];
+        cancelled: string[];
+        failed: string[];
+    };
+};
+export {};
+//# sourceMappingURL=state.d.ts.map

package/dist/src/dataTransfer/upload/core/uploadManager/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../../../src/dataTransfer/upload/core/uploadManager/state.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAChD,mBAAmB,EAAE,MAAM,CAAC;IAC5B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,KAAK,EAAE,eAAe,CAAC;IACvB,eAAe,EAAE,eAAe,CAAC;CAClC,CAAC;AAEF,eAAO,MAAM,kBAAkB;oBAWK,MAAM;oBACN,MAAM,SAAS,OAAO,CAAC,WAAW,CAAC;yBAOzC,MAAM;4BACH,MAAM;uBAgBX,MAAM;;6BAoBA,MAAM,uBAAuB,MAAM;0BAQtC,MAAM;oCA1CI,MAAM,UAAU,MAAM;;;;;;CAyF9D,CAAC"}

package/dist/src/dataTransfer/upload/core/uploadManager/streamingUploadManager.d.ts

@@ -0,0 +1,52 @@
+import { BaseUploadManagerConfig } from './types';
+export type StreamingUploadManagerConfig = BaseUploadManagerConfig & {
+    /**
+     * Callback triggered as bytes are uploaded. This reports an absolute byte count rather
+     * than a percentage: the total size isn't known upfront for a stream.
+     */
+    onProgress?: (uploadId: string, uploadedBytes: number) => void;
+};
+/**
+ * Creates and returns a `streamingUploadManager` - a multi-part upload handler
+ * driven by a `ReadableStream<Uint8Array>` rather than a `File`/`Blob`.
+ *
+ * Unlike the chunkedUploadManager, this doesn't need to know the total size of the upload upfront.
+ * Instead, it accumulates stream chunks into a buffer and uploadsa part every time
+ * the buffer crosses the configured threshold for upload chunks, flushing whatever remains
+ * as a final (possibly smaller) part once the stream ends.
+ *
+ * This bounds memory to roughly one chunk's worth of buffered bytes, plus
+ * whatever the stream source itself buffers, regardless of the eventual
+ * total size - useful for sources whose size can't be known in advance,
+ * such as compressed output from a streaming zip encoder.
+ *
+ * Shares the same part-upload mechanics (retries, progress, abort) as
+ * the chunkedUploadManager
+ */
+export declare const createStreamingUploadManager: (config: StreamingUploadManagerConfig) => {
+    uploadStreams: (streams: Array<{
+        uploadId: string;
+        stream: ReadableStream<Uint8Array>;
+    }>) => Promise<{
+        completed: string[];
+        cancelled: string[];
+        failed: string[];
+    }>;
+    getUploadState: (uploadId: string) => {
+        uploadId: string;
+        fileDescriptor?: {
+            name: string;
+            type: string;
+        };
+        completedChunkCount: number;
+        uploadedByteCount: number;
+        state: import('./types').UploadStateName;
+        abortController: AbortController;
+    } | undefined;
+    isFailed: (uploadId: string) => boolean;
+    isCancelled: (uploadId: string) => boolean;
+    cancel: (uploadId: string) => void;
+    cancelAll: () => void;
+    setFailed: (uploadId: string) => void;
+};
+//# sourceMappingURL=streamingUploadManager.d.ts.map

package/dist/src/dataTransfer/upload/core/uploadManager/streamingUploadManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streamingUploadManager.d.ts","sourceRoot":"","sources":["../../../../../../src/dataTransfer/upload/core/uploadManager/streamingUploadManager.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAGvD,MAAM,MAAM,4BAA4B,GAAG,uBAAuB,GAAG;IACnE;;;OAGG;IACH,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,KAAK,IAAI,CAAC;CAChE,CAAC;AAgIF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,4BAA4B,GACvC,QAAQ,4BAA4B;6BAkFzB,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,CAAA;KAAE,CAAC;;;;;;;;;;;;;;;;;;;;;CAqB3E,CAAC"}

package/dist/src/dataTransfer/upload/core/uploadManager/types.d.ts

@@ -0,0 +1,46 @@
+export type BaseUploadManagerConfig = {
+    /**
+     * Function to resolve the metadata for a request to upload a file part
+     * @param uploadId
+     * @param partNumber
+     * @returns
+     */
+    resolveFilePartUploadURL: (uploadId: string, partNumber: number) => Promise<{
+        method: string;
+        url: string;
+    }>;
+    /**
+     * Callback that gets triggered when the whole file (or stream in streaming mode) is uploaded.
+     * @param
+     * @returns
+     */
+    onFileUploadComplete?: (payload: {
+        /**
+         * Identifier of the upload for this file (must be unique)
+         */
+        uploadId: string;
+        /**
+         * Ids of all the uploaded file parts
+         */
+        filePartIds: Record<number, string>;
+    }) => void;
+    /**
+     * Callback that gets triggered when an upload has failed.
+     * @param uploadId
+     * @param error the error that cause the failure if it exists
+     * @returns
+     */
+    onFileUploadFailed?: (payload: {
+        uploadId: string;
+        error: Error;
+    }) => void;
+};
+export declare const UploadStates: {
+    readonly IDLE: "idle";
+    readonly IN_PROGRESS: "inprogress";
+    readonly CANCELLED: "cancelled";
+    readonly FAILED: "failed";
+    readonly COMPLETE: "complete";
+};
+export type UploadStateName = (typeof UploadStates)[keyof typeof UploadStates];
+//# sourceMappingURL=types.d.ts.map

package/dist/src/dataTransfer/upload/core/uploadManager/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/dataTransfer/upload/core/uploadManager/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,uBAAuB,GAAG;IACpC;;;;;OAKG;IACH,wBAAwB,EAAE,CACxB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,KACf,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAE9C;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,CAAC,OAAO,EAAE;QAC/B;;WAEG;QACH,QAAQ,EAAE,MAAM,CAAC;QACjB;;WAEG;QACH,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACrC,KAAK,IAAI,CAAC;IAEX;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,KAAK,IAAI,CAAC;CAC5E,CAAC;AAEF,eAAO,MAAM,YAAY;;;;;;CAMf,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC"}

package/dist/src/dataTransfer/upload/core/uploadManager/uploadPartBytes.d.ts

@@ -0,0 +1,17 @@
+export type PartUploadResponse = {
+    partId: string;
+};
+/**
+ * Uploads a single file part via XHR, reporting upload progress and
+ * resolving with the part's identifying ETag (or an empty string if the
+ * backend doesn't return one).
+ */
+export declare const uploadPartBytesWithProgress: (params: {
+    method: string;
+    url: string;
+    partBytes: Blob;
+    partIndex: number;
+    onProgress: (progress: number) => void;
+    abortSignal: AbortSignal;
+}) => Promise<PartUploadResponse>;
+//# sourceMappingURL=uploadPartBytes.d.ts.map

package/dist/src/dataTransfer/upload/core/uploadManager/uploadPartBytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadPartBytes.d.ts","sourceRoot":"","sources":["../../../../../../src/dataTransfer/upload/core/uploadManager/uploadPartBytes.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,GAAI,QAAQ;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,WAAW,EAAE,WAAW,CAAC;CAC1B,KAAG,OAAO,CAAC,kBAAkB,CAgD7B,CAAC"}

package/dist/src/dataTransfer/upload/index.d.ts

@@ -0,0 +1,6 @@
+import { default as UploadProgressPanel } from './UploadProgressPanel.vue';
+export { UploadProgressPanel };
+export type { DirectoryUploadItem, FileUploadItem, UploadItem, UploadItemStatus, UploadProgressPanelProps, } from './types';
+export * from './useFileUpload';
+export * from './useUploadManager';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/dataTransfer/upload/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/dataTransfer/upload/index.ts"],"names":[],"mappings":"AAAA,OAAO,mBAAmB,MAAM,2BAA2B,CAAC;AAE5D,OAAO,EAAE,mBAAmB,EAAE,CAAC;AAC/B,YAAY,EACV,mBAAmB,EACnB,cAAc,EACd,UAAU,EACV,gBAAgB,EAChB,wBAAwB,GACzB,MAAM,SAAS,CAAC;AACjB,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC"}

package/dist/src/dataTransfer/upload/types.d.ts

@@ -0,0 +1,80 @@
+import { UploadStateName } from '../core';
+export type UploadItemStatus = Exclude<UploadStateName, "idle"> | "processing" | "partial-success";
+declare const UploadItemStatus: {
+    PROCESSING: "processing";
+    /** Some, but not all, of the items an upload is comprised of succeeded. */
+    PARTIAL_SUCCESS: "partial-success";
+    IN_PROGRESS: "inprogress";
+    CANCELLED: "cancelled";
+    FAILED: "failed";
+    COMPLETE: "complete";
+};
+type CommonProps = {
+    /** Unique identifier of the uploaded item. */
+    id: string;
+    /** File name of the uploaded item. */
+    name: string;
+    /** Id of the parent folder the item is uploaded into. */
+    parentId: string;
+    actions?: {
+        cancellable?: boolean;
+        inspectable?: boolean;
+    };
+};
+type WithInProgress = {
+    status: typeof UploadItemStatus.IN_PROGRESS;
+};
+type WithComplete = {
+    status: typeof UploadItemStatus.COMPLETE;
+};
+type WithCancelled = {
+    /** Status indicating the upload was cancelled by the user. */
+    status: typeof UploadItemStatus.CANCELLED;
+};
+type WithFailure = {
+    status: typeof UploadItemStatus.FAILED;
+    /** Human-readable explanation of why the upload failed. */
+    failureDetails: string;
+};
+type WithProcessing = {
+    /** Status indicating the uploaded file is being processed server-side. */
+    status: typeof UploadItemStatus.PROCESSING;
+};
+type WithPartialSuccess = {
+    /**
+     * Status indicating that this item represents a group of uploads of
+     * which only some succeeded.
+     */
+    status: typeof UploadItemStatus.PARTIAL_SUCCESS;
+};
+type WithDirectoryProgress = {
+    uploadedEntries: number;
+    totalEntries: number;
+};
+export type DirectoryUploadItem = CommonProps & {
+    type: "directory";
+} & WithDirectoryProgress & (WithInProgress | WithComplete | WithFailure | WithCancelled | WithPartialSuccess);
+type WithFileProgress = {
+    /**
+     * A value between 0-1, which indicates percentage that has been uploaded of this file.
+     * If omitted, no progress bar is shown
+     */
+    progress?: number;
+    size: number;
+};
+export type FileUploadItem = CommonProps & {
+    type: "file";
+} & WithFileProgress & (WithInProgress | WithComplete | WithProcessing | WithFailure | WithCancelled);
+export type UploadItem = DirectoryUploadItem | FileUploadItem;
+export type UploadProgressPanelProps = {
+    /**
+     * List of items that the upload is comprised of
+     */
+    items: UploadItem[];
+    /**
+     * Indicates the number of items to show as placeholder skeletons
+     */
+    placeholderItems?: number;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/dataTransfer/upload/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/dataTransfer/upload/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAgB,MAAM,SAAS,CAAC;AAE7D,MAAM,MAAM,gBAAgB,GAC1B,OAAO,CAAC,eAAe,EAAE,MAAM,CAAC,GAAG,YAAY,GAAG,iBAAiB,CAAC;AAItE,QAAA,MAAM,gBAAgB;;IAGpB,2EAA2E;;;;;;CAE5E,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,8CAA8C;IAC9C,EAAE,EAAE,MAAM,CAAC;IACX,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,QAAQ,EAAE,MAAM,CAAC;IAEjB,OAAO,CAAC,EAAE;QACR,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB,CAAC;CACH,CAAC;AAEF,KAAK,cAAc,GAAG;IACpB,MAAM,EAAE,OAAO,gBAAgB,CAAC,WAAW,CAAC;CAC7C,CAAC;AAEF,KAAK,YAAY,GAAG;IAClB,MAAM,EAAE,OAAO,gBAAgB,CAAC,QAAQ,CAAC;CAC1C,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,8DAA8D;IAC9D,MAAM,EAAE,OAAO,gBAAgB,CAAC,SAAS,CAAC;CAC3C,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,OAAO,gBAAgB,CAAC,MAAM,CAAC;IACvC,2DAA2D;IAC3D,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,KAAK,cAAc,GAAG;IACpB,0EAA0E;IAC1E,MAAM,EAAE,OAAO,gBAAgB,CAAC,UAAU,CAAC;CAC5C,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACxB;;;OAGG;IACH,MAAM,EAAE,OAAO,gBAAgB,CAAC,eAAe,CAAC;CACjD,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAAE,eAAe,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/E,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG;IAC9C,IAAI,EAAE,WAAW,CAAC;CACnB,GAAG,qBAAqB,GACvB,CACI,cAAc,GACd,YAAY,GACZ,WAAW,GACX,aAAa,GACb,kBAAkB,CACrB,CAAC;AAEJ,KAAK,gBAAgB,GAAG;IACtB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,gBAAgB,GAC5E,CACE,cAAc,GAAG,YAAY,GAAG,cAAc,GAAG,WAAW,GAAG,aAAa,CAC7E,CAAC;AAEJ,MAAM,MAAM,UAAU,GAAG,mBAAmB,GAAG,cAAc,CAAC;AAE9D,MAAM,MAAM,wBAAwB,GAAG;IACrC;;OAEG;IACH,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC"}

package/dist/src/dataTransfer/upload/useFileUpload.d.ts

@@ -1,5 +1,5 @@
 import { FetchOptions } from 'ofetch';
-import { UploadItem } from './ui';
+import { UploadItem } from './types';
 type UseFileUploadOptions = {
     /**
      * Max number of concurrent uploads allowed in the upload queue.
@@ -38,6 +38,7 @@ type UseFileUploadOptions = {
      * e.g: headers, baseUrl, etc
      */
     customFetchClientOptions?: FetchOptions;
+    isFileWithProcessing?: (fileName: string) => boolean;
 };
 /**
  * This composable handles uploads of data to a hub repository item (space or workflow group).
@@ -90,24 +91,15 @@ type UseFileUploadOptions = {
  * Alternative to completion, you can also cancel an upload. For this, the composable makes a DELETE request
  * providing the corresponding `uploadId` which will effectively cancel it.
  *
- *
  * For a usage example, refer to the Docs page in storybook.
  */
 export declare const useFileUpload: (options?: UseFileUploadOptions) => {
     uploadQueue: import('vue').ComputedRef<UploadItem[]>;
-    unprocessedUploads: ReadonlySet<string>;
-    setProcessingCompleted: ({ uploadId }: {
-        uploadId: string;
-    }) => void;
-    setProcessingFailed: ({ uploadId, error, }: {
-        uploadId: string;
-        error?: Error;
-    }) => void;
+    getItemFromQueue: (uploadId: string) => UploadItem | undefined;
+    updateItemInQueue: (uploadId: string, data: Partial<UploadItem>) => void;
     isPreparingUpload: import('vue').ComputedRef<boolean>;
     totalFilesBeingPrepared: import('vue').ComputedRef<number>;
-    start: (parentId: string, files: File[], options?: {
-        isFileWithProcessing?: (file: File) => boolean;
-    }) => Promise<string[]>;
+    start: (parentId: string, files: File[]) => Promise<string[]>;
     cancel: (uploadId: string) => void;
     hasPendingUploads: import('vue').ComputedRef<boolean>;
     totalPendingUploads: import('vue').ComputedRef<number>;

package/dist/src/dataTransfer/upload/useFileUpload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useFileUpload.d.ts","sourceRoot":"","sources":["../../../../src/dataTransfer/upload/useFileUpload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAc,YAAY,EAAE,MAAM,QAAQ,CAAC;AAYvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAcvC,KAAK,oBAAoB,GAAG;IAC1B;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;OAGG;IACH,oBAAoB,CAAC,EAAE,CAAC,OAAO,EAAE;QAC/B,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACpC,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;KACd,KAAK,IAAI,CAAC;IACX;;;OAGG;IACH,kBAAkB,CAAC,EAAE,CAAC,OAAO,EAAE;QAC7B,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,EAAE,KAAK,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;KAClB,KAAK,IAAI,CAAC;IACX;;;;OAIG;IACH,yBAAyB,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3D;;;OAGG;IACH,wBAAwB,CAAC,EAAE,YAAY,CAAC;CACzC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,eAAO,MAAM,aAAa,GAAI,UAAS,oBAAyB;;;2CAiFhB;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE;gDAO/D;QACD,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,CAAC,EAAE,KAAK,CAAC;KACf;;;sBAoFa,MAAM,SACT,IAAI,EAAE,YACJ;QAAE,oBAAoB,CAAC,SApGV,IAAI,aAoGyB;KAAE;uBAwDpC,MAAM;;;;;;;CAO5B,CAAC"}
+{"version":3,"file":"useFileUpload.d.ts","sourceRoot":"","sources":["../../../../src/dataTransfer/upload/useFileUpload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAc,YAAY,EAAE,MAAM,QAAQ,CAAC;AAOvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAc1C,KAAK,oBAAoB,GAAG;IAC1B;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;OAGG;IACH,oBAAoB,CAAC,EAAE,CAAC,OAAO,EAAE;QAC/B,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACpC,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;KACd,KAAK,IAAI,CAAC;IACX;;;OAGG;IACH,kBAAkB,CAAC,EAAE,CAAC,OAAO,EAAE;QAC7B,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,EAAE,KAAK,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;KAClB,KAAK,IAAI,CAAC;IACX;;;;OAIG;IACH,yBAAyB,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3D;;;OAGG;IACH,wBAAwB,CAAC,EAAE,YAAY,CAAC;IAExC,oBAAoB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;CACtD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,aAAa,GAAI,UAAS,oBAAyB;;iCAO1B,MAAM;kCAaL,MAAM,QAAQ,OAAO,CAAC,UAAU,CAAC;;;sBAmG5C,MAAM,SAAS,IAAI,EAAE;uBAuD1B,MAAM;;;;;;;CAO5B,CAAC"}

package/dist/src/dataTransfer/upload/{ui/useUploadManager.d.ts → useUploadManager.d.ts}

@@ -1,15 +1,23 @@
-import { UploaderManagerConfig } from '../manager';
+import { ChunkUploadManagerConfig } from '../core';
 import { UploadItem } from './types';
-type OnCompletePayload = Parameters<NonNullable<UploaderManagerConfig["onFileUploadComplete"]>>[0] & {
+type OnCompletePayload = Parameters<NonNullable<ChunkUploadManagerConfig["onFileUploadComplete"]>>[0] & {
     parentId: string;
     name: string;
 };
-type OnFailedPayload = Parameters<NonNullable<UploaderManagerConfig["onFileUploadFailed"]>>[0] & {
+type OnFailedPayload = Parameters<NonNullable<ChunkUploadManagerConfig["onFileUploadFailed"]>>[0] & {
     parentId: string;
 };
-type UseUploadManagerOptions = Omit<UploaderManagerConfig, "onProgress" | "onFileUploadComplete" | "onFileUploadFailed"> & {
+type UseUploadManagerOptions = Omit<ChunkUploadManagerConfig, "onProgress" | "onFileUploadComplete" | "onFileUploadFailed"> & {
     onFileUploadComplete?: (payload: OnCompletePayload) => void;
     onFileUploadFailed?: (payload: OnFailedPayload) => void;
+    /**
+     * Determines the status to assign a file once its raw upload finishes,
+     * before calling `onFileUploadComplete`. This helps for files that need further
+     * server-side processing
+     *
+     * Defaults to `complete`
+     */
+    resolveCompleteStatus?: (payload: OnCompletePayload) => "complete" | "processing";
 };
 /**
  * This composable wraps the `uploadManager` utility
@@ -25,7 +33,11 @@ export declare const useUploadManager: (options: UseUploadManagerOptions) => {
     start: (parentId: string, uploadPayload: Array<{
         uploadId: string;
         file: File;
-    }>) => Promise<void>;
+    }>) => Promise<never[] | {
+        completed: string[];
+        cancelled: string[];
+        failed: string[];
+    }>;
     cancel: (uploadId: string) => void;
     canCancel: (uploadId: string) => boolean;
     removeItem: (uploadId: string) => void;

package/dist/src/dataTransfer/upload/useUploadManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUploadManager.d.ts","sourceRoot":"","sources":["../../../../src/dataTransfer/upload/useUploadManager.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,wBAAwB,EAAuB,MAAM,SAAS,CAAC;AAE7E,OAAO,KAAK,EAAkB,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1D,KAAK,iBAAiB,GAAG,UAAU,CACjC,WAAW,CAAC,wBAAwB,CAAC,sBAAsB,CAAC,CAAC,CAC9D,CAAC,CAAC,CAAC,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1C,KAAK,eAAe,GAAG,UAAU,CAC/B,WAAW,CAAC,wBAAwB,CAAC,oBAAoB,CAAC,CAAC,CAC5D,CAAC,CAAC,CAAC,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5B,KAAK,uBAAuB,GAAG,IAAI,CACjC,wBAAwB,EACxB,YAAY,GAAG,sBAAsB,GAAG,oBAAoB,CAC7D,GAAG;IACF,oBAAoB,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,IAAI,CAAC;IAC5D,kBAAkB,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAC;IACxD;;;;;;OAMG;IACH,qBAAqB,CAAC,EAAE,CACtB,OAAO,EAAE,iBAAiB,KACvB,UAAU,GAAG,YAAY,CAAC;CAChC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,uBAAuB;;;;sBAiCnD,MAAM,iBACD,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,IAAI,CAAA;KAAE,CAAC;;;;;uBAsDnC,MAAM;0BAhCE,MAAM;2BAIL,MAAM;;0BAmCZ,MAAM,SAAS,KAAK;CAW7C,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knime/product-features",
-  "version": "2.2.2",
+  "version": "2.3.0",
   "description": "Package containing composition patterns of KDS Components and KNIME business logic",
   "repository": {
     "type": "git",
@@ -25,6 +25,10 @@
       "types": "./dist/src/dataTransfer/index.d.ts",
       "import": "./dist/dataTransfer.js"
     },
+    "./data-transfer/core": {
+      "types": "./dist/src/dataTransfer/core.d.ts",
+      "import": "./dist/dataTransfer/core.js"
+    },
     "./nodes": {
       "types": "./dist/src/nodes/index.d.ts",
       "import": "./dist/nodes.js"
@@ -54,9 +58,9 @@
   },
   "dependencies": {
     "consola": "^3.4.2",
-    "@knime/kds-components": "^6.7.1",
-    "@knime/kds-styles": "^6.7.1",
-    "@knime/utils": "^2.0.1"
+    "@knime/kds-components": "^6.9.0",
+    "@knime/kds-styles": "^6.9.0",
+    "@knime/utils": "^2.0.2"
   },
   "devDependencies": {
     "@storybook/addon-docs": "^10.4.6",

package/dist/src/dataTransfer/upload/manager/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/dataTransfer/upload/manager/index.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,YAAY;;;;;;CAMf,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAE/E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA2DF,MAAM,MAAM,qBAAqB,GAAG;IAClC;;;;;OAKG;IACH,wBAAwB,EAAE,CACxB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,KACf,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAE9C;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,CAAC,OAAO,EAAE;QAC/B;;WAEG;QACH,QAAQ,EAAE,MAAM,CAAC;QACjB;;WAEG;QACH,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACrC,KAAK,IAAI,CAAC;IAEX;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,KAAK,IAAI,CAAC;IAE3E;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CAC3D,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,IAAI,CAAC;IACX,mBAAmB,EAAE,MAAM,CAAC;IAC5B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,KAAK,EAAE,eAAe,CAAC;IACvB,eAAe,EAAE,eAAe,CAAC;CAClC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ,qBAAqB;yBAiLnC,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,IAAI,CAAA;KAAE,CAAC;;;;;+BAjKjC,MAAM;yBAQZ,MAAM;4BACH,MAAM;uBAkBX,MAAM;0BAYH,MAAM,SAAS,KAAK;CAgKlD,CAAC"}

package/dist/src/dataTransfer/upload/ui/UploadProgressPanel.vue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"UploadProgressPanel.vue.d.ts","sourceRoot":"","sources":["../../../../../src/dataTransfer/upload/ui/UploadProgressPanel.vue"],"names":[],"mappings":"AAiHA,OAAO,KAAK,EAAE,UAAU,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAEpE,KAAK,WAAW,GAAG,wBAAwB,CAAC;AAqC5C,KAAK,gBAAgB,GAAG;IACxB,UAAU,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAKF,KAAK,iBAAiB,GAAG,WAAW,GAAG,gBAAgB,CAAC;AA6JxD,QAAA,MAAM,YAAY;;;;;;;;kFAGhB,CAAC;wBACkB,OAAO,YAAY;AAAxC,wBAAyC"}

package/dist/src/dataTransfer/upload/ui/UploadProgressPanelItem.vue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"UploadProgressPanelItem.vue.d.ts","sourceRoot":"","sources":["../../../../../src/dataTransfer/upload/ui/UploadProgressPanelItem.vue"],"names":[],"mappings":"AA0HA,OAAO,KAAK,EAAE,UAAU,EAAkC,MAAM,SAAS,CAAC;AAE1E,KAAK,KAAK,GAAG;IACX,IAAI,EAAE,UAAU,CAAC;IACjB,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AA6HF,QAAA,MAAM,YAAY;;;;kFAGhB,CAAC;wBACkB,OAAO,YAAY;AAAxC,wBAAyC"}

package/dist/src/dataTransfer/upload/ui/index.d.ts

@@ -1,5 +0,0 @@
-import { default as UploadProgressPanel } from './UploadProgressPanel.vue';
-import { default as UploadProgressPanelItem } from './UploadProgressPanelItem.vue';
-export { UploadProgressPanel, UploadProgressPanelItem };
-export type * from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/dataTransfer/upload/ui/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/dataTransfer/upload/ui/index.ts"],"names":[],"mappings":"AAAA,OAAO,mBAAmB,MAAM,2BAA2B,CAAC;AAC5D,OAAO,uBAAuB,MAAM,+BAA+B,CAAC;AAEpE,OAAO,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,CAAC;AACxD,mBAAmB,SAAS,CAAC"}