@manablox/media 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -0,0 +1,151 @@
+import { AssetCrop, AssetImageEdits, FocalPoint, MediaConfig, SpaceAssetSettings, StorageConfig, mimeTypeAllowed, withinInstance } from "@manablox/core";
+import { StorageDriver } from "@manablox/storage";
+import { AssetRow, Repositories } from "@manablox/db";
+//#region src/edits.d.ts
+/** The edits kept in an asset's `meta`, read leniently so an odd value is ignored, not fatal. */
+export declare function readImageEdits(meta: Record<string, unknown> | null | undefined): AssetImageEdits;
+/**
+ * Checks edits against the image they apply to. A crop must be a whole-pixel rectangle
+ * inside the image; a focal point is a fraction of the *cropped* image, so it is always
+ * inside the unit square whatever the crop.
+ */
+export declare function validateImageEdits(edits: AssetImageEdits, image: {
+  width: number;
+  height: number;
+}): AssetImageEdits;
+/**
+ * The window of a source image that a `cover` resize to `target` keeps, placed so the
+ * focal point stays in view — as close to the window's centre as the edges allow.
+ *
+ * `cover` scales the image until both target sides are covered and trims the rest;
+ * which part is trimmed is the whole point of a focal point. Sharp's own `position`
+ * only knows edges and centres, so the window is computed here and extracted before
+ * the resize.
+ */
+export declare function coverWindow(source: {
+  width: number;
+  height: number;
+}, target: {
+  width: number;
+  height: number;
+}, focal?: FocalPoint): AssetCrop;
+//#endregion
+//#region src/limits.d.ts
+export interface AssetLimits {
+  /** Empty means every type the instance allows. */
+  allowedMimeTypes: string[];
+  maxFileSize: number;
+}
+/**
+ * The limits an upload into a space is held to: the space's own where it has set them,
+ * otherwise the instance's. A space setting never widens — an entry outside the
+ * instance's allowlist is dropped, and a larger size is capped.
+ */
+export declare function resolveAssetLimits(instance: Pick<StorageConfig, 'allowedMimeTypes' | 'maxFileSize'>, space: SpaceAssetSettings | null | undefined, fallbackMaxFileSize?: number): AssetLimits;
+/** Reads the space's asset settings out of its free-form settings, leniently. */
+export declare function readSpaceAssetSettings(settings: Record<string, unknown> | null | undefined): SpaceAssetSettings | null;
+//#endregion
+//#region src/service.d.ts
+export interface UploadInput {
+  spaceId: string;
+  filename: string;
+  mimeType: string;
+  body: Buffer;
+  alt?: string;
+  title?: string;
+  actorId?: string | null;
+}
+export type PresentedAsset = AssetRow & {
+  url: string;
+  thumbnailUrl: string | null;
+};
+export interface MediaServiceOptions {
+  maxFileSize: number;
+  allowedMimeTypes: string[];
+}
+/** Upload, probing, and on-demand image derivatives. */
+export declare class MediaService {
+  private readonly repos;
+  private readonly storage;
+  private readonly config;
+  private readonly options;
+  constructor(repos: Repositories, storage: StorageDriver, config: MediaConfig & {
+    signingSecret?: string;
+  }, options: MediaServiceOptions);
+  /**
+   * The limits an upload into `spaceId` is held to: the space's own settings, narrowed
+   * to the instance's. The instance's are returned alongside so a settings form can show
+   * the ceiling it cannot exceed.
+   */
+  limits(spaceId: string): Promise<{
+    effective: AssetLimits;
+    instance: AssetLimits;
+  }>;
+  upload(input: UploadInput): Promise<AssetRow>;
+  /** Returns bytes for a preset, generating and caching the variant on first request. */
+  derive(asset: AssetRow, presetName: string, format: string): Promise<{
+    body: Buffer;
+    contentType: string;
+  }>;
+  /**
+   * Public URL for a preset — the storage driver's own URL, or a signed transform path.
+   *
+   * A variant URL carries the asset's version, so a crop or focal-point change reaches a
+   * browser or CDN that cached the previous rendering as immutable. The original is
+   * never edited, so its URL stays put.
+   */
+  /**
+   * An asset as a client receives it: the row plus the URLs it needs to show it. The
+   * thumbnail is a rendered variant, which only an image has.
+   */
+  present(asset: AssetRow): PresentedAsset;
+  urlFor(asset: AssetRow, presetName?: string, format?: string): string;
+  /**
+   * Sets an image's crop and focal point. Non-destructive: the original stays as
+   * uploaded, the edits live in `meta`, and every variant derived so far is dropped so
+   * the next request renders through the new edits.
+   */
+  setImageEdits(assetId: string, edits: AssetImageEdits): Promise<AssetRow>;
+  /** The name, alt text and title; the file itself never changes after upload. */
+  update(assetId: string, data: {
+    name?: string | undefined;
+    alt?: string | null | undefined;
+    title?: string | null | undefined;
+  }): Promise<AssetRow>;
+  verify(assetId: string, preset: string, format: string, signature: string | undefined): boolean;
+  delete(assetId: string): Promise<void>;
+  private audit;
+}
+//#endregion
+//#region src/signing.d.ts
+export interface TransformRequest {
+  assetId: string;
+  preset: string;
+  format: string;
+}
+/**
+ * Signed transform URLs.
+ *
+ * Without a signature, an arbitrary `?w=&h=` endpoint is a denial-of-service amplifier:
+ * anyone can ask for thousands of distinct resizes and force the server to decode the
+ * source image each time. Signing means only URLs the CMS emitted are honoured.
+ */
+export declare function signTransform(secret: string, request: TransformRequest): string;
+export declare function verifyTransform(secret: string, request: TransformRequest, signature: string): boolean;
+export declare function transformPath(request: TransformRequest, signature: string): string;
+//#endregion
+//#region src/urls.d.ts
+/**
+ * Makes a media URL absolute against the instance's public origin.
+ *
+ * `MediaService.urlFor` returns a storage-driver URL when there is one (S3, a CDN) and a
+ * root-relative path otherwise (`/media/…`). A relative path is fine for a same-origin
+ * admin and broken for everything the delivery API exists to serve: a frontend on its own
+ * domain resolves `/media/…` against *itself* and gets a 404. Found by driving
+ * `apps/example-plain` in a browser against a public instance on another port.
+ *
+ * Already-absolute URLs, protocol-relative URLs and data URIs are returned untouched.
+ */
+export declare function absoluteMediaUrl(url: string, base: string | undefined): string;
+//#endregion
+export { mimeTypeAllowed, withinInstance };

