@contello/uploader 8.21.0 → 8.21.2

package/README.md

@@ -0,0 +1,88 @@
+# @contello/uploader
+
+File uploader for Contello CMS with WebSocket (chunked) and HTTP (multipart) transports.
+
+## Installation
+
+```bash
+npm install @contello/uploader rxjs
+```
+
+## Usage
+
+### Simple upload
+
+```ts
+import { ContelloUploader } from '@contello/uploader';
+
+const uploader = new ContelloUploader({
+  url: 'https://example.com',
+  project: 'myProjectId',
+  token: 'app-a123b456c7890d123456789',
+});
+
+const { id } = await uploader.upload(file);
+```
+
+### Upload with progress
+
+```ts
+uploader.uploadWithEvents(file).subscribe((event) => {
+  if ('progress' in event) {
+    console.log(`${event.progress.toFixed(1)}%`);
+  } else {
+    console.log(`uploaded: ${event.id}`);
+  }
+});
+```
+
+### Upload with metadata
+
+```ts
+import { UploadAssetRetentionPolicy } from '@contello/uploader';
+
+await uploader.upload(file, {
+  annotations: [{ key: 'category', value: 'photos' }],
+  collectionRefs: ['collection-id'],
+  retentionPolicy: UploadAssetRetentionPolicy.retain,
+  image: {
+    transformations: [
+      { name: 'fit', options: { width: 1920, height: 1080 } },
+      { name: 'convert', options: { format: 'avif', options: { quality: 80, lossless: false } } },
+    ],
+  },
+});
+```
+
+### Abort an upload
+
+```ts
+const controller = new AbortController();
+
+uploader.upload(file, undefined, { abort: controller.signal });
+
+controller.abort();
+```
+
+## API
+
+### `ContelloUploader`
+
+| Option      | Type             | Default          | Description                      |
+| ----------- | ---------------- | ---------------- | -------------------------------- |
+| `url`       | `string`         | —                | Base URL of the Contello server  |
+| `project`   | `string`         | —                | Project identifier               |
+| `token`     | `string`         | —                | Authentication token             |
+| `transport` | `'ws' \| 'http'` | `'ws'`           | Transport protocol               |
+| `chunkSize` | `number`         | `4194304` (4 MB) | Chunk size for WebSocket uploads |
+
+### Methods
+
+| Method                                    | Returns                                             | Description                          |
+| ----------------------------------------- | --------------------------------------------------- | ------------------------------------ |
+| `upload(file, meta?, options?)`           | `Promise<{ id: string }>`                           | Upload a file, resolve with asset ID |
+| `uploadWithEvents(file, meta?, options?)` | `Observable<UploadAssetProgress \| { id: string }>` | Upload with progress events          |
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,211 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ContelloUploader: () => ContelloUploader,
+  UploadAssetRetentionPolicy: () => UploadAssetRetentionPolicy
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/upload-metadata.ts
+var UploadAssetRetentionPolicy = /* @__PURE__ */ ((UploadAssetRetentionPolicy2) => {
+  UploadAssetRetentionPolicy2["retain"] = "retain";
+  UploadAssetRetentionPolicy2["deleteIfNotUsed"] = "deleteIfNotUsed";
+  return UploadAssetRetentionPolicy2;
+})(UploadAssetRetentionPolicy || {});
+
+// src/uploader.ts
+var import_rxjs3 = require("rxjs");
+
+// src/implementations/ws.ts
+var import_rxjs = require("rxjs");
+function uploadViaWebSocket({ url, project, token, chunkSize }, file, meta, options) {
+  const metadata = { ...meta ?? {}, projectRef: project };
+  return new import_rxjs.Observable((obs) => {
+    const parsedUrl = new URL(url);
+    const ws = new WebSocket(
+      `${parsedUrl.protocol === "https:" ? "wss" : "ws"}://${parsedUrl.host}/api/v1/assets/ws`,
+      "contello-file-upload-v1"
+    );
+    const reader = typeof FileReader !== "undefined" ? new FileReader() : null;
+    let offset = 0;
+    let done = false;
+    let ackReceived = false;
+    ws.onopen = async () => {
+      const initFrame = {
+        type: "init",
+        metadata: {
+          ...metadata,
+          name: file.name,
+          mimeType: file.type,
+          size: file.size
+        },
+        token
+      };
+      ws.send(JSON.stringify(initFrame));
+      function readSlice() {
+        const slice = file.slice(offset, offset + chunkSize);
+        if (reader) {
+          reader.readAsArrayBuffer(slice);
+        } else {
+          slice.arrayBuffer().then((buffer) => {
+            handleArrayBuffer(buffer);
+          }).catch((err) => {
+            obs.error(err);
+          });
+        }
+      }
+      function markAsDone() {
+        reader?.abort();
+        ws.send(JSON.stringify({ type: "done" }));
+      }
+      function startUpload() {
+        if (ackReceived) {
+          readSlice();
+        }
+      }
+      function handleArrayBuffer(buffer) {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(buffer);
+          offset += buffer.byteLength;
+          if (offset < file.size) {
+            readSlice();
+          } else {
+            markAsDone();
+          }
+        } else {
+          obs.error(new Error("WebSocket is closed"));
+          reader?.abort();
+        }
+      }
+      if (reader) {
+        reader.onload = () => {
+          if (reader.result && reader.result instanceof ArrayBuffer) {
+            handleArrayBuffer(reader.result);
+          } else {
+            markAsDone();
+          }
+        };
+      }
+      ws.onmessage = (event) => {
+        const message = JSON.parse(event.data);
+        if (message.type === "ack") {
+          ackReceived = true;
+          startUpload();
+          return;
+        }
+        if (message.type === "progress") {
+          return obs.next({ progress: message.bytesReceived / file.size * 100 });
+        }
+        if (message.type === "done") {
+          if (message.id) {
+            done = true;
+            obs.next({ id: message.id });
+            obs.complete();
+          } else {
+            obs.error(new Error("No asset id received"));
+          }
+          return ws.close();
+        }
+        obs.error(new Error(`WebSocket message with unknown type ${JSON.stringify(message)}`));
+        ws.close();
+      };
+    };
+    ws.onerror = (error) => obs.error(error);
+    ws.onclose = () => {
+      if (!done) {
+        obs.error(new Error("Connection closed"));
+      }
+    };
+    const abortHandler = () => {
+      if (!done) {
+        reader?.abort();
+        ws.close();
+        obs.error(new Error("Upload aborted"));
+      }
+    };
+    options?.abort?.addEventListener("abort", abortHandler);
+    return () => {
+      options?.abort?.removeEventListener("abort", abortHandler);
+      ws.close();
+    };
+  });
+}
+
+// src/implementations/xhr.ts
+var import_rxjs2 = require("rxjs");
+function uploadViaXhr({ url, project, token }, file, meta, options) {
+  return new import_rxjs2.Observable((obs) => {
+    const data = new FormData();
+    data.append("metadata", JSON.stringify({ ...meta ?? {}, projectRef: project }));
+    data.append("file", file);
+    const xhr = new XMLHttpRequest();
+    xhr.setRequestHeader("Authorization", `Bearer ${token}`);
+    xhr.open("POST", `${url}/api/v1/assets`, true);
+    xhr.upload.onprogress = async (event) => {
+      if (event.lengthComputable) {
+        obs.next({ progress: event.loaded / event.total * 100 });
+      }
+    };
+    xhr.onload = async () => {
+      if (xhr.status >= 200 && xhr.status < 300) {
+        const { id } = JSON.parse(xhr.responseText);
+        obs.next({ id });
+        return obs.complete();
+      }
+      obs.error(new Error(`${xhr.status}: ${xhr.statusText}`));
+    };
+    xhr.onerror = (error) => obs.error(error);
+    xhr.send(data);
+    options?.abort?.addEventListener("abort", () => xhr.abort());
+    return () => xhr.abort();
+  });
+}
+
+// src/uploader.ts
+var ContelloUploader = class {
+  params;
+  constructor(params) {
+    this.params = {
+      url: params.url,
+      project: params.project,
+      token: params.token,
+      transport: params.transport || "ws",
+      chunkSize: params.chunkSize || 4 * 1024 * 1024
+    };
+  }
+  /** Uploads a file and resolves with the asset ID once complete. */
+  async upload(file, meta, options) {
+    return (0, import_rxjs3.firstValueFrom)(this.uploadWithEvents(file, meta, options).pipe((0, import_rxjs3.filter)((r) => "id" in r)));
+  }
+  /** Uploads a file and returns an Observable emitting progress events and the final asset ID. */
+  uploadWithEvents(file, meta, options) {
+    if (this.params.transport === "http") {
+      return uploadViaXhr(this.params, file, meta, options);
+    }
+    return uploadViaWebSocket(this.params, file, meta, options);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContelloUploader,
+  UploadAssetRetentionPolicy
+});

