@videxo/sdk 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export { DEFAULT_BASE_URL, DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT_MS, DEFAULT_WAIT, Fonts, Jobs, Outputs, Presets, Uploads, Videxo, Webhooks, type CreateOptions, type RequestOptions, type UploadOptions, type VidexoOptions, type WaitOptions, } from './client.ts';
+export { DEFAULT_BASE_URL, DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT_MS, DEFAULT_WAIT, ClientTokens, Fonts, Jobs, Outputs, Presets, Uploads, Videxo, Webhooks, type ClientTokenForJobOptions, type ClientTokenForUploadOptions, type CreateOptions, type RequestOptions, type UploadOptions, type VidexoOptions, type WaitOptions, } from './client.ts';
 export { SDK_ERROR_CODES, VidexoError, VidexoWebhookError, type ApiErrorCode, type SdkErrorCode, type VidexoErrorCode, type VidexoWebhookErrorCode, } from './errors.ts';
 export { MAX_RETRY_AFTER_SECONDS, type RetryPolicy } from './transport.ts';
-export { sendUpload, type SendUploadOptions, type UploadData } from './uploads.ts';
+export { sendUpload, type SendUploadOptions, type UploadData, type UploadProgress } from './uploads.ts';
 export { WEBHOOK_TOLERANCE_SECONDS, verifyWebhook, type VerifyWebhookOptions, type WebhookHeaders } from './webhooks.ts';
 export type * from './types.ts';
 export type { components, paths } from './generated/openapi.ts';

package/dist/index.js

@@ -1,6 +1,7 @@
 // @videxo/sdk: the TypeScript client of the Videxo API (README.md). Runs on Node 20+, Bun, Deno and
-// Workers, and `sendUpload()` in browsers: it uses only fetch, Web Streams and WebCrypto.
-export { DEFAULT_BASE_URL, DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT_MS, DEFAULT_WAIT, Fonts, Jobs, Outputs, Presets, Uploads, Videxo, Webhooks, } from "./client.js";
+// Workers, and `sendUpload()` in browsers: it uses only fetch, Web Streams and WebCrypto. Apps and web
+// pages use the separate entry `@videxo/sdk/client` (src/app-client.ts), with a client token.
+export { DEFAULT_BASE_URL, DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT_MS, DEFAULT_WAIT, ClientTokens, Fonts, Jobs, Outputs, Presets, Uploads, Videxo, Webhooks, } from "./client.js";
 export { SDK_ERROR_CODES, VidexoError, VidexoWebhookError, } from "./errors.js";
 export { MAX_RETRY_AFTER_SECONDS } from "./transport.js";
 export { sendUpload } from "./uploads.js";

package/dist/types.d.ts

@@ -28,6 +28,13 @@ export type StoryboardRequest = JsonBody<paths['/v1/storyboard']['post']>;
 export type GifRequest = JsonBody<paths['/v1/gif']['post']>;
 export type AudioRequest = JsonBody<paths['/v1/audio']['post']>;
 export type ConcatRequest = JsonBody<paths['/v1/concat']['post']>;
+export type SlideshowRequest = JsonBody<paths['/v1/slideshow']['post']>;
+export type ProbeRequest = JsonBody<paths['/v1/probe']['post']>;
+/** The Job, with what ffprobe read in `probe` once it succeeded. */
+export type ProbeResponse = Schemas['ProbeResponse'];
+export type MediaMetadata = NonNullable<ProbeResponse['probe']>;
+export type MediaStream = Schemas['MediaStream'];
+export type ScenesRequest = JsonBody<paths['/v1/scenes']['post']>;
 export type Font = Schemas['Font'];
 export type FontList = Schemas['FontList'];
 export type Preset = Schemas['Preset'];
@@ -43,6 +50,13 @@ export type CompletedUpload = {
     content_type: string;
     expires_at: string;
 };
+export type ClientToken = Schemas['ClientToken'];
+export type ClientGrant = Schemas['ClientGrant'];
+export type CreateClientTokenRequest = JsonBody<paths['/v1/client-tokens']['post']>;
+export type ClientTokenInfo = Schemas['ClientTokenInfo'];
+export type ClientJob = Schemas['ClientJob'];
+export type ClientJobOutput = Schemas['ClientJobOutput'];
+export type ClientJobList = Schemas['ClientJobList'];
 export type Problem = Schemas['Problem'];
 export type FieldError = Schemas['FieldError'];
 export type CommandProblem = Schemas['CommandProblem'];

package/dist/uploads.d.ts

@@ -9,6 +9,11 @@ export type SendUploadOptions = {
     /** No timeout by default: a large file may take a while. */
     timeoutMs?: number | null;
 };
+/** How far an upload has come. */
+export type UploadProgress = {
+    loaded: number;
+    total: number;
+};
 /** The byte length of `data`, when it can be known without reading it. */
 export declare function sizeOf(data: UploadData): number | null;
 /**
@@ -17,3 +22,11 @@ export declare function sizeOf(data: UploadData): number | null;
  * once the bytes start to flow, so this request is never retried.
  */
 export declare function sendUpload(uploadUrl: string, data: UploadData, options?: SendUploadOptions): Promise<CompletedUpload>;
