mulmocast 0.0.2 → 0.0.4

package/lib/types/schema.js

@@ -22,56 +22,57 @@ export const speechOptionsSchema = z
 const speakerIdSchema = z.string();
 const speakerDataSchema = z
     .object({
-    displayName: z.record(langSchema, z.string()),
+    displayName: z.record(langSchema, z.string()).optional(),
     voiceId: z.string(),
     speechOptions: speechOptionsSchema.optional(),
 })
     .strict();
 export const speakerDictionarySchema = z.record(speakerIdSchema, speakerDataSchema);
-const mediaSourceSchema = z.discriminatedUnion("kind", [
+export const mediaSourceSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("url"), url: URLStringSchema }).strict(), // https://example.com/foo.pdf
-    z.object({ kind: z.literal("data"), data: z.string() }).strict(), // base64
+    z.object({ kind: z.literal("base64"), data: z.string() }).strict(), // base64
+    z.object({ kind: z.literal("text"), text: z.string() }).strict(), // plain text
     z.object({ kind: z.literal("path"), path: z.string() }).strict(), // foo.pdf
 ]);
 // String is easier for AI, string array is easier for human
 const stringOrStringArray = z.union([z.string(), z.array(z.string())]);
-const MulmoMarkdownMediaSchema = z
+export const mulmoMarkdownMediaSchema = z
     .object({
     type: z.literal("markdown"),
     markdown: stringOrStringArray,
 })
     .strict();
-const MulmoWebMediaSchema = z
+const mulmoWebMediaSchema = z
     .object({
     type: z.literal("web"),
     url: URLStringSchema,
 })
     .strict();
-const MulmoPdfMediaSchema = z
+const mulmoPdfMediaSchema = z
     .object({
     type: z.literal("pdf"),
     source: mediaSourceSchema,
 })
     .strict();
-const MulmoImageMediaSchema = z
+export const mulmoImageMediaSchema = z
     .object({
     type: z.literal("image"),
     source: mediaSourceSchema,
 })
     .strict();
-const MulmoSvgMediaSchema = z
+const mulmoSvgMediaSchema = z
     .object({
     type: z.literal("svg"),
     source: mediaSourceSchema,
 })
     .strict();
-const MulmoMovieMediaSchema = z
+const mulmoMovieMediaSchema = z
     .object({
     type: z.literal("movie"),
     source: mediaSourceSchema,
 })
     .strict();
-const MulmoTextSlideMediaSchema = z
+export const mulmoTextSlideMediaSchema = z
     .object({
     type: z.literal("textSlide"),
     slide: z.object({
@@ -80,44 +81,45 @@ const MulmoTextSlideMediaSchema = z
     }),
 })
     .strict();
-const MulmoChartMediaSchema = z
+export const mulmoChartMediaSchema = z
     .object({
     type: z.literal("chart"),
     title: z.string(),
     chartData: z.record(z.any()),
 })
     .strict();
-const MulmoMermaidMediaSchema = z
+export const mulmoMermaidMediaSchema = z
     .object({
     type: z.literal("mermaid"),
     title: z.string().describe("The title of the diagram"),
-    code: z.string().describe("The code of the mermaid diagram"),
+    code: mediaSourceSchema.describe("The code of the mermaid diagram"),
+    appendix: z.array(z.string()).optional().describe("The appendix of the mermaid diagram; typically, style information."),
 })
     .strict();
 export const mulmoImageAssetSchema = z.union([
-    MulmoMarkdownMediaSchema,
-    MulmoWebMediaSchema,
-    MulmoPdfMediaSchema,
-    MulmoImageMediaSchema,
-    MulmoSvgMediaSchema,
-    MulmoMovieMediaSchema,
-    MulmoTextSlideMediaSchema,
-    MulmoChartMediaSchema,
-    MulmoMermaidMediaSchema,
+    mulmoMarkdownMediaSchema,
+    mulmoWebMediaSchema,
+    mulmoPdfMediaSchema,
+    mulmoImageMediaSchema,
+    mulmoSvgMediaSchema,
+    mulmoMovieMediaSchema,
+    mulmoTextSlideMediaSchema,
+    mulmoChartMediaSchema,
+    mulmoMermaidMediaSchema,
 ]);