package/dist/index.js

@@ -0,0 +1,472 @@
+import { ManabloxError, diffRecords, mimeTypeAllowed, snapshotChanges, withinInstance } from "@manablox/core";
+import { createHash, createHmac, timingSafeEqual } from "node:crypto";
+import { buildStorageKey } from "@manablox/storage";
+import sharp from "sharp";
+//#region src/edits.ts
+/** The edits kept in an asset's `meta`, read leniently so an odd value is ignored, not fatal. */
+function readImageEdits(meta) {
+	const edits = {};
+	const crop = meta?.crop;
+	if (crop && [
+		crop.left,
+		crop.top,
+		crop.width,
+		crop.height
+	].every(isFiniteNumber)) edits.crop = {
+		left: crop.left,
+		top: crop.top,
+		width: crop.width,
+		height: crop.height
+	};
+	const focal = meta?.focalPoint;
+	if (focal && isFiniteNumber(focal.x) && isFiniteNumber(focal.y)) edits.focalPoint = {
+		x: focal.x,
+		y: focal.y
+	};
+	return edits;
+}
+/**
+* Checks edits against the image they apply to. A crop must be a whole-pixel rectangle
+* inside the image; a focal point is a fraction of the *cropped* image, so it is always
+* inside the unit square whatever the crop.
+*/
+function validateImageEdits(edits, image) {
+	const out = {};
+	if (edits.crop) {
+		const crop = edits.crop;
+		const whole = [
+			crop.left,
+			crop.top,
+			crop.width,
+			crop.height
+		].every(Number.isInteger);
+		const inside = crop.left >= 0 && crop.top >= 0 && crop.width >= 1 && crop.height >= 1 && crop.left + crop.width <= image.width && crop.top + crop.height <= image.height;
+		if (!whole || !inside) throw ManabloxError.badRequest("asset.crop.outOfBounds", {
+			...crop,
+			...image
+		});
+		if (crop.left !== 0 || crop.top !== 0 || crop.width !== image.width || crop.height !== image.height) out.crop = crop;
+	}
+	if (edits.focalPoint) {
+		const { x, y } = edits.focalPoint;
+		if (!(x >= 0 && x <= 1 && y >= 0 && y <= 1)) throw ManabloxError.badRequest("asset.focalPoint.outOfBounds", {
+			x,
+			y
+		});
+		out.focalPoint = {
+			x: round3(x),
+			y: round3(y)
+		};
+	}
+	return out;
+}
+/**
+* The window of a source image that a `cover` resize to `target` keeps, placed so the
+* focal point stays in view — as close to the window's centre as the edges allow.
+*
+* `cover` scales the image until both target sides are covered and trims the rest;
+* which part is trimmed is the whole point of a focal point. Sharp's own `position`
+* only knows edges and centres, so the window is computed here and extracted before
+* the resize.
+*/
+function coverWindow(source, target, focal = {
+	x: .5,
+	y: .5
+}) {
+	const ratio = target.width / target.height;
+	let width = source.width;
+	let height = Math.round(source.width / ratio);
+	if (height > source.height) {
+		height = source.height;
+		width = Math.round(source.height * ratio);
+	}
+	width = Math.max(1, Math.min(width, source.width));
+	height = Math.max(1, Math.min(height, source.height));
+	return {
+		left: clamp(Math.round(focal.x * source.width - width / 2), 0, source.width - width),
+		top: clamp(Math.round(focal.y * source.height - height / 2), 0, source.height - height),
+		width,
+		height
+	};
+}
+function clamp(value, min, max) {
+	return Math.min(Math.max(value, min), max);
+}
+function round3(value) {
+	return Math.round(value * 1e3) / 1e3;
+}
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+//#endregion
+//#region src/limits.ts
+/**
+* The limits an upload into a space is held to: the space's own where it has set them,
+* otherwise the instance's. A space setting never widens — an entry outside the
+* instance's allowlist is dropped, and a larger size is capped.
+*/
+function resolveAssetLimits(instance, space, fallbackMaxFileSize = 26214400) {
+	const instanceTypes = instance.allowedMimeTypes ?? [];
+	const instanceMax = instance.maxFileSize ?? fallbackMaxFileSize;
+	return {
+		allowedMimeTypes: space?.allowedMimeTypes ? space.allowedMimeTypes.filter((entry) => withinInstance(entry, instanceTypes)) : instanceTypes,
+		maxFileSize: space?.maxFileSize && space.maxFileSize > 0 ? Math.min(space.maxFileSize, instanceMax) : instanceMax
+	};
+}
+/** Reads the space's asset settings out of its free-form settings, leniently. */
+function readSpaceAssetSettings(settings) {
+	const block = settings?.assets;
+	if (!block || typeof block !== "object") return null;
+	const out = {};
+	if (Array.isArray(block.allowedMimeTypes)) out.allowedMimeTypes = block.allowedMimeTypes.filter((entry) => typeof entry === "string");
+	if (typeof block.maxFileSize === "number" && block.maxFileSize > 0) out.maxFileSize = block.maxFileSize;
+	return out;
+}
+//#endregion
+//#region src/signing.ts
+/**
+* Signed transform URLs.
+*
+* Without a signature, an arbitrary `?w=&h=` endpoint is a denial-of-service amplifier:
+* anyone can ask for thousands of distinct resizes and force the server to decode the
+* source image each time. Signing means only URLs the CMS emitted are honoured.
+*/
+function signTransform(secret, request) {
+	return createHmac("sha256", secret).update(`${request.assetId}:${request.preset}:${request.format}`).digest("base64url").slice(0, 32);
+}
+function verifyTransform(secret, request, signature) {
+	const expected = Buffer.from(signTransform(secret, request));
+	const actual = Buffer.from(signature);
+	return expected.length === actual.length && timingSafeEqual(expected, actual);
+}
+function transformPath(request, signature) {
+	return `/media/${request.assetId}/${request.preset}.${request.format}?s=${signature}`;
+}
+//#endregion
+//#region src/service.ts
+const IMAGE_FORMATS = /* @__PURE__ */ new Set([
+	"avif",
+	"webp",
+	"jpeg",
+	"png"
+]);
+/** The storage key and the checksum are the file, which never changes; the rest is the record. */
+const ASSET_DIFF = {
+	expand: ["meta"],
+	ignore: [
+		"driver",
+		"key",
+		"checksum",
+		"actorId"
+	]
+};
+/** Upload, probing, and on-demand image derivatives. */
+var MediaService = class {
+	repos;
+	storage;
+	config;
+	options;
+	constructor(repos, storage, config, options) {
+		this.repos = repos;
+		this.storage = storage;
+		this.config = config;
+		this.options = options;
+	}
+	/**
+	* The limits an upload into `spaceId` is held to: the space's own settings, narrowed
+	* to the instance's. The instance's are returned alongside so a settings form can show
+	* the ceiling it cannot exceed.
+	*/
+	async limits(spaceId) {
+		const space = await this.repos.spaces.findById(spaceId);
+		const instance = resolveAssetLimits(this.options, null, this.options.maxFileSize);
+		return {
+			effective: resolveAssetLimits(this.options, readSpaceAssetSettings(space?.settings), this.options.maxFileSize),
+			instance
+		};
+	}
+	async upload(input) {
+		const { effective: limits } = await this.limits(input.spaceId);
+		if (input.body.byteLength > limits.maxFileSize) throw ManabloxError.badRequest("asset.tooLarge", {
+			size: input.body.byteLength,
+			max: limits.maxFileSize
+		});
+		const detected = await detectMimeType(input.body, input.mimeType);
+		if (!mimeTypeAllowed(detected, limits.allowedMimeTypes)) throw ManabloxError.badRequest("asset.mimeType.notAllowed", { mimeType: detected });
+		const checksum = createHash("sha256").update(input.body).digest("hex");
+		const existing = await this.repos.assets.findByChecksum(input.spaceId, checksum);
+		if (existing) return existing;
+		const key = buildStorageKey(input.spaceId, input.filename);
+		await this.storage.put(key, input.body, { contentType: detected });
+		const dimensions = await probeImage(input.body, detected);
+		const asset = await this.repos.assets.create({
+			spaceId: input.spaceId,
+			driver: this.storage.name,
+			key,
+			filename: key.split("/").pop() ?? input.filename,
+			name: input.filename.replace(/\.[^.]+$/, ""),
+			mimeType: detected,
+			size: input.body.byteLength,
+			width: dimensions?.width ?? null,
+			height: dimensions?.height ?? null,
+			checksum,
+			alt: input.alt ?? null,
+			title: input.title ?? null,
+			actorId: input.actorId ?? null
+		});
+		await this.audit("asset.upload", asset, snapshotChanges(asset, "created", ASSET_DIFF));
+		for (const preset of this.config.eager ?? []) if (this.config.presets?.[preset] && dimensions) await this.derive(asset, preset, this.config.presets[preset]?.format ?? "webp").catch(() => void 0);
+		return asset;
+	}
+	/** Returns bytes for a preset, generating and caching the variant on first request. */
+	async derive(asset, presetName, format) {
+		const preset = this.config.presets?.[presetName];
+		if (!preset) throw ManabloxError.notFound("media.preset.notFound", { preset: presetName });
+		if (!IMAGE_FORMATS.has(format)) throw ManabloxError.badRequest("media.format.unsupported", { format });
+		if (!asset.mimeType.startsWith("image/")) throw ManabloxError.badRequest("media.notAnImage", { assetId: asset.id });
+		const variantKey = `${asset.key}.${presetName}.${format}`;
+		const cached = await this.repos.assets.findVariant(asset.id, presetName, format);
+		if (cached && await this.storage.exists(cached.key)) return {
+			body: await this.storage.get(cached.key),
+			contentType: `image/${format}`
+		};
+		const body = await transform(await this.storage.get(asset.key), preset, format, readImageEdits(asset.meta));
+		const meta = await sharp(body).metadata();
+		await this.storage.put(variantKey, body, {
+			contentType: `image/${format}`,
+			cacheControl: "public, max-age=31536000, immutable"
+		});
+		await this.repos.assets.addVariant({
+			assetId: asset.id,
+			preset: presetName,
+			format,
+			key: variantKey,
+			width: meta.width ?? null,
+			height: meta.height ?? null,
+			size: body.byteLength
+		});
+		return {
+			body,
+			contentType: `image/${format}`
+		};
+	}
+	/**
+	* Public URL for a preset — the storage driver's own URL, or a signed transform path.
+	*
+	* A variant URL carries the asset's version, so a crop or focal-point change reaches a
+	* browser or CDN that cached the previous rendering as immutable. The original is
+	* never edited, so its URL stays put.
+	*/
+	/**
+	* An asset as a client receives it: the row plus the URLs it needs to show it. The
+	* thumbnail is a rendered variant, which only an image has.
+	*/
+	present(asset) {
+		return {
+			...asset,
+			url: this.urlFor(asset),
+			thumbnailUrl: asset.mimeType.startsWith("image/") ? this.urlFor(asset, "thumb", "webp") : null
+		};
+	}
+	urlFor(asset, presetName, format = "webp") {
+		if (!presetName) return this.storage.url(asset.key) ?? `/media/${asset.id}/original`;
+		const version = `v=${asset.updatedAt.getTime().toString(36)}`;
+		const secret = this.config.signingSecret;
+		if (!secret) return `/media/${asset.id}/${presetName}.${format}?${version}`;
+		const request = {
+			assetId: asset.id,
+			preset: presetName,
+			format
+		};
+		return `${transformPath(request, signTransform(secret, request))}&${version}`;
+	}
+	/**
+	* Sets an image's crop and focal point. Non-destructive: the original stays as
+	* uploaded, the edits live in `meta`, and every variant derived so far is dropped so
+	* the next request renders through the new edits.
+	*/
+	async setImageEdits(assetId, edits) {
+		const asset = await this.repos.assets.findById(assetId);
+		if (!asset) throw ManabloxError.notFound("asset.notFound", { id: assetId });
+		if (!asset.mimeType.startsWith("image/") || !asset.width || !asset.height) throw ManabloxError.badRequest("asset.notAnImage", { id: assetId });
+		const valid = validateImageEdits(edits, {
+			width: asset.width,
+			height: asset.height
+		});
+		const meta = { ...asset.meta };
+		if (valid.crop) meta.crop = valid.crop;
+		else delete meta.crop;
+		if (valid.focalPoint) meta.focalPoint = valid.focalPoint;
+		else delete meta.focalPoint;
+		const variants = await this.repos.assets.variants([assetId]);
+		await Promise.all(variants.map((variant) => this.storage.delete(variant.key).catch(() => void 0)));
+		await this.repos.assets.deleteVariants(assetId);
+		const saved = await this.repos.assets.update(assetId, { meta });
+		await this.audit("asset.setImageEdits", saved, diffRecords(asset, saved, ASSET_DIFF));
+		return saved;
+	}
+	/** The name, alt text and title; the file itself never changes after upload. */
+	async update(assetId, data) {
+		const asset = await this.repos.assets.findById(assetId);
+		if (!asset) throw ManabloxError.notFound("asset.notFound", { id: assetId });
+		const saved = await this.repos.assets.update(assetId, data);
+		await this.audit("asset.update", saved, diffRecords(asset, saved, ASSET_DIFF));
+		return saved;
+	}
+	verify(assetId, preset, format, signature) {
+		const secret = this.config.signingSecret;
+		if (!secret) return true;
+		if (!signature) return false;
+		return verifyTransform(secret, {
+			assetId,
+			preset,
+			format
+		}, signature);
+	}
+	async delete(assetId) {
+		const asset = await this.repos.assets.findById(assetId);
+		if (!asset) return;
+		const variants = await this.repos.assets.variants([assetId]);
+		await Promise.all(variants.map((variant) => this.storage.delete(variant.key).catch(() => void 0)));
+		await this.storage.delete(asset.key).catch(() => void 0);
+		await this.repos.assets.delete(assetId);
+		await this.audit("asset.delete", asset, snapshotChanges(asset, "deleted", ASSET_DIFF));
+	}
+	audit(action, asset, changes) {
+		return this.repos.audit.record({
+			spaceId: asset.spaceId,
+			action,
+			targetKind: "asset",
+			targetId: asset.id,
+			targetLabel: asset.name,
+			changes,
+			meta: {
+				mimeType: asset.mimeType,
+				filename: asset.filename
+			}
+		});
+	}
+};
+/**
+* Applies the preset through the asset's edits: the crop first, then — for a preset
+* that fixes both sides with `cover` — the window around the focal point, then the
+* resize. Both extractions fold into one rectangle, since sharp takes a single one
+* ahead of a resize.
+*/
+async function transform(source, preset, format, edits = {}) {
+	const pipeline = sharp(source, { failOn: "error" }).rotate();
+	const oriented = orientedSize(await pipeline.metadata());
+	let region = edits.crop ?? null;
+	const size = region ? {
+		width: region.width,
+		height: region.height
+	} : oriented;
+	if (preset.width && preset.height && (preset.fit ?? "inside") === "cover" && size) {
+		const window = coverWindow(size, {
+			width: preset.width,
+			height: preset.height
+		}, edits.focalPoint ?? void 0);
+		region = {
+			left: (region?.left ?? 0) + window.left,
+			top: (region?.top ?? 0) + window.top,
+			width: window.width,
+			height: window.height
+		};
+	}
+	if (region) pipeline.extract(region);
+	if (preset.width || preset.height) pipeline.resize({
+		...preset.width ? { width: preset.width } : {},
+		...preset.height ? { height: preset.height } : {},
+		fit: preset.fit ?? "inside",
+		withoutEnlargement: true
+	});
+	const quality = preset.quality ?? 82;
+	switch (format) {
+		case "avif": return pipeline.avif({ quality }).toBuffer();
+		case "png": return pipeline.png().toBuffer();
+		case "jpeg": return pipeline.jpeg({
+			quality,
+			mozjpeg: true
+		}).toBuffer();
+		default: return pipeline.webp({ quality }).toBuffer();
+	}
+}
+async function probeImage(body, mimeType) {
+	if (!mimeType.startsWith("image/")) return null;
+	try {
+		return orientedSize(await sharp(body).metadata());
+	} catch {
+		return null;
+	}
+}
+/**
+* The size as displayed, not as stored: a phone photo carries an EXIF orientation that
+* `rotate()` honours, so a crop drawn on the displayed image must be measured against
+* the rotated dimensions or it lands on the wrong part of the picture.
+*/
+function orientedSize(meta) {
+	if (!meta.width || !meta.height) return null;
+	return (meta.orientation ?? 1) >= 5 ? {
+		width: meta.height,
+		height: meta.width
+	} : {
+		width: meta.width,
+		height: meta.height
+	};
+}
+/** Magic-number sniffing for the formats worth trusting; falls back to the declared type. */
+async function detectMimeType(body, declared) {
+	for (const [mimeType, bytes] of [
+		["image/png", [
+			137,
+			80,
+			78,
+			71
+		]],
+		["image/jpeg", [
+			255,
+			216,
+			255
+		]],
+		["image/gif", [
+			71,
+			73,
+			70,
+			56
+		]],
+		["application/pdf", [
+			37,
+			80,
+			68,
+			70
+		]]
+	]) if (bytes.every((byte, index) => body[index] === byte)) return mimeType;
+	if (body.subarray(0, 4).toString("ascii") === "RIFF" && body.subarray(8, 12).toString("ascii") === "WEBP") return "image/webp";
+	if (body.subarray(4, 8).toString("ascii") === "ftyp") {
+		const brand = body.subarray(8, 12).toString("ascii");
+		if (brand.startsWith("avif")) return "image/avif";
+		if (brand.startsWith("heic") || brand.startsWith("mif1")) return "image/heic";
+		if (brand.startsWith("isom") || brand.startsWith("mp4")) return "video/mp4";
+	}
+	return declared;
+}
+//#endregion
+//#region src/urls.ts
+/**
+* Makes a media URL absolute against the instance's public origin.
+*
+* `MediaService.urlFor` returns a storage-driver URL when there is one (S3, a CDN) and a
+* root-relative path otherwise (`/media/…`). A relative path is fine for a same-origin
+* admin and broken for everything the delivery API exists to serve: a frontend on its own
+* domain resolves `/media/…` against *itself* and gets a 404. Found by driving
+* `apps/example-plain` in a browser against a public instance on another port.
+*
+* Already-absolute URLs, protocol-relative URLs and data URIs are returned untouched.
+*/
+function absoluteMediaUrl(url, base) {
+	if (!base) return url;
+	if (!url.startsWith("/") || url.startsWith("//")) return url;
+	return `${base.replace(/\/+$/, "")}${url}`;
+}
+//#endregion
+export { MediaService, absoluteMediaUrl, coverWindow, mimeTypeAllowed, readImageEdits, readSpaceAssetSettings, resolveAssetLimits, signTransform, transformPath, validateImageEdits, verifyTransform, withinInstance };

package/package.json

@@ -1,28 +1,35 @@
 {
   "name": "@manablox/media",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "type": "module",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "default": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     }
   },
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "dependencies": {
-    "@manablox/core": "0.2.0",
-    "@manablox/db": "0.2.0",
-    "@manablox/storage": "0.2.0",
+    "@manablox/core": "0.4.0",
+    "@manablox/db": "0.4.0",
+    "@manablox/storage": "0.4.0",
     "sharp": "^0.35.4"
   },
   "devDependencies": {
     "@manablox/config-typescript": "0.0.0",
     "@types/node": "^26.4.1",
+    "tsdown": "^0.23.0",
     "typescript": "^7.0.2",
     "vitest": "^5.0.0"
   },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "README.md"
+  ],
   "scripts": {
+    "build": "tsdown",
     "typecheck": "tsc --noEmit",
     "test": "vitest run"
   }