nuxt-media-library 0.0.44

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

@@ -0,0 +1,206 @@
+import { buildParts, clampPercent } from "./chunking.js";
+import { digestHex, finalSha256HexIfSmall } from "./checksum.js";
+function resolveRoute(route, ...args) {
+  if (typeof route === "function") return route(...args);
+  if (typeof route !== "string") return "";
+  let argIndex = 0;
+  return route.replace(/:(\w+)/g, (_match, key) => {
+    const value = args[argIndex++];
+    if (value === void 0 || value === null) {
+      throw new Error(`Missing route param: ${key}`);
+    }
+    return encodeURIComponent(String(value));
+  });
+}
+function getHeaders(cfg) {
+  const h = cfg.headers;
+  return typeof h === "function" ? h() : h || {};
+}
+async function limitedMap(items, concurrency, worker, signal) {
+  const results = Array.from({ length: items.length });
+  let idx = 0;
+  const runners = Array.from({ length: Math.max(1, concurrency) }, async () => {
+    while (true) {
+      if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+      const current = idx++;
+      if (current >= items.length) break;
+      const item = items[current];
+      if (item === void 0) break;
+      results[current] = await worker(item);
+    }
+  });
+  await Promise.all(runners);
+  return results;
+}
+export class ChunkUploader {
+  cfg;
+  controller = null;
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  abort() {
+    this.controller?.abort();
+  }
+  async createSession(createPayload) {
+    const url = this.cfg.baseURL + resolveRoute(this.cfg.routes.createSession);
+    return await $fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...getHeaders(this.cfg)
+      },
+      body: createPayload,
+      signal: this.controller?.signal
+    });
+  }
+  async getSession(sessionId) {
+    const url = this.cfg.baseURL + resolveRoute(this.cfg.routes.getSession, sessionId);
+    return await $fetch(url, {
+      method: "GET",
+      headers: {
+        ...getHeaders(this.cfg)
+      },
+      signal: this.controller?.signal
+    });
+  }
+  async uploadPart(params) {
+    const { sessionId, partNumber, blob, start, endExclusive, total } = params;
+    const url = this.cfg.baseURL + resolveRoute(this.cfg.routes.uploadPart, sessionId, partNumber);
+    let partShaHex;
+    if (this.cfg.checksum.perPart) {
+      const arr = await blob.arrayBuffer();
+      partShaHex = await digestHex(this.cfg.checksum.algorithm, arr);
+    }
+    const headers = {
+      ...getHeaders(this.cfg),
+      "Content-Type": "application/octet-stream",
+      "Content-Range": `bytes ${start}-${endExclusive - 1}/${total}`
+    };
+    if (partShaHex) headers["X-Part-SHA256"] = partShaHex;
+    return await $fetch(url, {
+      method: "PUT",
+      headers,
+      body: blob,
+      signal: this.controller?.signal
+    });
+  }
+  async finalize(sessionId, payload) {
+    const url = this.cfg.baseURL + resolveRoute(this.cfg.routes.finalize, sessionId);
+    return await $fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...getHeaders(this.cfg)
+      },
+      body: payload,
+      signal: this.controller?.signal
+    });
+  }
+  async abortSession(sessionId) {
+    const abortRoute = this.cfg.routes.abort;
+    if (!abortRoute) return;
+    const url = this.cfg.baseURL + resolveRoute(abortRoute, sessionId);
+    await $fetch(url, {
+      method: "POST",
+      headers: {
+        ...getHeaders(this.cfg)
+      },
+      signal: this.controller?.signal
+    });
+  }
+  async uploadFile(file, options) {
+    this.controller = new AbortController();
+    const concurrency = this.cfg.concurrency;
+    const onProgress = options.onProgress;
+    const onPartUploaded = options.onPartUploaded;
+    const onState = options.onState;
+    const totalBytes = file.size;
+    let uploadedBytes = 0;
+    const emitProgress = () => {
+      if (!onProgress) return;
+      const percent = clampPercent(uploadedBytes / Math.max(1, totalBytes) * 100);
+      const p = { totalBytes, uploadedBytes, percent };
+      onProgress(p);
+    };
+    onState?.({ phase: "init" });
+    let expectedSha256Hex;
+    if (this.cfg.checksum.final) {
+      onState?.({
+        phase: "checksum.final.compute",
+        message: "Computing final SHA-256 (may be skipped for large files)"
+      });
+      expectedSha256Hex = await finalSha256HexIfSmall(file).catch(() => void 0);
+    }
+    let sessionId = options.sessionId;
+    let session;
+    if (!sessionId) {
+      onState?.({ phase: "session.create" });
+      const createPayload = {
+        ...options.create,
+        expected_size_bytes: options.create.expected_size_bytes ?? file.size,
+        original_filename: options.create.original_filename ?? file.name,
+        mime_type: options.create.mime_type ?? file.type,
+        // do NOT trust client part size; server decides
+        parts_expected: void 0,
+        expected_sha256_hex: options.create.expected_sha256_hex ?? expectedSha256Hex
+      };
+      session = await this.createSession(createPayload);
+      sessionId = session.id;
+    } else {
+      onState?.({ phase: "session.fetch" });
+      session = await this.getSession(sessionId);
+      if (session.expected_size_bytes != null && session.expected_size_bytes !== file.size) {
+        throw new Error("This session was created for a different file size; cannot resume.");
+      }
+    }
+    const effectivePartSize = session.part_size_bytes ?? this.cfg.partSize;
+    const parts = buildParts(file.size, effectivePartSize);
+    const partsExpected = parts.length;
+    const receivedParts = new Set(session.received_parts || []);
+    uploadedBytes = (() => {
+      let sum = 0;
+      for (const partNo of receivedParts) {
+        const idx = partNo - 1;
+        const start = idx * effectivePartSize;
+        if (start >= file.size) continue;
+        const endExclusive = Math.min(start + effectivePartSize, file.size);
+        sum += endExclusive - start;
+      }
+      return sum;
+    })();
+    emitProgress();
+    const queue = parts.filter((p) => !receivedParts.has(p.partNumber));
+    onState?.({
+      phase: "upload.parts",
+      message: `Uploading ${queue.length}/${partsExpected} parts`
+    });
+    await limitedMap(queue, concurrency, async (p) => {
+      if (this.controller?.signal.aborted) throw new DOMException("Aborted", "AbortError");
+      const blob = file.slice(p.start, p.endExclusive);
+      await this.uploadPart({
+        sessionId,
+        partNumber: p.partNumber,
+        blob,
+        start: p.start,
+        endExclusive: p.endExclusive,
+        total: file.size
+      });
+      uploadedBytes += p.size;
+      onPartUploaded?.(p.partNumber);
+      emitProgress();
+      return true;
+    }, this.controller.signal);
+    onState?.({ phase: "finalize" });
+    const finalizePayload = {
+      expected_sha256_hex: expectedSha256Hex
+    };
+    const finalizeRes = await this.finalize(sessionId, finalizePayload);
+    onState?.({ phase: "done" });
+    emitProgress();
+    return {
+      sessionId,
+      finalize: finalizeRes,
+      expectedSha256Hex
+    };
+  }
+}

