nuxt-media-library 0.0.44

package/dist/runtime/server/resource-policy-proxy.js

@@ -0,0 +1,80 @@
+import { createError, defineEventHandler, getRequestHeaders, getRequestURL, proxyRequest } from "h3";
+import { useRuntimeConfig } from "#imports";
+const normalizeHeaders = (headers) => {
+  if (!headers) return {};
+  return typeof headers === "function" ? headers() : headers;
+};
+export default defineEventHandler(async (event) => {
+  try {
+    const config = useRuntimeConfig();
+    const baseURL = config.mediaLibrary?.baseURL;
+    if (!baseURL) {
+      throw createError({ statusCode: 500, statusMessage: "mediaLibrary.baseURL is required for resource policy proxying." });
+    }
+    try {
+      const parsed = new URL(baseURL);
+      if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error("Invalid protocol");
+      }
+    } catch {
+      throw createError({ statusCode: 500, statusMessage: "mediaLibrary.baseURL must be an absolute http(s) URL." });
+    }
+    const reqUrl = getRequestURL(event);
+    const path = reqUrl.pathname;
+    const prefix = "/api/media-library/manage/resource-policies";
+    if (!path.startsWith(prefix)) {
+      throw createError({ statusCode: 404, statusMessage: "Not found" });
+    }
+    const rest = path.slice(prefix.length);
+    const method = event.node.req.method || "GET";
+    const trimmedRest = rest.replace(/\/+$/, "");
+    const isCollection = trimmedRest === "";
+    const isSchema = trimmedRest === "/schema";
+    const isPipelineSteps = trimmedRest === "/pipelines/available-steps";
+    const isItem = !isSchema && !isPipelineSteps && /^\/[^/]+$/.test(trimmedRest);
+    if (!isCollection && !isSchema && !isPipelineSteps && !isItem) {
+      throw createError({ statusCode: 404, statusMessage: "Not found" });
+    }
+    const isDev = import.meta.dev;
+    const writeMethods = ["POST", "PUT", "DELETE"];
+    if (isSchema && method !== "GET") {
+      throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+    }
+    if (isPipelineSteps && method !== "GET") {
+      throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+    }
+    if (isCollection && method !== "GET" && !(isDev && method === "POST")) {
+      throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+    }
+    if (isItem && method !== "GET" && !(isDev && writeMethods.includes(method))) {
+      throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+    }
+    const upstreamPath = `/manage/resource-policies${trimmedRest}`;
+    const normalizedBase = baseURL.endsWith("/") ? baseURL : `${baseURL}/`;
+    const upstreamUrl = new URL(`.${upstreamPath}`, normalizedBase);
+    const incoming = new URLSearchParams(reqUrl.search);
+    incoming.forEach((value, key) => {
+      upstreamUrl.searchParams.append(key, value);
+    });
+    const forwardedHeaders = { ...getRequestHeaders(event) };
+    const extraHeaders = normalizeHeaders(config.mediaLibrary?.headers);
+    const proxyHeaders = { ...forwardedHeaders, ...extraHeaders };
+    delete proxyHeaders.connection;
+    delete proxyHeaders["transfer-encoding"];
+    delete proxyHeaders["keep-alive"];
+    delete proxyHeaders.upgrade;
+    delete proxyHeaders.expect;
+    delete proxyHeaders.host;
+    const result = await proxyRequest(event, upstreamUrl.toString(), {
+      headers: proxyHeaders,
+      streamRequest: true
+    });
+    if (event.node.res.statusCode >= 400) {
+      console.error(`[media-library] resource-policy-proxy upstream responded ${event.node.res.statusCode} for ${method} ${upstreamUrl.toString()}`);
+    }
+    return result;
+  } catch (err) {
+    console.error("[media-library] resource-policy-proxy error:", err);
+    throw err;
+  }
+});

package/dist/runtime/server/uploads-proxy.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/uploads-proxy.js