+/**
+ * `sendUpload` that reports its progress. A browser sends through `XMLHttpRequest`, the one API that
+ * reports upload progress there; elsewhere the bytes are counted as a stream hands them over. A
+ * custom `fetch` always goes through `fetch`; in a browser it reports the end only.
+ */
+export declare function sendUploadWithProgress(uploadUrl: string, data: UploadData, total: number, options: SendUploadOptions & {
+    onProgress(progress: UploadProgress): void;
+}): Promise<CompletedUpload>;

package/dist/uploads.js

@@ -25,7 +25,9 @@ export async function sendUpload(uploadUrl, data, options = {}) {
     const request = new Request(uploadUrl, init);
     const userFetch = options.fetch;
     const response = await send({ fetch: userFetch ? (input, init) => userFetch(input, init) : runtimeFetch, maxRetries: 0, timeoutMs: options.timeoutMs ?? null }, request, { retry: 'never', signal: options.signal, buffer: true });
-    const text = await response.text();
+    return completedUpload(response, await response.text());
+}
+function completedUpload(response, text) {
     let body = text;
     try {
         body = JSON.parse(text);
@@ -40,3 +42,73 @@ export async function sendUpload(uploadUrl, data, options = {}) {
         throw sdkError('invalid_response', 'The upload URL answered without the completed upload.', { status: response.status, body });
     return value;
 }
+/**
+ * `sendUpload` that reports its progress. A browser sends through `XMLHttpRequest`, the one API that
+ * reports upload progress there; elsewhere the bytes are counted as a stream hands them over. A
+ * custom `fetch` always goes through `fetch`; in a browser it reports the end only.
+ */
+export function sendUploadWithProgress(uploadUrl, data, total, options) {
+    const { onProgress, ...sending } = options;
+    const stream = typeof ReadableStream !== 'undefined' && data instanceof ReadableStream;
+    const Xhr = globalThis.XMLHttpRequest;
+    if (Xhr && !stream) {
+        if (!options.fetch || options.fetch === runtimeFetch)
+            return sendWithXhr(new Xhr(), uploadUrl, data, total, options);
+        // A custom fetch in a browser: not every browser can send a stream as a request body, so the bytes
+        // go as they are and the progress comes once, when they are all sent.
+        return sendUpload(uploadUrl, data, sending).then((completed) => {
+            onProgress({ loaded: total, total });
+            return completed;
+        });
+    }
+    const source = stream ? data : new Response(data).body;
+    let loaded = 0;
+    const counted = source.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            loaded += chunk.byteLength;
+            controller.enqueue(chunk);
+            onProgress({ loaded, total });
+        },
+    }));
+    return sendUpload(uploadUrl, counted, sending);
+}
+function sendWithXhr(xhr, uploadUrl, data, total, options) {
+    return new Promise((resolve, reject) => {
+        if (options.signal?.aborted)
+            return reject(sdkError('aborted', 'The upload was aborted.', { cause: options.signal.reason }));
+        const onAbort = () => xhr.abort();
+        const done = () => options.signal?.removeEventListener('abort', onAbort);
+        options.signal?.addEventListener('abort', onAbort, { once: true });
+        xhr.open('PUT', uploadUrl);
+        xhr.setRequestHeader('Content-Type', options.contentType ?? 'application/octet-stream');
+        if (options.timeoutMs)
+            xhr.timeout = options.timeoutMs;
+        xhr.upload.onprogress = (event) => options.onProgress({ loaded: event.loaded, total: event.lengthComputable ? event.total : total });
+        xhr.onload = () => {
+            done();
+            const headers = new Headers();
+            const requestId = xhr.getResponseHeader('request-id');
+            if (requestId)
+                headers.set('request-id', requestId);
+            try {
+                resolve(completedUpload({ ok: xhr.status >= 200 && xhr.status < 300, status: xhr.status, statusText: xhr.statusText, headers }, xhr.responseText));
+            }
+            catch (error) {
+                reject(error);
+            }
+        };
+        xhr.onerror = () => {
+            done();
+            reject(sdkError('network_error', 'The upload failed: the connection was lost.'));
+        };
+        xhr.ontimeout = () => {
+            done();
+            reject(sdkError('timeout', `The upload got no answer within ${options.timeoutMs} ms.`));
+        };
+        xhr.onabort = () => {
+            done();
+            reject(sdkError('aborted', 'The upload was aborted.', { cause: options.signal?.reason }));
+        };
+        xhr.send(data);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@videxo/sdk",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "The TypeScript client of the Videxo API: hosted ffmpeg jobs over HTTP.",
   "license": "MIT",
   "author": "Videxo",
@@ -23,6 +23,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./client": {
+      "types": "./dist/app-client.d.ts",
+      "import": "./dist/app-client.js",
+      "default": "./dist/app-client.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [