appos 0.3.5-0 → 0.3.7-0

package/dist/exports/api/generate-image-variant-DOIzj1wJ.mjs

@@ -0,0 +1,4 @@
+import "./workflow-BuSWHcX-.mjs";
+import { n as resizeSchema, r as transformationsSchema, t as generateImageVariant } from "./generate-image-variant-DxOPoGAk.mjs";
+
+export { generateImageVariant };

package/dist/exports/api/generate-image-variant-DxOPoGAk.mjs

@@ -0,0 +1,118 @@
+import { C as object, E as string, S as number, b as literal, l as _enum, p as boolean } from "./zod-CdrJdBtV.mjs";
+import { n as defineWorkflow } from "./workflow-BuSWHcX-.mjs";
+
+//#region src/api/workflows/generate-image-variant.ts
+/**
+* Resize options schema for image transformations.
+*/
+const resizeSchema = object({
+	width: number().optional(),
+	height: number().optional(),
+	fit: _enum([
+		"cover",
+		"contain",
+		"fill",
+		"inside",
+		"outside"
+	]).optional(),
+	position: _enum([
+		"top",
+		"right top",
+		"right",
+		"right bottom",
+		"bottom",
+		"left bottom",
+		"left",
+		"left top",
+		"centre"
+	]).optional(),
+	kernel: _enum([
+		"nearest",
+		"linear",
+		"cubic",
+		"mitchell",
+		"lanczos2",
+		"lanczos3"
+	]).optional()
+});
+/**
+* Image transformations schema.
+* Supports resize, rotate, flip, flop, sharpen, blur, grayscale, format conversion.
+*/
+const transformationsSchema = object({
+	resize: resizeSchema.optional(),
+	rotate: number().optional(),
+	flip: boolean().optional(),
+	flop: boolean().optional(),
+	sharpen: boolean().optional(),
+	blur: number().optional(),
+	grayscale: boolean().optional(),
+	format: _enum([
+		"jpeg",
+		"png",
+		"webp",
+		"avif",
+		"gif"
+	]).optional(),
+	quality: number().min(1).max(100).optional(),
+	preview: literal(true).optional()
+});
+/**
+* Generate image variant workflow. Applies transformations to create variants.
+*
+* Algorithm:
+* 1. Fetch blob by ID
+* 2. Download blob content
+* 3. Apply transformations using Sharp:
+*    - Resize with various fit options
+*    - Rotate by degrees
+*    - Flip/flop (vertical/horizontal mirror)
+*    - Sharpen, blur, grayscale filters
+*    - Format conversion with quality settings
+* 4. Store variant with transformation metadata
+*/
+const generateImageVariant = defineWorkflow({
+	input: object({
+		blobId: string(),
+		transformations: transformationsSchema
+	}),
+	async run({ container, input: { blobId, transformations }, step }) {
+		if (!await step("fetch-blob", async () => {
+			return container.storage.primary.getBlob(blobId);
+		})) throw new Error(`Blob ${blobId} not found`);
+		const buffer = await step("download-blob", async () => {
+			return container.storage.primary.downloadBlob(blobId);
+		});
+		if (!buffer) throw new Error(`Failed to download blob ${blobId}`);
+		const variantBuffer = await step("apply-transformations", async () => {
+			const sharp = (await import("sharp")).default;
+			let pipeline = sharp(buffer);
+			if (transformations.resize) pipeline = pipeline.resize({
+				width: transformations.resize.width,
+				height: transformations.resize.height,
+				fit: transformations.resize.fit,
+				position: transformations.resize.position,
+				kernel: transformations.resize.kernel
+			});
+			if (transformations.rotate !== void 0) pipeline = pipeline.rotate(transformations.rotate);
+			if (transformations.flip) pipeline = pipeline.flip();
+			if (transformations.flop) pipeline = pipeline.flop();
+			if (transformations.sharpen) pipeline = pipeline.sharpen();
+			if (transformations.blur !== void 0) pipeline = pipeline.blur(transformations.blur);
+			if (transformations.grayscale) pipeline = pipeline.grayscale();
+			if (transformations.format) pipeline = pipeline.toFormat(transformations.format, { quality: transformations.quality });
+			return pipeline.toBuffer();
+		});
+		const variant = await step("store-variant", async () => {
+			return container.storage.primary.createVariant(blobId, transformations, variantBuffer);
+		});
+		container.logger.info({
+			blobId,
+			variantId: variant.id
+		}, "Image variant generated");
+		return variant;
+	}
+});
+
+//#endregion
+export { resizeSchema as n, transformationsSchema as r, generateImageVariant as t };

package/dist/exports/api/generate-preview-CvTFuq58.mjs