@@ -0,0 +1,99 @@
+import { createError, defineEventHandler, getRequestHeaders, getRequestURL, proxyRequest } from "h3";
+import { useRuntimeConfig } from "#imports";
+const resolveRoute = (route, params) => {
+  return route.replace(/:(\w+)/g, (_, key) => {
+    const value = params[key];
+    return value === void 0 ? "" : String(value);
+  });
+};
+export default defineEventHandler(async (event) => {
+  try {
+    const config = useRuntimeConfig();
+    const baseURL = config.mediaLibrary?.baseURL;
+    const routes = config.mediaLibrary?.routes;
+    const headers = config.mediaLibrary?.headers;
+    if (!baseURL || !routes) {
+      throw createError({ statusCode: 500, statusMessage: "mediaLibrary.baseURL and routes are required for upload proxying." });
+    }
+    try {
+      const parsed = new URL(baseURL);
+      if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error("Invalid protocol");
+      }
+    } catch {
+      throw createError({ statusCode: 500, statusMessage: "mediaLibrary.baseURL must be an absolute http(s) URL." });
+    }
+    const resolvedBaseURL = baseURL;
+    const resolvedRoutes = routes;
+    const reqUrl = getRequestURL(event);
+    const path = reqUrl.pathname;
+    const prefix = "/api/media-library/manage/uploads";
+    if (!path.startsWith(prefix)) {
+      throw createError({ statusCode: 404, statusMessage: "Not found" });
+    }
+    const rest = path.slice(prefix.length);
+    let upstreamPath = "";
+    const method = event.node.req.method || "GET";
+    if (rest === "/sessions" || rest === "/sessions/") {
+      if (method !== "POST") {
+        throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+      }
+      upstreamPath = resolvedRoutes.createSession;
+    } else {
+      const sessionMatch = rest.match(/^\/sessions\/([^/]+)$/);
+      const partMatch = rest.match(/^\/sessions\/([^/]+)\/parts\/([^/]+)$/);
+      const finalizeMatch = rest.match(/^\/sessions\/([^/]+)\/finalize$/);
+      const abortMatch = rest.match(/^\/sessions\/([^/]+)\/abort$/);
+      if (partMatch) {
+        if (method !== "PUT") {
+          throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+        }
+        upstreamPath = resolveRoute(resolvedRoutes.uploadPart, { id: partMatch[1], part: partMatch[2] });
+      } else if (finalizeMatch) {
+        if (method !== "POST") {
+          throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+        }
+        upstreamPath = resolveRoute(resolvedRoutes.finalize, { id: finalizeMatch[1] });
+      } else if (abortMatch && resolvedRoutes.abort) {
+        if (method !== "DELETE") {
+          throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+        }
+        upstreamPath = resolveRoute(resolvedRoutes.abort, { id: abortMatch[1] });
+      } else if (sessionMatch) {
+        if (method !== "GET") {
+          throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+        }
+        upstreamPath = resolveRoute(resolvedRoutes.getSession, { id: sessionMatch[1] });
+      }
+    }
+    if (!upstreamPath) {
+      throw createError({ statusCode: 404, statusMessage: "Unknown upload route" });
+    }
+    const normalizedBase = resolvedBaseURL.endsWith("/") ? resolvedBaseURL : `${resolvedBaseURL}/`;
+    const upstreamUrl = new URL(`.${upstreamPath}`, normalizedBase);
+    const incoming = new URLSearchParams(reqUrl.search);
+    incoming.forEach((value, key) => {
+      upstreamUrl.searchParams.append(key, value);
+    });
+    const forwardedHeaders = { ...getRequestHeaders(event) };
+    const extraHeaders = typeof headers === "function" ? headers() : headers;
+    const proxyHeaders = { ...forwardedHeaders, ...extraHeaders || {} };
+    delete proxyHeaders.connection;
+    delete proxyHeaders["transfer-encoding"];
+    delete proxyHeaders["keep-alive"];
+    delete proxyHeaders.upgrade;
+    delete proxyHeaders.expect;
+    delete proxyHeaders.host;
+    const result = await proxyRequest(event, upstreamUrl.toString(), {
+      headers: proxyHeaders,
+      streamRequest: true
+    });
+    if (event.node.res.statusCode >= 400) {
+      console.error(`[media-library] uploads-proxy upstream responded ${event.node.res.statusCode} for ${method} ${upstreamUrl.toString()}`);
+    }
+    return result;
+  } catch (err) {
+    console.error("[media-library] uploads-proxy error:", err);
+    throw err;
+  }
+});

package/dist/runtime/types/asset.d.ts