package/dist/index.d.cts

@@ -0,0 +1,122 @@
+import * as rxjs from 'rxjs';
+
+type UploadAssetMetadata = {
+    name?: string | undefined;
+    mimeType?: string | undefined;
+    size?: number | undefined;
+    annotations?: UploadAssetAnnotation[] | undefined;
+    collectionRefs?: string[] | undefined;
+    image?: UploadAssetImageMetadata | undefined;
+    retentionPolicy?: UploadAssetRetentionPolicy | undefined;
+    generatePreview?: boolean | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+};
+type UploadAssetAnnotation = {
+    key: string;
+    value: string;
+};
+type UploadAssetProgress = {
+    progress: number;
+};
+declare enum UploadAssetRetentionPolicy {
+    retain = "retain",
+    deleteIfNotUsed = "deleteIfNotUsed"
+}
+type UploadAssetImageMetadata = {
+    transformations: UploadAssetImageTransformation[];
+};
+type UploadAssetImageTransformation = UploadAssetExtractTransformation | UploadAssetFitTransformation | UploadAssetConvertTransformation;
+type UploadAssetExtractTransformation = {
+    name: 'extract';
+    options: {
+        top: number;
+        left: number;
+        areaWidth: number;
+        areaHeight: number;
+        rotate?: 0 | 90 | 180 | 270 | undefined;
+    };
+};
+type UploadAssetFitTransformation = {
+    name: 'fit';
+    options: {
+        width: number;
+        height: number;
+    };
+};
+type UploadAssetConvertTransformation = {
+    name: 'convert';
+    options: UploadAssetConvertTransformationJpegOptions | UploadAssetConvertTransformationPngOptions | UploadAssetConvertTransformationAvifOptions;
+};
+type UploadAssetConvertTransformationJpegOptions = {
+    format: 'jpeg';
+    options: {
+        quality: number;
+        interlace: boolean;
+    };
+};
+type UploadAssetConvertTransformationPngOptions = {
+    format: 'png';
+    options: {
+        compressionLevel: number;
+    };
+};
+type UploadAssetConvertTransformationAvifOptions = {
+    format: 'avif';
+    options: {
+        quality: number;
+        lossless: boolean;
+    };
+};
+
+type ContelloUploaderParams = {
+    /**
+     * Base URL of the Contello server.
+     * Example: 'https://example.com'
+     */
+    url: string;
+    /**
+     * Project identifier for the Contello project.
+     * Example: 'myProjectId'
+     */
+    project: string;
+    /**
+     * Authentication token for the Contello API.
+     * Example: 'app-a123b456c7890d123456789'
+     */
+    token: string;
+    /**
+     * Transport protocol to use for uploading files.
+     * 'http' uses XMLHttpRequest, 'ws' uses WebSocket.
+     * @default 'ws'
+     */
+    transport?: 'http' | 'ws';
+    /**
+     * Size of each chunk in bytes when uploading files.
+     * Default is 4MB.
+     * @default 4_194_304
+     */
+    chunkSize?: number;
+};
+/**
+ * ContelloUploader is a class for uploading files to a Contello server.
+ * It supports both WebSocket and HTTP transports.
+ */
+declare class ContelloUploader {
+    private params;
+    constructor(params: ContelloUploaderParams);
+    /** Uploads a file and resolves with the asset ID once complete. */
+    upload(file: File, meta?: UploadAssetMetadata | undefined, options?: {
+        abort?: AbortSignal;
+    } | undefined): Promise<{
+        id: string;
+    }>;
+    /** Uploads a file and returns an Observable emitting progress events and the final asset ID. */
+    uploadWithEvents(file: File, meta?: UploadAssetMetadata | undefined, options?: {
+        abort?: AbortSignal;
+    } | undefined): rxjs.Observable<UploadAssetProgress | {
+        id: string;
+    }>;
+}
+
+export { ContelloUploader, type ContelloUploaderParams, type UploadAssetAnnotation, type UploadAssetConvertTransformation, type UploadAssetConvertTransformationAvifOptions, type UploadAssetConvertTransformationJpegOptions, type UploadAssetConvertTransformationPngOptions, type UploadAssetExtractTransformation, type UploadAssetFitTransformation, type UploadAssetImageMetadata, type UploadAssetImageTransformation, type UploadAssetMetadata, type UploadAssetProgress, UploadAssetRetentionPolicy };