@@ -0,0 +1,160 @@
+import { t as zod_default } from "./zod-CdrJdBtV.mjs";
+import { n as defineWorkflow } from "./workflow-BuSWHcX-.mjs";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+
+//#region src/api/workflows/generate-preview.ts
+/**
+* Generate preview workflow. Creates preview images/thumbnails for PDFs and videos.
+*
+* Algorithm:
+* 1. Fetch blob by ID
+* 2. Download blob content
+* 3. Generate preview based on content type:
+*    - Video: Extract frame at specified time using FFmpeg
+*    - PDF: Render first page using pdfjs-dist + canvas
+*    - Image: Resize to max 800x800 maintaining aspect ratio
+* 4. Store preview as a special variant with "preview" transformation key
+*/
+const generatePreview = defineWorkflow({
+	input: zod_default.object({
+		blobId: zod_default.string(),
+		timeInSeconds: zod_default.number().optional()
+	}),
+	async run({ container, input: { blobId, timeInSeconds = 1 }, step }) {
+		const blob = await step("fetch-blob", async () => {
+			return container.storage.primary.getBlob(blobId);
+		});
+		if (!blob) throw new Error(`Blob ${blobId} not found`);
+		const buffer = await step("download-blob", async () => {
+			return container.storage.primary.downloadBlob(blobId);
+		});
+		if (!buffer) throw new Error(`Failed to download blob ${blobId}`);
+		let previewBuffer = null;
+		if (blob.contentType?.startsWith("video/")) previewBuffer = await step("generate-video-preview", async () => {
+			return new Promise((resolve$1, reject) => {
+				try {
+					const ffmpeg = spawn("ffmpeg", [
+						"-i",
+						"pipe:0",
+						"-ss",
+						timeInSeconds.toString(),
+						"-frames:v",
+						"1",
+						"-f",
+						"image2pipe",
+						"-c:v",
+						"png",
+						"pipe:1"
+					]);
+					const chunks = [];
+					const errorChunks = [];
+					ffmpeg.stdout.on("data", (chunk) => {
+						chunks.push(chunk);
+					});
+					ffmpeg.stderr.on("data", (chunk) => {
+						errorChunks.push(chunk);
+					});
+					ffmpeg.on("close", async (code) => {
+						if (code === 0) try {
+							const pngBuffer = Buffer.concat(chunks);
+							const sharp = (await import("sharp")).default;
+							resolve$1(await sharp(pngBuffer).jpeg({ quality: 80 }).toBuffer());
+						} catch (error) {
+							container.logger.error({
+								error,
+								blobId
+							}, "Failed to convert video frame to JPEG");
+							reject(error);
+						}
+						else {
+							const errorMessage = Buffer.concat(errorChunks).toString();
+							const error = /* @__PURE__ */ new Error(`FFmpeg exited with code ${code}: ${errorMessage}`);
+							container.logger.error({
+								error,
+								blobId,
+								code,
+								stderr: errorMessage
+							}, "Failed to generate video preview");
+							reject(error);
+						}
+					});
+					ffmpeg.on("error", (error) => {
+						container.logger.error({
+							error,
+							blobId
+						}, "Failed to spawn FFmpeg process");
+						reject(error);
+					});
+					ffmpeg.stdin.on("error", (error) => {
+						if (error.code !== "EPIPE") container.logger.error({
+							error,
+							blobId
+						}, "Failed to write to FFmpeg stdin");
+					});
+					ffmpeg.stdin.write(buffer);
+					ffmpeg.stdin.end();
+				} catch (error) {
+					container.logger.error({
+						error,
+						blobId
+					}, "Failed to generate video preview");
+					reject(error);
+				}
+			});
+		});
+		else if (blob.contentType === "application/pdf") previewBuffer = await step("generate-pdf-preview", async () => {
+			try {
+				const pdfjsLib = await import("./pdf-YxB2Hm1p.mjs");
+				const { createCanvas } = await import("canvas");
+				const sharp = (await import("sharp")).default;
+				const standardFontDataUrl = `${join(process.cwd(), "node_modules/pdfjs-dist/standard_fonts")}/`;
+				const page = await (await pdfjsLib.getDocument({
+					data: new Uint8Array(buffer),
+					standardFontDataUrl
+				}).promise).getPage(1);
+				const viewport = page.getViewport({ scale: 2 });
+				const canvas = createCanvas(viewport.width, viewport.height);
+				const context = canvas.getContext("2d");
+				await page.render({
+					canvasContext: context,
+					viewport,
+					canvas
+				}).promise;
+				return await sharp(canvas.toBuffer("image/png")).resize(800, 800, {
+					fit: "inside",
+					withoutEnlargement: true
+				}).jpeg({ quality: 85 }).toBuffer();
+			} catch (error) {
+				container.logger.error({
+					error,
+					errorMessage: error instanceof Error ? error.message : String(error),
+					errorStack: error instanceof Error ? error.stack : void 0,
+					errorCode: error?.code,
+					blobId
+				}, "Failed to generate PDF preview");
+				throw error;
+			}
+		});
+		else if (blob.contentType?.startsWith("image/")) previewBuffer = await step("generate-image-preview", async () => {
+			const sharp = (await import("sharp")).default;
+			return await sharp(buffer).resize(800, 800, {
+				fit: "inside",
+				withoutEnlargement: true
+			}).jpeg({ quality: 85 }).toBuffer();
+		});
+		else throw new Error(`Preview generation not supported for content type: ${blob.contentType}`);
+		const preview = await step("store-preview", async () => {
+			return await container.storage.primary.createVariant(blobId, { preview: true }, previewBuffer);
+		});
+		container.logger.info({
+			blobId,
+			previewId: preview.id,
+			contentType: blob.contentType
+		}, "Preview generated");
+		return preview;
+	}
+});
+
+//#endregion
+export { generatePreview as t };

package/dist/exports/api/generate-preview-Dk3coswZ.mjs

@@ -0,0 +1,4 @@
+import "./workflow-BuSWHcX-.mjs";
+import { t as generatePreview } from "./generate-preview-CvTFuq58.mjs";
+
+export { generatePreview };