-const MulmoAudioMediaSchema = z
+const mulmoAudioMediaSchema = z
     .object({
     type: z.literal("audio"),
     source: mediaSourceSchema,
 })
     .strict();
-const MulmoMidiMediaSchema = z
+const mulmoMidiMediaSchema = z
     .object({
     type: z.literal("midi"),
     source: z.string(), // TODO: define it later
 })
     .strict();
-export const mulmoAudioAssetSchema = z.union([MulmoAudioMediaSchema, MulmoMidiMediaSchema]);
+export const mulmoAudioAssetSchema = z.union([mulmoAudioMediaSchema, mulmoMidiMediaSchema]);
 export const mulmoImageParamsSchema = z
     .object({
     model: z.string().optional(), // default: provider specific
@@ -128,7 +130,7 @@ export const mulmoImageParamsSchema = z
     .strict();
 export const textSlideParamsSchema = z
     .object({
-    cssStyles: z.array(z.string()),
+    cssStyles: stringOrStringArray,
 })
     .strict();
 export const videoParamsSchema = z
@@ -138,7 +140,7 @@ export const videoParamsSchema = z
     .strict();
 export const mulmoBeatSchema = z
     .object({
-    speaker: speakerIdSchema,
+    speaker: speakerIdSchema.default("Presenter"),
     text: z.string(),
     image: mulmoImageAssetSchema.optional(),
     audio: mulmoAudioAssetSchema.optional(),
@@ -169,17 +171,19 @@ export const mulmoSpeechParamsSchema = z
 })
     .strict();
 export const text2ImageProviderSchema = z.union([z.literal("openai"), z.literal("google")]).default("openai");
-export const mulmoScriptSchema = z
-    .object({
-    // global settings
+export const mulmoPresentationStyleSchema = z.object({
     $mulmocast: mulmoCastCreditSchema,
-    title: z.string(),
-    description: z.string().optional(),
-    reference: z.string().optional(),
-    lang: langSchema.optional(), // default "en"
     canvasSize: mulmoCanvasDimensionSchema, // has default value
-    beats: z.array(mulmoBeatSchema),
-    speechParams: mulmoSpeechParamsSchema,
+    speechParams: mulmoSpeechParamsSchema.default({
+        speakers: {
+            Presenter: {
+                voiceId: "shimmer",
+                displayName: {
+                    en: "Presenter",
+                },
+            },
+        },
+    }),
     imageParams: mulmoImageParamsSchema
         .extend({
         provider: text2ImageProviderSchema, // has default value
@@ -188,15 +192,30 @@ export const mulmoScriptSchema = z
     // for textSlides
     textSlideParams: textSlideParamsSchema.optional(),
     videoParams: videoParamsSchema.optional(),
-    // images: ImageInfo[] // generated
-    imagePath: z.string().optional(), // for keynote images movie ??
+    // TODO: Switch to showCaptions later
     omitCaptions: z.boolean().optional(), // default is false
+});
+export const mulmoReferenceSchema = z.object({
+    url: URLStringSchema,
+    title: z.string().optional(),
+    description: z.string().optional(),
+    type: z.union([z.literal("article"), z.literal("image"), z.literal("video"), z.literal("audio")]).default("article"),
+});
+export const mulmoScriptSchema = mulmoPresentationStyleSchema
+    .extend({
+    title: z.string().optional(),
+    description: z.string().optional(),
+    references: z.array(mulmoReferenceSchema).optional(),
+    lang: langSchema.optional(), // default "en"
+    beats: z.array(mulmoBeatSchema).min(1),
+    // TODO: Delete it later
+    imagePath: z.string().optional(), // for keynote images movie ??
     // for debugging
     __test_invalid__: z.boolean().optional(),
 })
     .strict();
-export const mulmoStudioBeatSchema = mulmoBeatSchema
-    .extend({
+export const mulmoStudioBeatSchema = z
+    .object({
     multiLingualTexts: multiLingualTextsSchema.optional(),
     hash: z.string().optional(),
     duration: z.number().optional(),
@@ -208,7 +227,7 @@ export const mulmoStudioSchema = z
     .object({
     script: mulmoScriptSchema,
     filename: z.string(),
-    beats: z.array(mulmoStudioBeatSchema),
+    beats: z.array(mulmoStudioBeatSchema).min(1),
 })
     .strict();
 export const mulmoScriptTemplateSchema = z
@@ -219,4 +238,19 @@ export const mulmoScriptTemplateSchema = z
     script: mulmoScriptSchema.optional(),
 })
     .strict();
+export const mulmoStoryboardSceneSchema = z
+    .object({
+    description: z.string(),
+    references: z.array(mulmoReferenceSchema).optional(),
+})
+    .describe("A detailed description of the content of the scene, not the presentation style")
+    .strict();
+export const mulmoStoryboardSchema = z
+    .object({
+    title: z.string(),
+    references: z.array(mulmoReferenceSchema).optional(),
+    scenes: z.array(mulmoStoryboardSceneSchema),
+})
+    .describe("A storyboard for a presentation, a story, a video, etc.")
+    .strict();
 export const urlsSchema = z.array(z.string().url({ message: "Invalid URL format" }));

package/lib/types/type.d.ts

@@ -1,4 +1,5 @@
-import { langSchema, localizedTextSchema, mulmoBeatSchema, mulmoScriptSchema, mulmoStudioSchema, mulmoStudioBeatSchema, speakerDictionarySchema, mulmoImageParamsSchema, mulmoSpeechParamsSchema, textSlideParamsSchema, speechOptionsSchema, mulmoCanvasDimensionSchema, mulmoScriptTemplateSchema, text2ImageProviderSchema, text2SpeechProviderSchema } from "./schema.js";
+import { langSchema, localizedTextSchema, mulmoBeatSchema, mulmoScriptSchema, mulmoStudioSchema, mulmoStudioBeatSchema, mulmoStoryboardSchema, mulmoStoryboardSceneSchema, speakerDictionarySchema, mulmoImageParamsSchema, mulmoSpeechParamsSchema, textSlideParamsSchema, speechOptionsSchema, mulmoCanvasDimensionSchema, mulmoScriptTemplateSchema, text2ImageProviderSchema, text2SpeechProviderSchema, mulmoPresentationStyleSchema, mulmoMermaidMediaSchema, mulmoTextSlideMediaSchema, mulmoMarkdownMediaSchema, mulmoImageMediaSchema, mulmoChartMediaSchema, mediaSourceSchema } from "./schema.js";
+import { pdf_modes, pdf_sizes } from "../utils/const.js";
 import { z } from "zod";
 export type LANG = z.infer<typeof langSchema>;
 export type MulmoBeat = z.infer<typeof mulmoBeatSchema>;
@@ -11,10 +12,19 @@ export type Text2ImageProvider = z.infer<typeof text2ImageProviderSchema>;
 export type Text2SpeechProvider = z.infer<typeof text2SpeechProviderSchema>;
 export type LocalizedText = z.infer<typeof localizedTextSchema>;
 export type MulmoScript = z.infer<typeof mulmoScriptSchema>;
+export type MulmoPresentationStyle = z.infer<typeof mulmoPresentationStyleSchema>;
 export type MulmoCanvasDimension = z.infer<typeof mulmoCanvasDimensionSchema>;
+export type MulmoStoryboardScene = z.infer<typeof mulmoStoryboardSceneSchema>;
+export type MulmoStoryboard = z.infer<typeof mulmoStoryboardSchema>;
 export type MulmoStudioBeat = z.infer<typeof mulmoStudioBeatSchema>;
+export type MulmoMediaSource = z.infer<typeof mediaSourceSchema>;
 export type MulmoStudio = z.infer<typeof mulmoStudioSchema>;
 export type MulmoScriptTemplate = z.infer<typeof mulmoScriptTemplateSchema>;
+export type MulmoTextSlideMedia = z.infer<typeof mulmoTextSlideMediaSchema>;
+export type MulmoMarkdownMedia = z.infer<typeof mulmoMarkdownMediaSchema>;
+export type MulmoImageMedia = z.infer<typeof mulmoImageMediaSchema>;
+export type MulmoChartMedia = z.infer<typeof mulmoChartMediaSchema>;
+export type MulmoMermaidMedia = z.infer<typeof mulmoMermaidMediaSchema>;
 export type FileDirs = {
     mulmoFilePath: string;
     mulmoFileDirPath: string;
@@ -34,4 +44,21 @@ export type ScriptingParams = {
     cacheDirPath: string;
     templateName: string;
     filename: string;
+    llm_model?: string;
+    llm_agent?: string;
 };
+export type ImageProcessorParams = {
+    beat: MulmoBeat;
+    context: MulmoStudioContext;
+    imagePath: string;
+    textSlideStyle: string;
+    canvasSize: MulmoCanvasDimension;
+};
+export type PDFMode = (typeof pdf_modes)[number];
+export type PDFSize = (typeof pdf_sizes)[number];
+export type Text2ImageAgentInfo = {
+    provider: Text2ImageProvider;
+    agent: string;
+    imageParams: MulmoImageParams;
+};
+export type BeatMediaType = "movie" | "image";

package/lib/utils/const.d.ts

@@ -2,3 +2,5 @@ export declare const outDirName = "output";
 export declare const audioDirName = "audio";
 export declare const imageDirName = "images";
 export declare const cacheDirName = "cache";
+export declare const pdf_modes: string[];
+export declare const pdf_sizes: string[];

package/lib/utils/const.js

@@ -2,3 +2,5 @@ export const outDirName = "output";
 export const audioDirName = "audio";
 export const imageDirName = "images";
 export const cacheDirName = "cache";
+export const pdf_modes = ["slide", "talk", "handout"];
+export const pdf_sizes = ["letter", "a4"];

package/lib/utils/file.d.ts

@@ -1,4 +1,5 @@
-import { MulmoScript, MulmoScriptTemplate } from "../types/index.js";
+import { MulmoScript, MulmoScriptTemplate, MulmoMediaSource, MulmoStudioContext } from "../types/index.js";
+import { PDFMode } from "../types/index.js";
 export declare function readMulmoScriptFile<T = MulmoScript>(path: string, errorMessage: string): {
     mulmoData: T;
     mulmoDataPath: string;
@@ -28,6 +29,7 @@ export declare const getAudioSegmentFilePath: (audioDirPath: string, studioFileN
 export declare const getAudioCombinedFilePath: (audioDirPath: string, fileName: string) => string;
 export declare const getAudioArtifactFilePath: (outDirPath: string, fileName: string) => string;
 export declare const getOutputVideoFilePath: (outDirPath: string, fileName: string) => string;
+export declare const getOutputPdfFilePath: (outDirPath: string, fileName: string, pdfMode: PDFMode) => string;
 export declare const getTemplateFilePath: (templateName: string) => string;
 export declare const mkdir: (dirPath: string) => void;
 export declare const silentPath: string;
@@ -41,3 +43,4 @@ export declare const getAvailableTemplates: () => (MulmoScriptTemplate & {
     filename: string;
 })[];
 export declare const writingMessage: (filePath: string) => void;
+export declare const resolveMediaSource: (source: MulmoMediaSource, context: MulmoStudioContext) => string | null;

package/lib/utils/file.js

@@ -1,8 +1,10 @@
 import fs from "fs";
 import path from "path";
+import { parse as yamlParse } from "yaml";
 import { fileURLToPath } from "url";
 import { GraphAILogger } from "graphai";
 import { MulmoScriptTemplateMethods } from "../methods/mulmo_script_template.js";
+import { MulmoStudioContextMethods } from "../methods/index.js";
 import { mulmoScriptTemplateSchema } from "../types/schema.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -16,7 +18,7 @@ export function readMulmoScriptFile(arg2, errorMessage) {
         return null;
     }
     const scriptData = fs.readFileSync(scriptPath, "utf-8");
-    const script = JSON.parse(scriptData);
+    const script = ([".yaml", ".yml"].includes(path.extname(scriptPath).toLowerCase()) ? yamlParse(scriptData) : JSON.parse(scriptData));
     const parsedPath = path.parse(scriptPath);
     return {
         mulmoData: script,
@@ -58,6 +60,9 @@ export const getAudioArtifactFilePath = (outDirPath, fileName) => {
 export const getOutputVideoFilePath = (outDirPath, fileName) => {
     return path.resolve(outDirPath, fileName + ".mp4");
 };
+export const getOutputPdfFilePath = (outDirPath, fileName, pdfMode) => {
+    return path.resolve(outDirPath, fileName + "_" + pdfMode + ".pdf");
+};
 export const getTemplateFilePath = (templateName) => {
     return path.resolve(__dirname, "../../assets/templates/" + templateName + ".json");
 };
@@ -117,3 +122,12 @@ export const getAvailableTemplates = () => {
 export const writingMessage = (filePath) => {
     GraphAILogger.info(`writing: ${filePath}`);
 };
+export const resolveMediaSource = (source, context) => {
+    if (source.kind === "path") {
+        return MulmoStudioContextMethods.resolveAssetPath(context, source.path);
+    }
+    if (source.kind === "url") {
+        return source.url;
+    }
+    return null;
+};

package/lib/utils/filters.js

@@ -4,7 +4,7 @@ import path from "path";
 import fsPromise from "fs/promises";
 import { GraphAILogger } from "graphai";
 import { writingMessage } from "./file.js";
-import { text2hash } from "./text_hash.js";
+import { text2hash } from "./utils.js";
 export const fileCacheAgentFilter = async (context, next) => {
     const { namedInputs } = context;
     const { file, text, force } = namedInputs;

package/lib/utils/image_plugins/chart.d.ts

@@ -0,0 +1,3 @@
+import { ImageProcessorParams } from "../../types/index.js";
+export declare const imageType = "chart";
+export declare const process: (params: ImageProcessorParams) => Promise<string | undefined>;

package/lib/utils/image_plugins/chart.js

@@ -0,0 +1,18 @@
+import { getHTMLFile } from "../file.js";
+import { renderHTMLToImage, interpolate } from "../markdown.js";
+export const imageType = "chart";
+const processChart = async (params) => {
+    const { beat, imagePath, canvasSize, textSlideStyle } = params;
+    if (!beat.image || beat.image.type !== imageType)
+        return;
+    const template = getHTMLFile("chart");
+    const htmlData = interpolate(template, {
+        title: beat.image.title,
+        style: textSlideStyle,
+        width: Math.round(canvasSize.width * 0.625).toString(),
+        chart_data: JSON.stringify(beat.image.chartData),
+    });
+    await renderHTMLToImage(htmlData, imagePath, canvasSize.width, canvasSize.height);
+    return imagePath;
+};
+export const process = processChart;

package/lib/utils/image_plugins/image.d.ts

@@ -0,0 +1,2 @@
+export declare const imageType = "image";
+export declare const process: (params: import("../../types/type.js").ImageProcessorParams) => string | undefined;

package/lib/utils/image_plugins/image.js

@@ -0,0 +1,3 @@
+import { processSource } from "./source.js";
+export const imageType = "image";
+export const process = processSource(imageType);

package/lib/utils/image_plugins/index.d.ts

@@ -0,0 +1,7 @@
+import * as pluginTextSlide from "./text_slide.js";
+import * as pluginMarkdown from "./markdown.js";
+import * as pluginImage from "./image.js";
+import * as pluginChart from "./chart.js";
+import * as pluginMermaid from "./mermaid.js";
+import * as pluginMovie from "./movie.js";
+export declare const imagePlugins: (typeof pluginTextSlide | typeof pluginMarkdown | typeof pluginImage | typeof pluginChart | typeof pluginMermaid | typeof pluginMovie)[];

package/lib/utils/image_plugins/index.js

@@ -0,0 +1,7 @@
+import * as pluginTextSlide from "./text_slide.js";
+import * as pluginMarkdown from "./markdown.js";
+import * as pluginImage from "./image.js";
+import * as pluginChart from "./chart.js";
+import * as pluginMermaid from "./mermaid.js";
+import * as pluginMovie from "./movie.js";
+export const imagePlugins = [pluginTextSlide, pluginMarkdown, pluginImage, pluginChart, pluginMermaid, pluginMovie];

package/lib/utils/image_plugins/markdown.d.ts

@@ -0,0 +1,3 @@
+import { ImageProcessorParams } from "../../types/index.js";
+export declare const imageType = "markdown";
+export declare const process: (params: ImageProcessorParams) => Promise<string | undefined>;

package/lib/utils/image_plugins/markdown.js

@@ -0,0 +1,11 @@
+import { renderMarkdownToImage } from "../markdown.js";
+export const imageType = "markdown";
+const processMarkdown = async (params) => {
+    const { beat, imagePath, textSlideStyle, canvasSize } = params;
+    if (!beat.image || beat.image.type !== imageType)
+        return;
+    const markdown = Array.isArray(beat.image.markdown) ? beat.image.markdown.join("\n") : beat.image.markdown;
+    await renderMarkdownToImage(markdown, textSlideStyle, imagePath, canvasSize.width, canvasSize.height);
+    return imagePath;
+};
+export const process = processMarkdown;

package/lib/utils/image_plugins/mermaid.d.ts

@@ -0,0 +1,3 @@
+import { ImageProcessorParams } from "../../types/index.js";
+export declare const imageType = "mermaid";
+export declare const process: (params: ImageProcessorParams) => Promise<string | undefined>;

package/lib/utils/image_plugins/mermaid.js

@@ -0,0 +1,21 @@
+import { MulmoMediaSourceMethods } from "../../methods/index.js";
+import { getHTMLFile } from "../file.js";
+import { renderHTMLToImage, interpolate } from "../markdown.js";
+export const imageType = "mermaid";
+const processMermaid = async (params) => {
+    const { beat, imagePath, canvasSize, context, textSlideStyle } = params;
+    if (!beat.image || beat.image.type !== imageType)
+        return;
+    const template = getHTMLFile("mermaid");
+    const diagram_code = await MulmoMediaSourceMethods.getText(beat.image.code, context);
+    if (diagram_code) {
+        const htmlData = interpolate(template, {
+            title: beat.image.title,
+            style: textSlideStyle,
+            diagram_code: `${diagram_code}\n${beat.image.appendix?.join("\n") ?? ""}`,
+        });
+        await renderHTMLToImage(htmlData, imagePath, canvasSize.width, canvasSize.height);
+    }
+    return imagePath;
+};
+export const process = processMermaid;

package/lib/utils/image_plugins/movie.d.ts

@@ -0,0 +1,2 @@
+export declare const imageType = "movie";
+export declare const process: (params: import("../../types/type.js").ImageProcessorParams) => string | undefined;

package/lib/utils/image_plugins/movie.js

@@ -0,0 +1,3 @@
+import { processSource } from "./source.js";
+export const imageType = "movie";
+export const process = processSource(imageType);

package/lib/utils/image_plugins/source.d.ts

@@ -0,0 +1,4 @@
+import { ImageProcessorParams } from "../../types/index.js";
+type ImageType = "image" | "movie";
+export declare const processSource: (imageType: ImageType) => (params: ImageProcessorParams) => string | undefined;
+export {};

package/lib/utils/image_plugins/source.js

@@ -0,0 +1,15 @@
+import { GraphAILogger } from "graphai";
+import { resolveMediaSource } from "../../utils/file.js";
+export const processSource = (imageType) => {
+    return (params) => {
+        const { beat, context } = params;
+        if (!beat.image || beat.image.type !== imageType)
+            return;
+        const path = resolveMediaSource(beat.image.source, context);
+        if (path) {
+            return path;
+        }
+        GraphAILogger.error(`Image Plugin unknown ${imageType} source type:`, beat.image);
+        throw new Error(`ERROR: unknown ${imageType} source type`);
+    };
+};

package/lib/utils/image_plugins/text_slide.d.ts

@@ -0,0 +1,3 @@
+import { ImageProcessorParams } from "../../types/index.js";
+export declare const imageType = "textSlide";
+export declare const process: (params: ImageProcessorParams) => Promise<string | undefined>;

package/lib/utils/image_plugins/text_slide.js

@@ -0,0 +1,12 @@
+import { renderMarkdownToImage } from "../markdown.js";
+export const imageType = "textSlide";
+const processTextSlide = async (params) => {
+    const { beat, imagePath, textSlideStyle, canvasSize } = params;
+    if (!beat.image || beat.image.type !== imageType)
+        return;
+    const slide = beat.image.slide;
+    const markdown = `# ${slide.title}\n` + slide.bullets.map((text) => `- ${text}`).join("\n");
+    await renderMarkdownToImage(markdown, textSlideStyle, imagePath, canvasSize.width, canvasSize.height);
+    return imagePath;
+};
+export const process = processTextSlide;

package/lib/utils/image_plugins/type_guards.d.ts

@@ -0,0 +1,6 @@
+import { MulmoTextSlideMedia, MulmoMarkdownMedia, MulmoImageMedia, MulmoChartMedia, MulmoMermaidMedia } from "../../types/index.js";
+export declare const isMulmoImageTextSlide: (value: unknown) => value is MulmoTextSlideMedia;
+export declare const isMulmoImageMarkdown: (value: unknown) => value is MulmoMarkdownMedia;
+export declare const isMulmoImageImage: (value: unknown) => value is MulmoImageMedia;
+export declare const isMulmoImageChart: (value: unknown) => value is MulmoChartMedia;
+export declare const isMulmoImageMermaild: (value: unknown) => value is MulmoMermaidMedia;

package/lib/utils/image_plugins/type_guards.js

@@ -0,0 +1,21 @@
+import { mulmoTextSlideMediaSchema, mulmoMarkdownMediaSchema, mulmoImageMediaSchema, mulmoChartMediaSchema, mulmoMermaidMediaSchema, } from "../../types/index.js";
+export const isMulmoImageTextSlide = (value) => {
+    const result = mulmoTextSlideMediaSchema.safeParse(value);
+    return result.success;
+};
+export const isMulmoImageMarkdown = (value) => {
+    const result = mulmoMarkdownMediaSchema.safeParse(value);
+    return result.success;
+};
+export const isMulmoImageImage = (value) => {
+    const result = mulmoImageMediaSchema.safeParse(value);
+    return result.success;
+};
+export const isMulmoImageChart = (value) => {
+    const result = mulmoChartMediaSchema.safeParse(value);
+    return result.success;
+};
+export const isMulmoImageMermaild = (value) => {
+    const result = mulmoMermaidMediaSchema.safeParse(value);
+    return result.success;
+};

package/lib/utils/markdown.js

@@ -1,9 +1,12 @@
 import { GraphAILogger } from "graphai";
 import { marked } from "marked";
 import puppeteer from "puppeteer";
+const isCI = process.env.CI === "true";
 export const renderHTMLToImage = async (html, outputPath, width, height) => {
     // Use Puppeteer to render HTML to an image
-    const browser = await puppeteer.launch();
+    const browser = await puppeteer.launch({
+        args: isCI ? ["--no-sandbox"] : [],
+    });
     const page = await browser.newPage();
     // Set the page content to the HTML generated from the Markdown
     await page.setContent(html);

package/lib/utils/pdf.d.ts

@@ -0,0 +1,8 @@
+import { PDFFont } from "pdf-lib";
+export declare const fontSize = 12;
+export declare const textMargin = 6;
+export declare const drawSize: (fitWidth: boolean, expectWidth: number, expectHeight: number, origWidth: number, origHeight: number) => {
+    drawWidth: number;
+    drawHeight: number;
+};
+export declare const wrapText: (text: string, font: PDFFont, fontSize: number, maxWidth: number) => string[];

package/lib/utils/pdf.js

@@ -0,0 +1,75 @@
+export const fontSize = 12;
+export const textMargin = 6;
+export const drawSize = (fitWidth, expectWidth, expectHeight, origWidth, origHeight) => {
+    if (fitWidth) {
+        const drawWidth = expectWidth;
+        const scale = drawWidth / origWidth;
+        const drawHeight = origHeight * scale;
+        return {
+            drawWidth,
+            drawHeight,
+        };
+    }
+    const drawHeight = expectHeight;
+    const scale = drawHeight / origHeight;
+    const drawWidth = origWidth * scale;
+    return {
+        drawWidth,
+        drawHeight,
+    };
+};
+const isFullwidth = (char) => {
+    const code = char.charCodeAt(0);
+    return ((code >= 0x3000 && code <= 0x9fff) || // CJK, punctuation, kana
+        (code >= 0xff00 && code <= 0xffef) // Fullwidth ASCII
+    );
+};
+export const wrapText = (text, font, fontSize, maxWidth) => {
+    const lines = [];
+    for (const rawLine of text.split("\n")) {
+        let line = "";
+        let buffer = "";
+        for (let i = 0; i < rawLine.length; i++) {
+            const char = rawLine[i];
+            buffer += char;
+            const width = font.widthOfTextAtSize(line + buffer, fontSize);
+            const nextChar = rawLine[i + 1];
+            const currentIsFull = isFullwidth(char);
+            const nextIsFull = nextChar && isFullwidth(nextChar);
+            const isBreakable = currentIsFull || (!currentIsFull && (char === " " || nextChar === " " || nextIsFull));
+            if (width > maxWidth && buffer) {
+                lines.push(line);
+                line = "";
+                buffer = char;
+            }
+            if (isBreakable || i === rawLine.length - 1) {
+                line += buffer;
+                buffer = "";
+            }
+        }
+        if (line)
+            lines.push(line);
+    }
+    return lines;
+};
+/*
+export const wrapText = (text: string, font: PDFFont, fontSize: number, maxWidth: number) => {
+  const words = text.split(" ");
+  const lines = [];
+  let currentLine = "";
+
+  for (const word of words) {
+    const nextLine = currentLine ? `${currentLine} ${word}` : word;
+    // console.log(nextLine);
+    const width = font.widthOfTextAtSize(nextLine ?? "", fontSize);
+    if (width <= maxWidth) {
+      currentLine = nextLine;
+    } else {
+      lines.push(currentLine);
+      currentLine = word;
+    }
+  }
+  if (currentLine) lines.push(currentLine);
+  return lines;
+};
+*/