package/dist/index.d.ts

@@ -1,132 +1,122 @@
-import { Observable } from 'rxjs';
-
-/**
- * ContelloUploader is a class for uploading files to a Contello server.
- * It supports both WebSocket and HTTP transports.
- */
-export declare class ContelloUploader {
-    private params;
-    constructor(params: ContelloUploaderParams);
-    upload(file: File, meta?: UploadAssetMetadata | undefined, options?: {
-        abort?: AbortSignal;
-    } | undefined): Promise<{
-        id: string;
-    }>;
-    uploadWithEvents(file: File, meta?: UploadAssetMetadata | undefined, options?: {
-        abort?: AbortSignal;
-    } | undefined): Observable<UploadAssetProgress | {
-    id: string;
-    }>;
-}
-
-export declare type ContelloUploaderParams = {
-    /**
-     * Base URL of the Contello server.
-     * Example: 'https://example.com'
-     */
-    url: string;
-    /**
-     * Project identifier for the Contello project.
-     * Example: 'myProjectId'
-     */
-    project: string;
-    /**
-     * Authentication token for the Contello API.
-     * Example: 'app-a123b456c7890d123456789'
-     */
-    token: string;
-    /**
-     * Transport protocol to use for uploading files.
-     * 'http' uses XMLHttpRequest, 'ws' uses WebSocket.
-     * @default 'ws'
-     */
-    transport?: 'http' | 'ws';
-    /**
-     * Size of each chunk in bytes when uploading files.
-     * Default is 4MB.
-     * @default 4_194_304
-     */
-    chunkSize?: number;
-};
-
-export declare type UploadAssetAnnotation = {
-    key: string;
-    value: string;
-};
-
-export declare type UploadAssetConvertTransformation = {
-    name: 'convert';
-    options: UploadAssetConvertTransformationJpegOptions | UploadAssetConvertTransformationPngOptions | UploadAssetConvertTransformationAvifOptions;
-};
-
-export declare type UploadAssetConvertTransformationAvifOptions = {
-    format: 'avif';
-    options: {
-        quality: number;
-        lossless: boolean;
-    };
-};
-
-export declare type UploadAssetConvertTransformationJpegOptions = {
-    format: 'jpeg';
-    options: {
-        quality: number;
-        interlace: boolean;
-    };
-};
-
-export declare type UploadAssetConvertTransformationPngOptions = {
-    format: 'png';
-    options: {
-        compressionLevel: number;
-    };
-};
-
-export declare type UploadAssetExtractTransformation = {
-    name: 'extract';
-    options: {
-        top: number;
-        left: number;
-        areaWidth: number;
-        areaHeight: number;
-        rotate?: 0 | 90 | 180 | 270 | undefined;
-    };
-};
-
-export declare type UploadAssetFitTransformation = {
-    name: 'fit';
-    options: {
-        width: number;
-        height: number;
-    };
-};
-
-export declare type UploadAssetImageMetadata = {
-    transformations: UploadAssetImageTransformation[];
-};
-
-export declare type UploadAssetImageTransformation = UploadAssetExtractTransformation | UploadAssetFitTransformation | UploadAssetConvertTransformation;
-
-export declare type UploadAssetMetadata = {
-    name?: string | undefined;
-    mimeType?: string | undefined;
-    size?: number | undefined;
-    annotations?: UploadAssetAnnotation[] | undefined;
-    collectionRefs?: string[] | undefined;
-    image?: UploadAssetImageMetadata | undefined;
-    retentionPolicy?: UploadAssetRetentionPolicy | undefined;
-    generatePreview?: boolean | undefined;
-    createdAt?: string | undefined;
-    updatedAt?: string | undefined;
-};
-
-export declare type UploadAssetProgress = {
-    progress: number;
-};
-
-export declare enum UploadAssetRetentionPolicy {
-    retain = "retain",
-    deleteIfNotUsed = "deleteIfNotUsed"
-}
-
-export { }
+import * as rxjs from 'rxjs';
+
+type UploadAssetMetadata = {
+    name?: string | undefined;
+    mimeType?: string | undefined;
+    size?: number | undefined;
+    annotations?: UploadAssetAnnotation[] | undefined;
+    collectionRefs?: string[] | undefined;
+    image?: UploadAssetImageMetadata | undefined;
+    retentionPolicy?: UploadAssetRetentionPolicy | undefined;
+    generatePreview?: boolean | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+};
+type UploadAssetAnnotation = {
+    key: string;
+    value: string;
+};
+type UploadAssetProgress = {
+    progress: number;
+};
+declare enum UploadAssetRetentionPolicy {
+    retain = "retain",
+    deleteIfNotUsed = "deleteIfNotUsed"
+}
+type UploadAssetImageMetadata = {
+    transformations: UploadAssetImageTransformation[];
+};
+type UploadAssetImageTransformation = UploadAssetExtractTransformation | UploadAssetFitTransformation | UploadAssetConvertTransformation;
+type UploadAssetExtractTransformation = {
+    name: 'extract';
+    options: {
+        top: number;
+        left: number;
+        areaWidth: number;
+        areaHeight: number;
+        rotate?: 0 | 90 | 180 | 270 | undefined;
+    };
+};
+type UploadAssetFitTransformation = {
+    name: 'fit';
+    options: {
+        width: number;
+        height: number;
+    };
+};
+type UploadAssetConvertTransformation = {
+    name: 'convert';
+    options: UploadAssetConvertTransformationJpegOptions | UploadAssetConvertTransformationPngOptions | UploadAssetConvertTransformationAvifOptions;
+};
+type UploadAssetConvertTransformationJpegOptions = {
+    format: 'jpeg';
+    options: {
+        quality: number;
+        interlace: boolean;
+    };
+};
+type UploadAssetConvertTransformationPngOptions = {
+    format: 'png';
+    options: {
+        compressionLevel: number;
+    };
+};
+type UploadAssetConvertTransformationAvifOptions = {
+    format: 'avif';
+    options: {
+        quality: number;
+        lossless: boolean;
+    };
+};
+
+type ContelloUploaderParams = {
+    /**
+     * Base URL of the Contello server.
+     * Example: 'https://example.com'
+     */
+    url: string;
+    /**
+     * Project identifier for the Contello project.
+     * Example: 'myProjectId'
+     */
+    project: string;
+    /**
+     * Authentication token for the Contello API.
+     * Example: 'app-a123b456c7890d123456789'
+     */
+    token: string;
+    /**
+     * Transport protocol to use for uploading files.
+     * 'http' uses XMLHttpRequest, 'ws' uses WebSocket.
+     * @default 'ws'
+     */
+    transport?: 'http' | 'ws';
+    /**
+     * Size of each chunk in bytes when uploading files.
+     * Default is 4MB.
+     * @default 4_194_304
+     */
+    chunkSize?: number;
+};
+/**
+ * ContelloUploader is a class for uploading files to a Contello server.
+ * It supports both WebSocket and HTTP transports.
+ */
+declare class ContelloUploader {
+    private params;
+    constructor(params: ContelloUploaderParams);
+    /** Uploads a file and resolves with the asset ID once complete. */
+    upload(file: File, meta?: UploadAssetMetadata | undefined, options?: {
+        abort?: AbortSignal;
+    } | undefined): Promise<{
+        id: string;
+    }>;
+    /** Uploads a file and returns an Observable emitting progress events and the final asset ID. */
+    uploadWithEvents(file: File, meta?: UploadAssetMetadata | undefined, options?: {
+        abort?: AbortSignal;
+    } | undefined): rxjs.Observable<UploadAssetProgress | {
+        id: string;
+    }>;
+}
+
+export { ContelloUploader, type ContelloUploaderParams, type UploadAssetAnnotation, type UploadAssetConvertTransformation, type UploadAssetConvertTransformationAvifOptions, type UploadAssetConvertTransformationJpegOptions, type UploadAssetConvertTransformationPngOptions, type UploadAssetExtractTransformation, type UploadAssetFitTransformation, type UploadAssetImageMetadata, type UploadAssetImageTransformation, type UploadAssetMetadata, type UploadAssetProgress, UploadAssetRetentionPolicy };