@@ -0,0 +1,174 @@
+export type PreviewUrlType = "presign" | "cdn" | "volume_token";
+export interface PreviewUrlFields {
+    previewUrl: string | null;
+    previewUrlType: PreviewUrlType | null;
+    previewUrlExpiresIn: number | null;
+}
+export interface AssetDetail extends PreviewUrlFields {
+    id: string;
+    kind: string;
+    title: string | null;
+    original_filename: string;
+    originalFilename?: string;
+    mime_type: string;
+    mimeType?: string;
+    size_bytes: number;
+    sizeBytes?: number;
+    bytes?: number;
+    hash_sha256: string | null;
+    hashSha256?: string | null;
+    content_hash_sha256?: string | null;
+    status: string;
+    visibility: string;
+    created_at: string;
+    createdAt?: string;
+    blob_id: string | null;
+    blobId?: string | null;
+    resource_policy_id: string | null;
+    resourcePolicyId?: string | null;
+    renditions: Rendition[];
+    slug?: string | null;
+    created_by?: string | null;
+    updated_at?: string | null;
+    deleted_at?: string | null;
+    upload_session_id?: string | null;
+    primary_blob_id?: string | null;
+}
+export interface AssetSlot {
+    label: string;
+    /** Single-asset slot id; empty string means empty. Ignored when `assetIds` is defined. */
+    assetId?: string;
+    /**
+     * Multi-asset slot ids. When this property is defined (even as `[]`) the
+     * slot is treated as multi-mode and the slot widget will allow multiple
+     * uploads / display the assets as a horizontal strip.
+     */
+    assetIds?: string[];
+    resourceType: string;
+    collectionName?: string | null;
+}
+export declare function getSlotAssetIds(slot: AssetSlot): string[];
+export declare function isMultiSlot(slot: AssetSlot): boolean;
+/** Null on non-FAILED rows. */
+export type ProcessingFailureKind = 'validation' | 'timeout' | 'crash' | 'worker_lost';
+export interface ProcessingTask {
+    id: string;
+    asset_id: string;
+    task_type: string;
+    status: string;
+    attempts: number;
+    last_error: string | null;
+    metadata_payload: Record<string, any> | null;
+    queued_at: string | null;
+    started_at: string | null;
+    finished_at: string | null;
+    input_blob_id?: string | null;
+    inputBlobId?: string | null;
+    output_blob_id?: string | null;
+    outputBlobId?: string | null;
+    rendition_id?: string | null;
+    renditionId?: string | null;
+    options?: Record<string, any> | null;
+    heartbeat_at?: string | null;
+    heartbeatAt?: string | null;
+    max_retries?: number | null;
+    maxRetries?: number | null;
+    failure_kind?: ProcessingFailureKind | null;
+    failureKind?: ProcessingFailureKind | null;
+}
+export interface PipelineOptionSchema {
+    type: string;
+    default?: any;
+    description?: string;
+    min?: number;
+    max?: number;
+    items?: string | {
+        type: string;
+    };
+    allowed_values?: any[];
+}
+export interface PipelineProcessor {
+    options: Record<string, PipelineOptionSchema>;
+}
+export interface PipelineConfig {
+    pipeline: string[];
+    processors: Record<string, PipelineProcessor>;
+}
+export type AvailableSteps = Record<string, PipelineConfig>;
+export interface ListProcessingTasksResponse {
+    items: ProcessingTask[];
+    total: number;
+    page: number;
+    pageSize?: number;
+    page_size?: number;
+    pipeline: string[];
+    pipelineStepsSchema?: Record<string, Record<string, PipelineOptionSchema>>;
+    pipeline_steps_schema?: Record<string, Record<string, PipelineOptionSchema>>;
+}
+export interface RenditionVariant extends PreviewUrlFields {
+    name: string;
+    entrypoint: string;
+    locale: string | null;
+    width: number | null;
+    height: number | null;
+    bitrateKbps: number | null;
+    blobIds: string[];
+    extras: Record<string, any> | null;
+}
+export interface Rendition extends PreviewUrlFields {
+    id: string;
+    renditionType: string;
+    entrypoint: string | null;
+    storagePrefix: string | null;
+    blobIds: string[];
+    variants: RenditionVariant[] | null;
+    status: string;
+    durationSeconds: number | null;
+    pages: number | null;
+    channels: number | null;
+    extras: Record<string, any> | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface DeliveryRenditionVariant extends PreviewUrlFields {
+    name: string;
+    width: number | null;
+    height: number | null;
+    bitrateKbps: number | null;
+}
+export interface DeliveryRendition extends PreviewUrlFields {
+    id: string;
+    renditionType: string;
+    status: string;
+    entrypoint: string | null;
+    durationSeconds: number | null;
+    variants: DeliveryRenditionVariant[];
+}
+export interface DeliveryAsset {
+    id: string;
+    kind: string;
+    title: string | null;
+    status: string;
+    visibility: string;
+    mimeType: string | null;
+    downloadType: string | null;
+    downloadUrl: string | null;
+    downloadUrlExpiresIn: number | null;
+    renditions: DeliveryRendition[];
+}
+export interface DeliveryAssetListResponse {
+    items: DeliveryAsset[];
+    total: number;
+    page: number;
+    pageSize: number;
+}
+export interface DeliveryBatchResolveItem {
+    assetId: string;
+    status: 'ok' | 'not_found';
+    asset: DeliveryAsset | null;
+    error: string | null;
+}
+export interface DeliveryBatchResolveResponse {
+    items: DeliveryBatchResolveItem[];
+    total: number;
+}

package/dist/runtime/types/asset.js

@@ -0,0 +1,7 @@
+export function getSlotAssetIds(slot) {
+  if (slot.assetIds !== void 0) return slot.assetIds;
+  return slot.assetId ? [slot.assetId] : [];
+}
+export function isMultiSlot(slot) {
+  return slot.assetIds !== void 0;
+}

package/dist/runtime/types/preview.d.ts

@@ -0,0 +1,20 @@
+import type { DeliveryAsset, DeliveryRendition } from './asset.js';
+export interface AssetSource {
+    url: string;
+    renditionType: string | null;
+    /** Variant name (e.g. "1080p"); null for rendition-level sources. */
+    name: string | null;
+    width: number | null;
+    height: number | null;
+    bitrateKbps: number | null;
+}
+export type AssetPreview = {
+    id: string;
+    asset_type: string;
+    url: string | null;
+    metadata: DeliveryAsset | null;
+    expiresIn: number | null;
+    renditions: DeliveryRendition[];
+    sources: AssetSource[];
+    forbidden: boolean;
+};

package/dist/runtime/types/resourcePolicy.d.ts

@@ -0,0 +1,77 @@
+export declare enum Visibility {
+    Private = "private",
+    RESTRICTED = "restricted",
+    Public = "public"
+}
+export declare enum AssetKind {
+    Image = "image",
+    ImageBatch = "image_batch",
+    Video = "video",
+    Audio = "audio",
+    Document = "document",
+    Archive = "archive",
+    Font = "font",
+    Model3D = "model_3d",
+    WebApp = "web_app",
+    Other = "other"
+}
+export declare enum ResourcePolicySchemaMode {
+    Create = "create",
+    Update = "update",
+    Response = "response"
+}
+export interface FileConstraintsSchema {
+    allowed_mime_types: string[];
+    max_size_bytes?: number | null;
+    min_size_bytes?: number | null;
+    allow_multiple?: boolean;
+}
+export interface PermissionRequirementsSchema {
+    required_permissions?: string[];
+    allow_anonymous?: boolean;
+}
+export interface ProcessingConfigSchema {
+    auto_process: boolean;
+    step_options?: Record<string, Record<string, any>> | null;
+}
+export interface StorageConfigSchema {
+    storage_class: string;
+    visibility: string;
+}
+export interface CreateResourcePolicyRequest {
+    resource_type: string;
+    collection_name?: string | null;
+    file_constraints: FileConstraintsSchema;
+    permission_requirements?: PermissionRequirementsSchema;
+    processing_config: ProcessingConfigSchema;
+    kind: AssetKind;
+    visibility: Visibility;
+}
+export interface UpdateResourcePolicyRequest {
+    file_constraints?: FileConstraintsSchema | null;
+    permission_requirements?: PermissionRequirementsSchema | null;
+    processing_config?: ProcessingConfigSchema | null;
+    kind?: AssetKind | null;
+    visibility?: Visibility | null;
+    is_active?: boolean | null;
+}
+export interface ResourcePolicyResponse {
+    id: string;
+    tenant_id: string;
+    resource_type: string;
+    collection_name: string | null;
+    file_constraints: FileConstraintsSchema;
+    permission_requirements: PermissionRequirementsSchema;
+    processing_config: ProcessingConfigSchema;
+    storage_config?: StorageConfigSchema;
+    kind: AssetKind;
+    visibility: Visibility;
+    is_active: boolean;
+    version: number;
+    created_at: string;
+    updated_at: string;
+}
+export interface ResourcePolicyListQuery {
+    resource_type?: string | null;
+    is_active?: boolean | null;
+}

package/dist/runtime/types/resourcePolicy.js

@@ -0,0 +1,25 @@
+export var Visibility = /* @__PURE__ */ ((Visibility2) => {
+  Visibility2["Private"] = "private";
+  Visibility2["RESTRICTED"] = "restricted";
+  Visibility2["Public"] = "public";
+  return Visibility2;
+})(Visibility || {});
+export var AssetKind = /* @__PURE__ */ ((AssetKind2) => {
+  AssetKind2["Image"] = "image";
+  AssetKind2["ImageBatch"] = "image_batch";
+  AssetKind2["Video"] = "video";
+  AssetKind2["Audio"] = "audio";
+  AssetKind2["Document"] = "document";
+  AssetKind2["Archive"] = "archive";
+  AssetKind2["Font"] = "font";
+  AssetKind2["Model3D"] = "model_3d";
+  AssetKind2["WebApp"] = "web_app";
+  AssetKind2["Other"] = "other";
+  return AssetKind2;
+})(AssetKind || {});
+export var ResourcePolicySchemaMode = /* @__PURE__ */ ((ResourcePolicySchemaMode2) => {
+  ResourcePolicySchemaMode2["Create"] = "create";
+  ResourcePolicySchemaMode2["Update"] = "update";
+  ResourcePolicySchemaMode2["Response"] = "response";
+  return ResourcePolicySchemaMode2;
+})(ResourcePolicySchemaMode || {});

package/dist/runtime/types/uploader.d.ts

@@ -0,0 +1,71 @@
+export type ChecksumAlgorithm = 'SHA-256';
+export type ResolveRoute = string | ((...args: any[]) => string);
+export interface ChunkUploaderRoutes {
+    createSession: string;
+    getSession: ResolveRoute;
+    uploadPart: ResolveRoute;
+    finalize: ResolveRoute;
+    abort?: ResolveRoute;
+}
+export interface ChunkUploaderChecksumConfig {
+    algorithm: ChecksumAlgorithm;
+    perPart: boolean;
+    final: boolean;
+}
+export interface ChunkUploaderConfig {
+    baseURL: string;
+    routes: ChunkUploaderRoutes;
+    /**
+     * When true, the client will not use baseURL directly and should
+     * send requests to same-origin proxy routes.
+     */
+    proxyUploads?: boolean;
+    partSize: number;
+    concurrency: number;
+    checksum: ChunkUploaderChecksumConfig;
+    headers: Record<string, string> | (() => Record<string, string>);
+}
+export interface CreateUploadSessionRequest {
+    resource_type?: string;
+    collection_name?: string | null;
+    expected_size_bytes?: number;
+    original_filename?: string;
+    mime_type?: string;
+    parts_expected?: number;
+    expected_sha256_hex?: string;
+}
+export interface UploadSessionResponse {
+    id: string;
+    state?: string;
+    part_size_bytes?: number;
+    expected_size_bytes?: number | null;
+    parts_expected?: number | null;
+    parts_received?: number;
+    received_parts?: number[];
+    expires_at?: string;
+    checksum_verified?: boolean;
+    final_blob_id?: string | null;
+}
+export interface FinalizeUploadRequest {
+    expected_sha256_hex?: string;
+}
+export interface UploadProgress {
+    totalBytes: number;
+    uploadedBytes: number;
+    percent: number;
+}
+export interface UploadResult {
+    sessionId: string;
+    finalize?: any;
+    expectedSha256Hex?: string;
+}
+export interface UploadFileOptions {
+    create: CreateUploadSessionRequest;
+    sessionId?: string;
+    onProgress?: (p: UploadProgress) => void;
+    onPartUploaded?: (partNumber: number) => void;
+    onState?: (s: {
+        phase: string;
+        message?: string;
+    }) => void;
+}

package/dist/runtime/utils/uploader/checksum.d.ts

@@ -0,0 +1,21 @@
+import type { ChecksumAlgorithm } from '../../types/uploader.js';
+export declare function toHex(buffer: ArrayBuffer): string;
+export declare function sha256Hex(data: ArrayBuffer): Promise<string>;
+export declare function digestHex(alg: ChecksumAlgorithm, data: ArrayBuffer): Promise<string>;
+/**
+ * Compute final SHA-256 by reading the file in chunks (does NOT load full file into memory).
+ * Uses a streaming-ish approach by buffering chunks and hashing incrementally is not available
+ * natively in WebCrypto, so we do: concatenate blocks? (too big)
+ *
+ * Practical approach:
+ * - If you must do true streaming SHA-256 in browser, use a JS streaming SHA-256 implementation.
+ * - For now: compute final hash by reading all bytes -> not acceptable for huge files.
+ *
+ * So we implement a "progressive" approach using a small dependency-free streaming SHA-256?
+ * Not here.
+ *
+ * Instead we offer:
+ * - per-part integrity always
+ * - optional final hash ONLY if file is within a safe max size threshold.
+ */
+export declare function finalSha256HexIfSmall(file: File, maxBytes?: number): Promise<string>;

package/dist/runtime/utils/uploader/checksum.js

@@ -0,0 +1,23 @@
+export function toHex(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let hex = "";
+  for (const b of bytes) {
+    hex += b.toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+export async function sha256Hex(data) {
+  const digest = await crypto.subtle.digest("SHA-256", data);
+  return toHex(digest);
+}
+export async function digestHex(alg, data) {
+  if (alg !== "SHA-256") throw new Error(`Unsupported checksum algorithm: ${alg}`);
+  return sha256Hex(data);
+}
+export async function finalSha256HexIfSmall(file, maxBytes = 200 * 1024 * 1024) {
+  if (file.size > maxBytes) {
+    throw new Error(`File too large to compute final SHA-256 in this implementation (${file.size} bytes). Enable a streaming SHA-256 lib or compute on server only.`);
+  }
+  const buf = await file.arrayBuffer();
+  return sha256Hex(buf);
+}

package/dist/runtime/utils/uploader/chunking.d.ts

@@ -0,0 +1,8 @@
+export interface PartInfo {
+    partNumber: number;
+    start: number;
+    endExclusive: number;
+    size: number;
+}
+export declare function buildParts(totalSize: number, partSize: number): PartInfo[];
+export declare function clampPercent(x: number): number;

package/dist/runtime/utils/uploader/chunking.js

@@ -0,0 +1,21 @@
+export function buildParts(totalSize, partSize) {
+  if (partSize <= 0) throw new Error("partSize must be > 0");
+  const parts = [];
+  let partNumber = 1;
+  for (let start = 0; start < totalSize; start += partSize) {
+    const endExclusive = Math.min(start + partSize, totalSize);
+    parts.push({
+      partNumber,
+      start,
+      endExclusive,
+      size: endExclusive - start
+    });
+    partNumber++;
+  }
+  return parts;
+}
+export function clampPercent(x) {
+  if (x < 0) return 0;
+  if (x > 100) return 100;
+  return x;
+}

package/dist/runtime/utils/uploader/uploader.d.ts

@@ -0,0 +1,20 @@
+import type { ChunkUploaderConfig, FinalizeUploadRequest, UploadFileOptions, UploadResult, UploadSessionResponse } from '../../types/uploader.js';
+export declare class ChunkUploader {
+    private readonly cfg;
+    private controller;
+    constructor(cfg: ChunkUploaderConfig);
+    abort(): void;
+    createSession(createPayload: any): Promise<UploadSessionResponse>;
+    getSession(sessionId: string): Promise<UploadSessionResponse>;
+    uploadPart(params: {
+        sessionId: string;
+        partNumber: number;
+        blob: Blob;
+        start: number;
+        endExclusive: number;
+        total: number;
+    }): Promise<any>;
+    finalize(sessionId: string, payload: FinalizeUploadRequest): Promise<any>;
+    abortSession(sessionId: string): Promise<void>;
+    uploadFile(file: File, options: UploadFileOptions): Promise<UploadResult>;
+}