@dudousxd/nestjs-media-dashboard 0.1.0

package/dist/server/index.js

@@ -0,0 +1,794 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/server/media-dashboard.module.ts
+import { Module as Module2 } from "@nestjs/common";
+import { RouterModule } from "@nestjs/core";
+
+// src/server/media-console-api.module.ts
+import { Module } from "@nestjs/common";
+
+// src/server/media-console-actions.controller.ts
+import { Body, Controller, Delete, HttpCode, Inject as Inject2, Param, Post, Query } from "@nestjs/common";
+
+// src/server/media-console.service.ts
+import { Inject, Injectable, NotFoundException, Optional } from "@nestjs/common";
+
+// src/server/tokens.ts
+var MEDIA_STORE = Symbol.for("nestjs-media:store");
+var MEDIA_UPLOAD_SESSIONS = Symbol.for("nestjs-media:upload-sessions");
+var MEDIA_STORAGE_SHARED = Symbol.for("nestjs-media:storage");
+var MEDIA_DASHBOARD_BASE_PATH = Symbol("MEDIA_DASHBOARD_BASE_PATH");
+var MEDIA_DASHBOARD_API_PATH = Symbol("MEDIA_DASHBOARD_API_PATH");
+var MEDIA_DASHBOARD_ACTIONS = Symbol("MEDIA_DASHBOARD_ACTIONS");
+
+// src/server/media-console.service.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var URL_TTL_SECONDS = 300;
+var DEFAULT_PAGE_LIMIT = 50;
+function lastSegment(prefix) {
+  const trimmed = prefix.replace(/\/+$/, "");
+  const slash = trimmed.lastIndexOf("/");
+  return slash === -1 ? trimmed : trimmed.slice(slash + 1);
+}
+__name(lastSegment, "lastSegment");
+function mapUpload(session) {
+  const percent = session.size !== void 0 && session.size > 0 ? Math.min(100, Math.round(session.offset / session.size * 100)) : null;
+  return {
+    id: session.id,
+    disk: session.disk,
+    key: session.key,
+    offset: session.offset,
+    size: session.size ?? null,
+    percent,
+    parts: session.parts,
+    multipart: session.multipartUploadId !== void 0,
+    ...session.createdAt ? {
+      createdAt: session.createdAt.toISOString()
+    } : {}
+  };
+}
+__name(mapUpload, "mapUpload");
+function mapRecord(record) {
+  return {
+    id: record.id,
+    ownerType: record.ownerType,
+    ownerId: record.ownerId,
+    collection: record.collection,
+    name: record.name,
+    fileName: record.fileName,
+    mimeType: record.mimeType,
+    size: record.size,
+    disk: record.disk,
+    path: record.path,
+    createdAt: record.createdAt.toISOString()
+  };
+}
+__name(mapRecord, "mapRecord");
+var MediaConsoleService = class {
+  static {
+    __name(this, "MediaConsoleService");
+  }
+  storage;
+  store;
+  uploads;
+  actionsEnabled;
+  constructor(storage, store, uploads, actionsEnabled) {
+    this.storage = storage;
+    this.store = store;
+    this.uploads = uploads;
+    this.actionsEnabled = actionsEnabled;
+  }
+  diskOrThrow(disk) {
+    if (!this.storage || !this.storage.diskNames().includes(disk)) {
+      throw new NotFoundException(`Unknown disk: ${disk}`);
+    }
+    return this.storage.disk(disk);
+  }
+  listDisks() {
+    const storage = this.storage;
+    if (!storage) return {
+      disks: []
+    };
+    const defaultDisk = storage.defaultDisk;
+    return {
+      disks: storage.diskNames().map((name) => ({
+        name,
+        default: name === defaultDisk,
+        capabilities: storage.disk(name).capabilities
+      }))
+    };
+  }
+  async listObjects(disk, options) {
+    const driver = this.diskOrThrow(disk);
+    const result = await driver.list(options.prefix ?? "", {
+      delimiter: "/",
+      ...options.cursor ? {
+        cursor: options.cursor
+      } : {},
+      limit: options.limit ?? DEFAULT_PAGE_LIMIT
+    });
+    return {
+      folders: result.folders.map((prefix) => ({
+        name: lastSegment(prefix),
+        prefix
+      })),
+      files: result.files.map((entry) => ({
+        key: entry.key,
+        name: entry.name,
+        sizeBytes: entry.sizeBytes,
+        lastModified: entry.lastModified ? entry.lastModified.toISOString() : null
+      })),
+      ...result.cursor ? {
+        cursor: result.cursor
+      } : {}
+    };
+  }
+  async objectDetail(disk, key) {
+    const driver = this.diskOrThrow(disk);
+    const stat = driver.stat ? await driver.stat(key) : {
+      size: await driver.size(key)
+    };
+    const url = driver.capabilities.presign ? await driver.temporaryUrl(key, URL_TTL_SECONDS) : await driver.url(key);
+    return {
+      key,
+      size: stat.size,
+      ...stat.contentType ? {
+        contentType: stat.contentType
+      } : {},
+      ...stat.lastModified ? {
+        lastModified: stat.lastModified.toISOString()
+      } : {},
+      url
+    };
+  }
+  async deleteObject(disk, key) {
+    await this.diskOrThrow(disk).delete(key);
+  }
+  async copyObject(disk, from, to) {
+    await this.diskOrThrow(disk).copy(from, to);
+  }
+  async moveObject(disk, from, to) {
+    await this.diskOrThrow(disk).move(from, to);
+  }
+  async listUploads(filter) {
+    if (!this.uploads || typeof this.uploads.list !== "function") return {
+      uploads: []
+    };
+    const sessions = await this.uploads.list({
+      ...filter.disk ? {
+        disk: filter.disk
+      } : {},
+      ...filter.prefix ? {
+        keyPrefix: filter.prefix
+      } : {}
+    });
+    return {
+      uploads: sessions.map(mapUpload)
+    };
+  }
+  async uploadDetail(id) {
+    if (!this.uploads) throw new NotFoundException("No upload store configured");
+    const session = await this.uploads.get(id);
+    if (!session) throw new NotFoundException(`Unknown upload: ${id}`);
+    const parts = this.uploads.listParts ? await this.uploads.listParts(id) : [];
+    return {
+      upload: mapUpload(session),
+      parts
+    };
+  }
+  /**
+  * Cancels a resumable session by removing its record from the upload store, so it stops
+  * appearing as in-progress. NOTE: this does NOT tear down an underlying native multipart upload
+  * (e.g. an S3 multipart) or its temporary parts — the decoupled console resolves only the
+  * `UploadSessionStore`, not the `ResumableUploadManager` that owns `abort()`. An incomplete
+  * multipart is reaped by the bucket's lifecycle policy. Surfaced as "Cancel session" in the UI.
+  */
+  async abortUpload(id) {
+    if (!this.uploads) throw new NotFoundException("No upload store configured");
+    await this.uploads.delete(id);
+  }
+  async listCollections() {
+    if (!this.store || typeof this.store.aggregate !== "function") return {
+      collections: []
+    };
+    const buckets = await this.store.aggregate({
+      groupBy: "collection",
+      sum: "size"
+    });
+    return {
+      collections: buckets
+    };
+  }
+  async listLibrary(filter) {
+    if (!this.store || typeof this.store.list !== "function") return {
+      records: []
+    };
+    const page = await this.store.list({
+      ...filter.collection ? {
+        collection: filter.collection
+      } : {},
+      ...filter.disk ? {
+        disk: filter.disk
+      } : {}
+    }, {
+      limit: filter.limit ?? DEFAULT_PAGE_LIMIT,
+      ...filter.cursor ? {
+        cursor: filter.cursor
+      } : {}
+    });
+    return {
+      records: page.records.map(mapRecord),
+      ...page.cursor ? {
+        cursor: page.cursor
+      } : {}
+    };
+  }
+  async libraryDetail(id) {
+    if (!this.store) throw new NotFoundException("No media store configured");
+    const record = await this.store.find(id);
+    if (!record) throw new NotFoundException(`Unknown media record: ${id}`);
+    const variants = await Promise.all(Object.entries(record.conversions).map(async ([name, conversion]) => {
+      const driver = this.storage?.diskNames().includes(conversion.disk) ? this.storage.disk(conversion.disk) : null;
+      const url = driver?.capabilities.presign ? await driver.temporaryUrl(conversion.path, URL_TTL_SECONDS) : await driver?.url(conversion.path) ?? "";
+      return {
+        name,
+        url
+      };
+    }));
+    return {
+      record: mapRecord(record),
+      variants
+    };
+  }
+  async deleteLibraryRecord(id) {
+    if (!this.store) throw new NotFoundException("No media store configured");
+    await this.store.delete(id);
+  }
+  topology() {
+    return {
+      hasStore: this.store !== null && typeof this.store.list === "function",
+      hasUploads: this.uploads !== null && typeof this.uploads.list === "function",
+      disks: this.storage ? this.storage.diskNames().length : 0,
+      actions: this.actionsEnabled === true
+    };
+  }
+};
+MediaConsoleService = _ts_decorate([
+  Injectable(),
+  _ts_param(0, Optional()),
+  _ts_param(0, Inject(MEDIA_STORAGE_SHARED)),
+  _ts_param(1, Optional()),
+  _ts_param(1, Inject(MEDIA_STORE)),
+  _ts_param(2, Optional()),
+  _ts_param(2, Inject(MEDIA_UPLOAD_SESSIONS)),
+  _ts_param(3, Optional()),
+  _ts_param(3, Inject(MEDIA_DASHBOARD_ACTIONS)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    Object,
+    Object,
+    Object,
+    Object
+  ])
+], MediaConsoleService);
+
+// src/server/media-console-actions.controller.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var MediaConsoleActionsController = class {
+  static {
+    __name(this, "MediaConsoleActionsController");
+  }
+  service;
+  constructor(service) {
+    this.service = service;
+  }
+  deleteObject(disk, key) {
+    return this.service.deleteObject(disk, key);
+  }
+  copyObject(disk, body) {
+    return this.service.copyObject(disk, body.from, body.to);
+  }
+  moveObject(disk, body) {
+    return this.service.moveObject(disk, body.from, body.to);
+  }
+  abortUpload(id) {
+    return this.service.abortUpload(id);
+  }
+  deleteLibraryRecord(id) {
+    return this.service.deleteLibraryRecord(id);
+  }
+};
+_ts_decorate2([
+  Delete("disks/:disk/object"),
+  HttpCode(204),
+  _ts_param2(0, Param("disk")),
+  _ts_param2(1, Query("key")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String,
+    String
+  ]),
+  _ts_metadata2("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], MediaConsoleActionsController.prototype, "deleteObject", null);
+_ts_decorate2([
+  Post("disks/:disk/copy"),
+  HttpCode(204),
+  _ts_param2(0, Param("disk")),
+  _ts_param2(1, Body()),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String,
+    typeof CopyMoveBody === "undefined" ? Object : CopyMoveBody
+  ]),
+  _ts_metadata2("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], MediaConsoleActionsController.prototype, "copyObject", null);
+_ts_decorate2([
+  Post("disks/:disk/move"),
+  HttpCode(204),
+  _ts_param2(0, Param("disk")),
+  _ts_param2(1, Body()),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String,
+    typeof CopyMoveBody === "undefined" ? Object : CopyMoveBody
+  ]),
+  _ts_metadata2("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], MediaConsoleActionsController.prototype, "moveObject", null);
+_ts_decorate2([
+  Post("uploads/:id/abort"),
+  HttpCode(204),
+  _ts_param2(0, Param("id")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata2("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], MediaConsoleActionsController.prototype, "abortUpload", null);
+_ts_decorate2([
+  Delete("library/:id"),
+  HttpCode(204),
+  _ts_param2(0, Param("id")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata2("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], MediaConsoleActionsController.prototype, "deleteLibraryRecord", null);
+MediaConsoleActionsController = _ts_decorate2([
+  Controller(),
+  _ts_param2(0, Inject2(MediaConsoleService)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof MediaConsoleService === "undefined" ? Object : MediaConsoleService
+  ])
+], MediaConsoleActionsController);
+
+// src/server/media-console-read.controller.ts
+import { Controller as Controller2, Get, Inject as Inject3, Param as Param2, Query as Query2 } from "@nestjs/common";
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+function toLimit(value) {
+  if (value === void 0) return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : void 0;
+}
+__name(toLimit, "toLimit");
+var MediaConsoleReadController = class {
+  static {
+    __name(this, "MediaConsoleReadController");
+  }
+  service;
+  constructor(service) {
+    this.service = service;
+  }
+  disks() {
+    return this.service.listDisks();
+  }
+  objects(disk, prefix, cursor, limit) {
+    const limitValue = toLimit(limit);
+    return this.service.listObjects(disk, {
+      ...prefix ? {
+        prefix
+      } : {},
+      ...cursor ? {
+        cursor
+      } : {},
+      ...limitValue !== void 0 ? {
+        limit: limitValue
+      } : {}
+    });
+  }
+  object(disk, key) {
+    return this.service.objectDetail(disk, key);
+  }
+  uploads(disk, prefix) {
+    return this.service.listUploads({
+      ...disk ? {
+        disk
+      } : {},
+      ...prefix ? {
+        prefix
+      } : {}
+    });
+  }
+  upload(id) {
+    return this.service.uploadDetail(id);
+  }
+  collections() {
+    return this.service.listCollections();
+  }
+  library(collection, disk, cursor, limit) {
+    const limitValue = toLimit(limit);
+    return this.service.listLibrary({
+      ...collection ? {
+        collection
+      } : {},
+      ...disk ? {
+        disk
+      } : {},
+      ...cursor ? {
+        cursor
+      } : {},
+      ...limitValue !== void 0 ? {
+        limit: limitValue
+      } : {}
+    });
+  }
+  libraryRecord(id) {
+    return this.service.libraryDetail(id);
+  }
+  topology() {
+    return this.service.topology();
+  }
+};
+_ts_decorate3([
+  Get("disks"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", []),
+  _ts_metadata3("design:returntype", typeof DiskListResponse === "undefined" ? Object : DiskListResponse)
+], MediaConsoleReadController.prototype, "disks", null);
+_ts_decorate3([
+  Get("disks/:disk/objects"),
+  _ts_param3(0, Param2("disk")),
+  _ts_param3(1, Query2("prefix")),
+  _ts_param3(2, Query2("cursor")),
+  _ts_param3(3, Query2("limit")),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    String,
+    String,
+    String,
+    String
+  ]),
+  _ts_metadata3("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], MediaConsoleReadController.prototype, "objects", null);
+_ts_decorate3([
+  Get("disks/:disk/object"),
+  _ts_param3(0, Param2("disk")),
+  _ts_param3(1, Query2("key")),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    String,
+    String
+  ]),
+  _ts_metadata3("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], MediaConsoleReadController.prototype, "object", null);
+_ts_decorate3([
+  Get("uploads"),
+  _ts_param3(0, Query2("disk")),
+  _ts_param3(1, Query2("prefix")),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    String,
+    String
+  ]),
+  _ts_metadata3("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], MediaConsoleReadController.prototype, "uploads", null);
+_ts_decorate3([
+  Get("uploads/:id"),
+  _ts_param3(0, Param2("id")),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata3("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], MediaConsoleReadController.prototype, "upload", null);
+_ts_decorate3([
+  Get("library/collections"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", []),
+  _ts_metadata3("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], MediaConsoleReadController.prototype, "collections", null);
+_ts_decorate3([
+  Get("library"),
+  _ts_param3(0, Query2("collection")),
+  _ts_param3(1, Query2("disk")),
+  _ts_param3(2, Query2("cursor")),
+  _ts_param3(3, Query2("limit")),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    String,
+    String,
+    String,
+    String
+  ]),
+  _ts_metadata3("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], MediaConsoleReadController.prototype, "library", null);
+_ts_decorate3([
+  Get("library/:id"),
+  _ts_param3(0, Param2("id")),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata3("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], MediaConsoleReadController.prototype, "libraryRecord", null);
+_ts_decorate3([
+  Get("topology"),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", []),
+  _ts_metadata3("design:returntype", typeof Topology === "undefined" ? Object : Topology)
+], MediaConsoleReadController.prototype, "topology", null);
+MediaConsoleReadController = _ts_decorate3([
+  Controller2(),
+  _ts_param3(0, Inject3(MediaConsoleService)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof MediaConsoleService === "undefined" ? Object : MediaConsoleService
+  ])
+], MediaConsoleReadController);
+
+// src/server/media-console-api.module.ts
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+var MediaConsoleApiModule = class _MediaConsoleApiModule {
+  static {
+    __name(this, "MediaConsoleApiModule");
+  }
+  static register(actions) {
+    return {
+      module: _MediaConsoleApiModule,
+      controllers: actions ? [
+        MediaConsoleReadController,
+        MediaConsoleActionsController
+      ] : [
+        MediaConsoleReadController
+      ],
+      providers: [
+        MediaConsoleService,
+        {
+          provide: MEDIA_DASHBOARD_ACTIONS,
+          useValue: actions
+        }
+      ],
+      exports: [
+        MediaConsoleService
+      ]
+    };
+  }
+};
+MediaConsoleApiModule = _ts_decorate4([
+  Module({})
+], MediaConsoleApiModule);
+
+// src/server/media-dashboard-ui.controller.ts
+import { existsSync, readFileSync } from "node:fs";
+import { basename, extname, join, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Controller as Controller3, Get as Get2, Header, Inject as Inject4, NotFoundException as NotFoundException2, Param as Param3, StreamableFile } from "@nestjs/common";
+function _ts_decorate5(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+var BUILD_BASE = "/media";
+function spaDir() {
+  return fileURLToPath(new URL("../spa", import.meta.url));
+}
+__name(spaDir, "spaDir");
+var CONTENT_TYPES = {
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".json": "application/json; charset=utf-8",
+  ".woff2": "font/woff2",
+  ".ico": "image/x-icon"
+};
+var MediaDashboardUiController = class {
+  static {
+    __name(this, "MediaDashboardUiController");
+  }
+  basePath;
+  apiBasePath;
+  dir = spaDir();
+  constructor(basePath, apiBasePath) {
+    this.basePath = basePath;
+    this.apiBasePath = apiBasePath;
+  }
+  // index.html references hash-named bundles, so it MUST NOT be cached (stale bundle = "stuck
+  // loading after a deploy"). The hashed assets below are immutable.
+  index() {
+    const indexPath = join(this.dir, "index.html");
+    if (!existsSync(indexPath)) {
+      throw new NotFoundException2("Console SPA is not built. Run the package build.");
+    }
+    const html = readFileSync(indexPath, "utf8").replaceAll(`="${BUILD_BASE}/`, `="${this.basePath}/`);
+    const inject = `<script>window.__MEDIA_BASE__='${this.basePath}';window.__MEDIA_API__='${this.apiBasePath}';</script>`;
+    return html.includes("</head>") ? html.replace("</head>", `${inject}</head>`) : inject + html;
+  }
+  asset(file) {
+    const safe = basename(file);
+    if (safe !== file) throw new NotFoundException2();
+    const root = resolve(this.dir, "assets");
+    const assetPath = resolve(root, safe);
+    if (!assetPath.startsWith(root + sep) || !existsSync(assetPath)) {
+      throw new NotFoundException2();
+    }
+    const type = CONTENT_TYPES[extname(safe)] ?? "application/octet-stream";
+    return new StreamableFile(readFileSync(assetPath), {
+      type
+    });
+  }
+};
+_ts_decorate5([
+  Get2(),
+  Header("Content-Type", "text/html; charset=utf-8"),
+  Header("Cache-Control", "no-store, must-revalidate"),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", []),
+  _ts_metadata4("design:returntype", String)
+], MediaDashboardUiController.prototype, "index", null);
+_ts_decorate5([
+  Get2("assets/:file"),
+  Header("Cache-Control", "public, max-age=31536000, immutable"),
+  _ts_param4(0, Param3("file")),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    String
+  ]),
+  _ts_metadata4("design:returntype", typeof StreamableFile === "undefined" ? Object : StreamableFile)
+], MediaDashboardUiController.prototype, "asset", null);
+MediaDashboardUiController = _ts_decorate5([
+  Controller3(),
+  _ts_param4(0, Inject4(MEDIA_DASHBOARD_BASE_PATH)),
+  _ts_param4(1, Inject4(MEDIA_DASHBOARD_API_PATH)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    String,
+    String
+  ])
+], MediaDashboardUiController);
+
+// src/server/media-dashboard.module.ts
+function _ts_decorate6(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate6, "_ts_decorate");
+function normalize(path) {
+  return `/${path.replace(/^\/+|\/+$/g, "")}`;
+}
+__name(normalize, "normalize");
+var MediaDashboardModule = class _MediaDashboardModule {
+  static {
+    __name(this, "MediaDashboardModule");
+  }
+  static forRoot(options = {}) {
+    const basePath = normalize(options.basePath ?? "/media");
+    const apiBasePath = normalize(options.apiBasePath ?? `${basePath}/api`);
+    const actions = options.actions === true;
+    return {
+      module: _MediaDashboardModule,
+      imports: [
+        MediaConsoleApiModule.register(actions),
+        RouterModule.register([
+          {
+            path: basePath,
+            module: _MediaDashboardModule
+          },
+          {
+            path: apiBasePath,
+            module: MediaConsoleApiModule
+          }
+        ])
+      ],
+      controllers: [
+        MediaDashboardUiController
+      ],
+      providers: [
+        {
+          provide: MEDIA_DASHBOARD_BASE_PATH,
+          useValue: basePath
+        },
+        {
+          provide: MEDIA_DASHBOARD_API_PATH,
+          useValue: apiBasePath
+        }
+      ],
+      // Re-export the API module so its MediaConsoleService reaches importers if they want it.
+      exports: [
+        MediaConsoleApiModule
+      ]
+    };
+  }
+};
+MediaDashboardModule = _ts_decorate6([
+  Module2({})
+], MediaDashboardModule);
+export {
+  MEDIA_STORAGE_SHARED,
+  MEDIA_STORE,
+  MEDIA_UPLOAD_SESSIONS,
+  MediaConsoleApiModule,
+  MediaConsoleService,
+  MediaDashboardModule
+};
+//# sourceMappingURL=index.js.map