package/dist/types.d.mts

@@ -0,0 +1,11 @@
+export { default } from './module.mjs'
+
+export { type ChunkUploaderRoutesConfig, type ModuleOptions } from './module.mjs'
+
+export * from '../dist/runtime/types/resourcePolicy.js'
+
+export * from '../dist/runtime/types/uploader.js'
+
+export * from '../dist/runtime/types/preview.js'
+
+export * from '../dist/runtime/types/asset.js'

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "nuxt-media-library",
+  "version": "0.0.44",
+  "description": "Nuxt module for media library management — chunked uploads, asset previews, and resource policies",
+  "repository": "fritill-team/nuxt-media-library",
+  "license": "MIT",
+  "type": "module",
+  "types": "./dist/types.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    },
+    "./server": {
+      "types": "./dist/runtime/server/index.d.ts",
+      "import": "./dist/runtime/server/index.js"
+    },
+    "./style.css": "./dist/runtime/css/index.css"
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "yarn dev:prepare && nuxi dev playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
+    "build": "nuxt build playground",
+    "admin:dev": "yarn dev:prepare && yarn --cwd admin-playground dev",
+    "prepack": "nuxt-module-build build",
+    "lint": "eslint .",
+    "test": "yarn dev:prepare && nuxi prepare test/fixtures/basic && vitest run"
+  },
+  "peerDependencies": {
+    "@nuxt/ui": "^4.0.0",
+    "dashjs": "^4.7.0 || ^5.0.0",
+    "hls.js": "^1.5.0",
+    "zod": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "hls.js": {
+      "optional": true
+    },
+    "dashjs": {
+      "optional": true
+    }
+  },
+  "packageManager": "yarn@1.22.22",
+  "dependencies": {
+    "@nuxt/kit": "^4.2.2"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^3.1.1",
+    "@nuxt/devtools-kit": "^2.3.0",
+    "@nuxt/devtools-ui-kit": "^3.2.0",
+    "@nuxt/eslint-config": "^1.12.1",
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "^4.2.2",
+    "@nuxt/test-utils": "^3.21.0",
+    "@nuxt/ui": "4.3.0",
+    "@types/node": "latest",
+    "dashjs": "^5.1.1",
+    "eslint": "^9.39.2",
+    "hls.js": "^1.6.16",
+    "nuxt": "^4.2.2",
+    "sirv": "^3.0.1",
+    "typescript": "~5.9.3",
+    "vitest": "^4.0.15",
+    "vue-tsc": "^3.1.8",
+    "zod": "^4.3.5"
+  }
+}