@deepnote/convert 2.2.0 → 2.3.0

package/README.md

@@ -192,14 +192,14 @@ await convertMarimoFilesToDeepnoteFile(["notebook.py"], {
 
 ```typescript
 import {
-  convertDeepnoteFileToJupyter,
+  convertDeepnoteFileToJupyterFiles,
   convertDeepnoteFileToQuartoFiles,
   convertDeepnoteFileToPercentFiles,
   convertDeepnoteFileToMarimoFiles,
 } from "@deepnote/convert";
 
 // To Jupyter
-await convertDeepnoteFileToJupyter("project.deepnote", {
+await convertDeepnoteFileToJupyterFiles("project.deepnote", {
   outputDir: "./jupyter-notebooks",
 });
 

package/dist/bin.cjs

@@ -1,19 +1,23 @@
 #!/usr/bin/env node
-const require_src = require('./src-DHLflV_K.cjs');
+const require_src = require('./src-CrnuwKOU.cjs');
 let cleye = require("cleye");
 cleye = require_src.__toESM(cleye);
 let node_fs_promises = require("node:fs/promises");
 node_fs_promises = require_src.__toESM(node_fs_promises);
 let node_path = require("node:path");
 node_path = require_src.__toESM(node_path);
+let __deepnote_blocks = require("@deepnote/blocks");
+__deepnote_blocks = require_src.__toESM(__deepnote_blocks);
 let chalk = require("chalk");
 chalk = require_src.__toESM(chalk);
 let ora = require("ora");
 ora = require_src.__toESM(ora);
+let yaml = require("yaml");
+yaml = require_src.__toESM(yaml);
 
 //#region src/cli.ts
 async function convert(options) {
-	const { inputPath, projectName: customProjectName, outputPath: customOutputPath, cwd = process.cwd(), outputFormat = "jupyter" } = options;
+	const { inputPath, projectName: customProjectName, outputPath: customOutputPath, cwd = process.cwd(), outputFormat = "jupyter", singleFile = false } = options;
 	const resolveProjectName = (possibleName) => {
 		if (customProjectName) return customProjectName;
 		if (possibleName) return possibleName;
@@ -57,25 +61,57 @@ async function convert(options) {
 		}
 		const marimoFiles = results.filter((r) => r.type === "marimo").map((r) => r.file);
 		const percentFiles = results.filter((r) => r.type === "percent").map((r) => r.file);
-		if (ipynbFiles.length > 0) return convertDirectory(absolutePath, ipynbFiles, "jupyter", resolveProjectName, resolveOutputPath);
-		if (quartoFiles.length > 0) return convertDirectory(absolutePath, quartoFiles, "quarto", resolveProjectName, resolveOutputPath);
-		if (marimoFiles.length > 0) return convertDirectory(absolutePath, marimoFiles, "marimo", resolveProjectName, resolveOutputPath);
-		if (percentFiles.length > 0) return convertDirectory(absolutePath, percentFiles, "percent", resolveProjectName, resolveOutputPath);
+		const directoryOptions = {
+			resolveProjectName,
+			resolveOutputPath,
+			singleFile
+		};
+		if (ipynbFiles.length > 0) return convertDirectory({
+			dirPath: absolutePath,
+			files: ipynbFiles,
+			format: "jupyter",
+			...directoryOptions
+		});
+		if (quartoFiles.length > 0) return convertDirectory({
+			dirPath: absolutePath,
+			files: quartoFiles,
+			format: "quarto",
+			...directoryOptions
+		});
+		if (marimoFiles.length > 0) return convertDirectory({
+			dirPath: absolutePath,
+			files: marimoFiles,
+			format: "marimo",
+			...directoryOptions
+		});
+		if (percentFiles.length > 0) return convertDirectory({
+			dirPath: absolutePath,
+			files: percentFiles,
+			format: "percent",
+			...directoryOptions
+		});
 		throw new Error("No supported notebook files found in the specified directory (.ipynb, .qmd, .py)");
 	}
 	const ext = (0, node_path.extname)(absolutePath).toLowerCase();
-	if (ext === ".ipynb") return convertJupyterToDeepnote(absolutePath, resolveProjectName, resolveOutputPath);
-	if (ext === ".qmd") return convertQuartoToDeepnote(absolutePath, resolveProjectName, resolveOutputPath);
+	const fileOptions = {
+		absolutePath,
+		resolveProjectName,
+		resolveOutputPath,
+		singleFile
+	};
+	if (ext === ".ipynb") return convertJupyterToDeepnote(fileOptions);
+	if (ext === ".qmd") return convertQuartoToDeepnote(fileOptions);
 	if (ext === ".py") {
 		const content = await node_fs_promises.default.readFile(absolutePath, "utf-8");
-		if (require_src.isMarimoContent(content)) return convertMarimoToDeepnote(absolutePath, resolveProjectName, resolveOutputPath);
-		if (require_src.isPercentContent(content)) return convertPercentToDeepnote(absolutePath, resolveProjectName, resolveOutputPath);
+		if (require_src.isMarimoContent(content)) return convertMarimoToDeepnote(fileOptions);
+		if (require_src.isPercentContent(content)) return convertPercentToDeepnote(fileOptions);
 		throw new Error("Unsupported Python file format. File must be a percent format (# %% markers) or Marimo notebook (@app.cell decorators).");
 	}
 	if (ext === ".deepnote") return convertDeepnoteToFormat(absolutePath, outputFormat, customOutputPath, cwd);
 	throw new Error("Unsupported file type. Please provide a .ipynb, .qmd, .py (percent/marimo), or .deepnote file.");
 }
-async function convertDirectory(dirPath, files, format, resolveProjectName, resolveOutputPath) {
+async function convertDirectory(options) {
+	const { dirPath, files, format, resolveProjectName, resolveOutputPath, singleFile } = options;
 	const spinner = (0, ora.default)(`Converting ${{
 		jupyter: "Jupyter Notebooks",
 		quarto: "Quarto documents",
@@ -87,67 +123,83 @@ async function convertDirectory(dirPath, files, format, resolveProjectName, reso
 		const projectName = resolveProjectName(filenameWithoutExtension);
 		const outputPath = await resolveOutputPath(`${filenameWithoutExtension}.deepnote`);
 		const inputFilePaths = files.map((file) => (0, node_path.resolve)(dirPath, file));
+		let deepnoteFile;
 		switch (format) {
 			case "jupyter":
-				await require_src.convertIpynbFilesToDeepnoteFile(inputFilePaths, {
-					projectName,
-					outputPath
-				});
+				deepnoteFile = await require_src.readAndConvertIpynbFiles(inputFilePaths, { projectName });
 				break;
 			case "quarto":
-				await require_src.convertQuartoFilesToDeepnoteFile(inputFilePaths, {
-					projectName,
-					outputPath
-				});
+				deepnoteFile = await require_src.readAndConvertQuartoFiles(inputFilePaths, { projectName });
 				break;
 			case "percent":
-				await require_src.convertPercentFilesToDeepnoteFile(inputFilePaths, {
-					projectName,
-					outputPath
-				});
+				deepnoteFile = await require_src.readAndConvertPercentFiles(inputFilePaths, { projectName });
 				break;
 			case "marimo":
-				await require_src.convertMarimoFilesToDeepnoteFile(inputFilePaths, {
-					projectName,
-					outputPath
-				});
+				deepnoteFile = await require_src.readAndConvertMarimoFiles(inputFilePaths, { projectName });
 				break;
 		}
-		spinner.succeed(`The Deepnote project has been saved to ${chalk.default.bold(outputPath)}`);
+		const { snapshotPath } = await require_src.writeDeepnoteFile({
+			file: deepnoteFile,
+			outputPath,
+			projectName,
+			singleFile
+		});
+		if (snapshotPath) spinner.succeed(`The Deepnote project has been saved to ${chalk.default.bold(outputPath)}\nSnapshot saved to ${chalk.default.bold(snapshotPath)}`);
+		else spinner.succeed(`The Deepnote project has been saved to ${chalk.default.bold(outputPath)}`);
 		return outputPath;
 	} catch (error) {
 		spinner.fail("Conversion failed");
 		throw error;
 	}
 }
-async function convertSingleFileToDeepnote(absolutePath, formatName, converter, resolveProjectName, resolveOutputPath) {
+async function convertSingleFileToDeepnote(options) {
+	const { absolutePath, formatName, converter, resolveProjectName, resolveOutputPath, singleFile } = options;
 	const spinner = (0, ora.default)(`Converting the ${formatName} to a Deepnote project...`).start();
 	try {
 		const filenameWithoutExtension = (0, node_path.basename)(absolutePath, (0, node_path.extname)(absolutePath));
 		const projectName = resolveProjectName(filenameWithoutExtension);
 		const outputPath = await resolveOutputPath(`${filenameWithoutExtension}.deepnote`);
-		await converter([absolutePath], {
+		const { snapshotPath } = await require_src.writeDeepnoteFile({
+			file: await converter([absolutePath], { projectName }),
+			outputPath,
 			projectName,
-			outputPath
+			singleFile
 		});
-		spinner.succeed(`The Deepnote project has been saved to ${chalk.default.bold(outputPath)}`);
+		if (snapshotPath) spinner.succeed(`The Deepnote project has been saved to ${chalk.default.bold(outputPath)}\nSnapshot saved to ${chalk.default.bold(snapshotPath)}`);
+		else spinner.succeed(`The Deepnote project has been saved to ${chalk.default.bold(outputPath)}`);
 		return outputPath;
 	} catch (error) {
 		spinner.fail("Conversion failed");
 		throw error;
 	}
 }
-function convertJupyterToDeepnote(absolutePath, resolveProjectName, resolveOutputPath) {
-	return convertSingleFileToDeepnote(absolutePath, "Jupyter Notebook", require_src.convertIpynbFilesToDeepnoteFile, resolveProjectName, resolveOutputPath);
+function convertJupyterToDeepnote(options) {
+	return convertSingleFileToDeepnote({
+		...options,
+		formatName: "Jupyter Notebook",
+		converter: require_src.readAndConvertIpynbFiles
+	});
 }
-function convertQuartoToDeepnote(absolutePath, resolveProjectName, resolveOutputPath) {
-	return convertSingleFileToDeepnote(absolutePath, "Quarto document", require_src.convertQuartoFilesToDeepnoteFile, resolveProjectName, resolveOutputPath);
+function convertQuartoToDeepnote(options) {
+	return convertSingleFileToDeepnote({
+		...options,
+		formatName: "Quarto document",
+		converter: require_src.readAndConvertQuartoFiles
+	});
 }
-function convertPercentToDeepnote(absolutePath, resolveProjectName, resolveOutputPath) {
-	return convertSingleFileToDeepnote(absolutePath, "percent format notebook", require_src.convertPercentFilesToDeepnoteFile, resolveProjectName, resolveOutputPath);
+function convertPercentToDeepnote(options) {
+	return convertSingleFileToDeepnote({
+		...options,
+		formatName: "percent format notebook",
+		converter: require_src.readAndConvertPercentFiles
+	});
 }
-function convertMarimoToDeepnote(absolutePath, resolveProjectName, resolveOutputPath) {
-	return convertSingleFileToDeepnote(absolutePath, "Marimo notebook", require_src.convertMarimoFilesToDeepnoteFile, resolveProjectName, resolveOutputPath);
+function convertMarimoToDeepnote(options) {
+	return convertSingleFileToDeepnote({
+		...options,
+		formatName: "Marimo notebook",
+		converter: require_src.readAndConvertMarimoFiles
+	});
 }
 async function convertDeepnoteToFormat(absolutePath, outputFormat, customOutputPath, cwd) {
 	const formatNames = {
@@ -158,21 +210,35 @@ async function convertDeepnoteToFormat(absolutePath, outputFormat, customOutputP
 	};
 	const spinner = (0, ora.default)(`Converting Deepnote project to ${formatNames[outputFormat]}...`).start();
 	try {
-		const outputDirName = (0, node_path.basename)(absolutePath, (0, node_path.extname)(absolutePath));
-		const outputDir = customOutputPath ? (0, node_path.resolve)(cwd, customOutputPath) : (0, node_path.resolve)(cwd, outputDirName);
-		switch (outputFormat) {
-			case "jupyter":
-				await require_src.convertDeepnoteFileToJupyterFiles(absolutePath, { outputDir });
-				break;
-			case "percent":
-				await require_src.convertDeepnoteFileToPercentFiles(absolutePath, { outputDir });
-				break;
-			case "quarto":
-				await require_src.convertDeepnoteFileToQuartoFiles(absolutePath, { outputDir });
-				break;
-			case "marimo":
-				await require_src.convertDeepnoteFileToMarimoFiles(absolutePath, { outputDir });
-				break;
+		const filenameWithoutExtension = (0, node_path.basename)(absolutePath, (0, node_path.extname)(absolutePath));
+		const outputDir = customOutputPath ? (0, node_path.resolve)(cwd, customOutputPath) : (0, node_path.resolve)(cwd, filenameWithoutExtension);
+		let deepnoteFile = (0, __deepnote_blocks.deserializeDeepnoteFile)(await node_fs_promises.default.readFile(absolutePath, "utf-8"));
+		const snapshot = await require_src.loadLatestSnapshot(absolutePath, deepnoteFile.project.id);
+		if (snapshot) deepnoteFile = require_src.mergeSnapshotIntoSource(deepnoteFile, snapshot, { skipMismatched: true });
+		const tempDir = await node_fs_promises.default.mkdtemp((0, node_path.resolve)((0, node_path.dirname)(absolutePath), ".deepnote-merge-"));
+		const tempPath = (0, node_path.resolve)(tempDir, `${filenameWithoutExtension}.merged.deepnote`);
+		try {
+			const mergedYaml = (0, yaml.stringify)(deepnoteFile);
+			await node_fs_promises.default.writeFile(tempPath, mergedYaml, "utf-8");
+			switch (outputFormat) {
+				case "jupyter":
+					await require_src.convertDeepnoteFileToJupyterFiles(tempPath, { outputDir });
+					break;
+				case "percent":
+					await require_src.convertDeepnoteFileToPercentFiles(tempPath, { outputDir });
+					break;
+				case "quarto":
+					await require_src.convertDeepnoteFileToQuartoFiles(tempPath, { outputDir });
+					break;
+				case "marimo":
+					await require_src.convertDeepnoteFileToMarimoFiles(tempPath, { outputDir });
+					break;
+			}
+		} finally {
+			await node_fs_promises.default.rm(tempDir, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
 		}
 		spinner.succeed(`${formatNames[outputFormat]} have been saved to ${chalk.default.bold(outputDir)}`);
 		return outputDir;
@@ -201,6 +267,11 @@ async function main() {
 			cwd: {
 				description: "The working directory to resolve paths relative to.",
 				type: String
+			},
+			singleFile: {
+				description: "Output a single file with outputs included (disables snapshot mode).",
+				type: Boolean,
+				default: false
 			}
 		}
 	});
@@ -208,7 +279,8 @@ async function main() {
 		inputPath: argv._.path,
 		projectName: argv.flags.projectName,
 		outputPath: argv.flags.outputPath,
-		cwd: argv.flags.cwd ?? process.cwd()
+		cwd: argv.flags.cwd ?? process.cwd(),
+		singleFile: argv.flags.singleFile
 	});
 }
 if (process.env.NODE_ENV !== "test" && process.env.VITEST !== "true") main().catch((error) => {

package/dist/bin.js

@@ -1,14 +1,16 @@
 #!/usr/bin/env node
-import { N as convertDeepnoteFileToJupyterFiles, O as convertDeepnoteFileToMarimoFiles, _ as isMarimoContent, a as convertPercentFilesToDeepnoteFile, b as convertDeepnoteFileToQuartoFiles, d as convertMarimoFilesToDeepnoteFile, p as convertIpynbFilesToDeepnoteFile, r as convertQuartoFilesToDeepnoteFile, v as isPercentContent, w as convertDeepnoteFileToPercentFiles } from "./src-CWHTtGro.js";
+import { G as convertDeepnoteFileToPercentFiles, I as readAndConvertIpynbFiles, R as isMarimoContent, S as mergeSnapshotIntoSource, T as loadLatestSnapshot, V as convertDeepnoteFileToQuartoFiles, Y as convertDeepnoteFileToMarimoFiles, d as readAndConvertPercentFiles, et as convertDeepnoteFileToJupyterFiles, g as readAndConvertMarimoFiles, o as readAndConvertQuartoFiles, t as writeDeepnoteFile, z as isPercentContent } from "./src-C0XPNDnj.js";
 import { cli } from "cleye";
 import fs from "node:fs/promises";
-import { basename, extname, resolve } from "node:path";
+import { basename, dirname, extname, resolve } from "node:path";
+import { deserializeDeepnoteFile } from "@deepnote/blocks";
 import chalk from "chalk";
 import ora from "ora";
+import { stringify } from "yaml";
 
 //#region src/cli.ts
 async function convert(options) {
-	const { inputPath, projectName: customProjectName, outputPath: customOutputPath, cwd = process.cwd(), outputFormat = "jupyter" } = options;
+	const { inputPath, projectName: customProjectName, outputPath: customOutputPath, cwd = process.cwd(), outputFormat = "jupyter", singleFile = false } = options;
 	const resolveProjectName = (possibleName) => {
 		if (customProjectName) return customProjectName;
 		if (possibleName) return possibleName;
@@ -52,25 +54,57 @@ async function convert(options) {
 		}
 		const marimoFiles = results.filter((r) => r.type === "marimo").map((r) => r.file);
 		const percentFiles = results.filter((r) => r.type === "percent").map((r) => r.file);
-		if (ipynbFiles.length > 0) return convertDirectory(absolutePath, ipynbFiles, "jupyter", resolveProjectName, resolveOutputPath);
-		if (quartoFiles.length > 0) return convertDirectory(absolutePath, quartoFiles, "quarto", resolveProjectName, resolveOutputPath);
-		if (marimoFiles.length > 0) return convertDirectory(absolutePath, marimoFiles, "marimo", resolveProjectName, resolveOutputPath);
-		if (percentFiles.length > 0) return convertDirectory(absolutePath, percentFiles, "percent", resolveProjectName, resolveOutputPath);
+		const directoryOptions = {
+			resolveProjectName,
+			resolveOutputPath,
+			singleFile
+		};
+		if (ipynbFiles.length > 0) return convertDirectory({
+			dirPath: absolutePath,
+			files: ipynbFiles,
+			format: "jupyter",
+			...directoryOptions
+		});
+		if (quartoFiles.length > 0) return convertDirectory({
+			dirPath: absolutePath,
+			files: quartoFiles,
+			format: "quarto",
+			...directoryOptions
+		});
+		if (marimoFiles.length > 0) return convertDirectory({
+			dirPath: absolutePath,
+			files: marimoFiles,
+			format: "marimo",
+			...directoryOptions
+		});
+		if (percentFiles.length > 0) return convertDirectory({
+			dirPath: absolutePath,
+			files: percentFiles,
+			format: "percent",
+			...directoryOptions
+		});
 		throw new Error("No supported notebook files found in the specified directory (.ipynb, .qmd, .py)");
 	}
 	const ext = extname(absolutePath).toLowerCase();
-	if (ext === ".ipynb") return convertJupyterToDeepnote(absolutePath, resolveProjectName, resolveOutputPath);
-	if (ext === ".qmd") return convertQuartoToDeepnote(absolutePath, resolveProjectName, resolveOutputPath);
+	const fileOptions = {
+		absolutePath,
+		resolveProjectName,
+		resolveOutputPath,
+		singleFile
+	};
+	if (ext === ".ipynb") return convertJupyterToDeepnote(fileOptions);
+	if (ext === ".qmd") return convertQuartoToDeepnote(fileOptions);
 	if (ext === ".py") {
 		const content = await fs.readFile(absolutePath, "utf-8");
-		if (isMarimoContent(content)) return convertMarimoToDeepnote(absolutePath, resolveProjectName, resolveOutputPath);
-		if (isPercentContent(content)) return convertPercentToDeepnote(absolutePath, resolveProjectName, resolveOutputPath);
+		if (isMarimoContent(content)) return convertMarimoToDeepnote(fileOptions);
+		if (isPercentContent(content)) return convertPercentToDeepnote(fileOptions);
 		throw new Error("Unsupported Python file format. File must be a percent format (# %% markers) or Marimo notebook (@app.cell decorators).");
 	}
 	if (ext === ".deepnote") return convertDeepnoteToFormat(absolutePath, outputFormat, customOutputPath, cwd);
 	throw new Error("Unsupported file type. Please provide a .ipynb, .qmd, .py (percent/marimo), or .deepnote file.");
 }
-async function convertDirectory(dirPath, files, format, resolveProjectName, resolveOutputPath) {
+async function convertDirectory(options) {
+	const { dirPath, files, format, resolveProjectName, resolveOutputPath, singleFile } = options;
 	const spinner = ora(`Converting ${{
 		jupyter: "Jupyter Notebooks",
 		quarto: "Quarto documents",
@@ -82,67 +116,83 @@ async function convertDirectory(dirPath, files, format, resolveProjectName, reso
 		const projectName = resolveProjectName(filenameWithoutExtension);
 		const outputPath = await resolveOutputPath(`${filenameWithoutExtension}.deepnote`);
 		const inputFilePaths = files.map((file) => resolve(dirPath, file));
+		let deepnoteFile;
 		switch (format) {
 			case "jupyter":
-				await convertIpynbFilesToDeepnoteFile(inputFilePaths, {
-					projectName,
-					outputPath
-				});
+				deepnoteFile = await readAndConvertIpynbFiles(inputFilePaths, { projectName });
 				break;
 			case "quarto":
-				await convertQuartoFilesToDeepnoteFile(inputFilePaths, {
-					projectName,
-					outputPath
-				});
+				deepnoteFile = await readAndConvertQuartoFiles(inputFilePaths, { projectName });
 				break;
 			case "percent":
-				await convertPercentFilesToDeepnoteFile(inputFilePaths, {
-					projectName,
-					outputPath
-				});
+				deepnoteFile = await readAndConvertPercentFiles(inputFilePaths, { projectName });
 				break;
 			case "marimo":
-				await convertMarimoFilesToDeepnoteFile(inputFilePaths, {
-					projectName,
-					outputPath
-				});
+				deepnoteFile = await readAndConvertMarimoFiles(inputFilePaths, { projectName });
 				break;
 		}
-		spinner.succeed(`The Deepnote project has been saved to ${chalk.bold(outputPath)}`);
+		const { snapshotPath } = await writeDeepnoteFile({
+			file: deepnoteFile,
+			outputPath,
+			projectName,
+			singleFile
+		});
+		if (snapshotPath) spinner.succeed(`The Deepnote project has been saved to ${chalk.bold(outputPath)}\nSnapshot saved to ${chalk.bold(snapshotPath)}`);
+		else spinner.succeed(`The Deepnote project has been saved to ${chalk.bold(outputPath)}`);
 		return outputPath;
 	} catch (error) {
 		spinner.fail("Conversion failed");
 		throw error;
 	}
 }
-async function convertSingleFileToDeepnote(absolutePath, formatName, converter, resolveProjectName, resolveOutputPath) {
+async function convertSingleFileToDeepnote(options) {
+	const { absolutePath, formatName, converter, resolveProjectName, resolveOutputPath, singleFile } = options;
 	const spinner = ora(`Converting the ${formatName} to a Deepnote project...`).start();
 	try {
 		const filenameWithoutExtension = basename(absolutePath, extname(absolutePath));
 		const projectName = resolveProjectName(filenameWithoutExtension);
 		const outputPath = await resolveOutputPath(`${filenameWithoutExtension}.deepnote`);
-		await converter([absolutePath], {
+		const { snapshotPath } = await writeDeepnoteFile({
+			file: await converter([absolutePath], { projectName }),
+			outputPath,
 			projectName,
-			outputPath
+			singleFile
 		});
-		spinner.succeed(`The Deepnote project has been saved to ${chalk.bold(outputPath)}`);
+		if (snapshotPath) spinner.succeed(`The Deepnote project has been saved to ${chalk.bold(outputPath)}\nSnapshot saved to ${chalk.bold(snapshotPath)}`);
+		else spinner.succeed(`The Deepnote project has been saved to ${chalk.bold(outputPath)}`);
 		return outputPath;
 	} catch (error) {
 		spinner.fail("Conversion failed");
 		throw error;
 	}
 }
-function convertJupyterToDeepnote(absolutePath, resolveProjectName, resolveOutputPath) {
-	return convertSingleFileToDeepnote(absolutePath, "Jupyter Notebook", convertIpynbFilesToDeepnoteFile, resolveProjectName, resolveOutputPath);
+function convertJupyterToDeepnote(options) {
+	return convertSingleFileToDeepnote({
+		...options,
+		formatName: "Jupyter Notebook",
+		converter: readAndConvertIpynbFiles
+	});
 }
-function convertQuartoToDeepnote(absolutePath, resolveProjectName, resolveOutputPath) {
-	return convertSingleFileToDeepnote(absolutePath, "Quarto document", convertQuartoFilesToDeepnoteFile, resolveProjectName, resolveOutputPath);
+function convertQuartoToDeepnote(options) {
+	return convertSingleFileToDeepnote({
+		...options,
+		formatName: "Quarto document",
+		converter: readAndConvertQuartoFiles
+	});
 }
-function convertPercentToDeepnote(absolutePath, resolveProjectName, resolveOutputPath) {
-	return convertSingleFileToDeepnote(absolutePath, "percent format notebook", convertPercentFilesToDeepnoteFile, resolveProjectName, resolveOutputPath);
+function convertPercentToDeepnote(options) {
+	return convertSingleFileToDeepnote({
+		...options,
+		formatName: "percent format notebook",
+		converter: readAndConvertPercentFiles
+	});
 }
-function convertMarimoToDeepnote(absolutePath, resolveProjectName, resolveOutputPath) {
-	return convertSingleFileToDeepnote(absolutePath, "Marimo notebook", convertMarimoFilesToDeepnoteFile, resolveProjectName, resolveOutputPath);
+function convertMarimoToDeepnote(options) {
+	return convertSingleFileToDeepnote({
+		...options,
+		formatName: "Marimo notebook",
+		converter: readAndConvertMarimoFiles
+	});
 }
 async function convertDeepnoteToFormat(absolutePath, outputFormat, customOutputPath, cwd) {
 	const formatNames = {
@@ -153,21 +203,35 @@ async function convertDeepnoteToFormat(absolutePath, outputFormat, customOutputP
 	};
 	const spinner = ora(`Converting Deepnote project to ${formatNames[outputFormat]}...`).start();
 	try {
-		const outputDirName = basename(absolutePath, extname(absolutePath));
-		const outputDir = customOutputPath ? resolve(cwd, customOutputPath) : resolve(cwd, outputDirName);
-		switch (outputFormat) {
-			case "jupyter":
-				await convertDeepnoteFileToJupyterFiles(absolutePath, { outputDir });
-				break;
-			case "percent":
-				await convertDeepnoteFileToPercentFiles(absolutePath, { outputDir });
-				break;
-			case "quarto":
-				await convertDeepnoteFileToQuartoFiles(absolutePath, { outputDir });
-				break;
-			case "marimo":
-				await convertDeepnoteFileToMarimoFiles(absolutePath, { outputDir });
-				break;
+		const filenameWithoutExtension = basename(absolutePath, extname(absolutePath));
+		const outputDir = customOutputPath ? resolve(cwd, customOutputPath) : resolve(cwd, filenameWithoutExtension);
+		let deepnoteFile = deserializeDeepnoteFile(await fs.readFile(absolutePath, "utf-8"));
+		const snapshot = await loadLatestSnapshot(absolutePath, deepnoteFile.project.id);
+		if (snapshot) deepnoteFile = mergeSnapshotIntoSource(deepnoteFile, snapshot, { skipMismatched: true });
+		const tempDir = await fs.mkdtemp(resolve(dirname(absolutePath), ".deepnote-merge-"));
+		const tempPath = resolve(tempDir, `${filenameWithoutExtension}.merged.deepnote`);
+		try {
+			const mergedYaml = stringify(deepnoteFile);
+			await fs.writeFile(tempPath, mergedYaml, "utf-8");
+			switch (outputFormat) {
+				case "jupyter":
+					await convertDeepnoteFileToJupyterFiles(tempPath, { outputDir });
+					break;
+				case "percent":
+					await convertDeepnoteFileToPercentFiles(tempPath, { outputDir });
+					break;
+				case "quarto":
+					await convertDeepnoteFileToQuartoFiles(tempPath, { outputDir });
+					break;
+				case "marimo":
+					await convertDeepnoteFileToMarimoFiles(tempPath, { outputDir });
+					break;
+			}
+		} finally {
+			await fs.rm(tempDir, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
 		}
 		spinner.succeed(`${formatNames[outputFormat]} have been saved to ${chalk.bold(outputDir)}`);
 		return outputDir;
@@ -196,6 +260,11 @@ async function main() {
 			cwd: {
 				description: "The working directory to resolve paths relative to.",
 				type: String
+			},
+			singleFile: {
+				description: "Output a single file with outputs included (disables snapshot mode).",
+				type: Boolean,
+				default: false
 			}
 		}
 	});
@@ -203,7 +272,8 @@ async function main() {
 		inputPath: argv._.path,
 		projectName: argv.flags.projectName,
 		outputPath: argv.flags.outputPath,
-		cwd: argv.flags.cwd ?? process.cwd()
+		cwd: argv.flags.cwd ?? process.cwd(),
+		singleFile: argv.flags.singleFile
 	});
 }
 if (process.env.NODE_ENV !== "test" && process.env.VITEST !== "true") main().catch((error) => {

package/dist/index.cjs

@@ -1,11 +1,14 @@
-const require_src = require('./src-DHLflV_K.cjs');
+const require_src = require('./src-CrnuwKOU.cjs');
 
+exports.addContentHashes = require_src.addContentHashes;
+exports.computeContentHash = require_src.computeContentHash;
+exports.computeSnapshotHash = require_src.computeSnapshotHash;
 exports.convertBlockToJupyterCell = require_src.convertBlockToJupyterCell;
 exports.convertBlocksToJupyterNotebook = require_src.convertBlocksToJupyterNotebook;
 exports.convertBlocksToMarimoApp = require_src.convertBlocksToMarimoApp;
 exports.convertBlocksToPercentNotebook = require_src.convertBlocksToPercentNotebook;
 exports.convertBlocksToQuartoDocument = require_src.convertBlocksToQuartoDocument;
-exports.convertDeepnoteFileToJupyter = require_src.convertDeepnoteFileToJupyterFiles;
+exports.convertDeepnoteFileToJupyterFiles = require_src.convertDeepnoteFileToJupyterFiles;
 exports.convertDeepnoteFileToMarimoFiles = require_src.convertDeepnoteFileToMarimoFiles;
 exports.convertDeepnoteFileToPercentFiles = require_src.convertDeepnoteFileToPercentFiles;
 exports.convertDeepnoteFileToQuartoFiles = require_src.convertDeepnoteFileToQuartoFiles;
@@ -25,10 +28,28 @@ exports.convertPercentNotebooksToDeepnote = require_src.convertPercentNotebooksT
 exports.convertQuartoDocumentToBlocks = require_src.convertQuartoDocumentToBlocks;
 exports.convertQuartoDocumentsToDeepnote = require_src.convertQuartoDocumentsToDeepnote;
 exports.convertQuartoFilesToDeepnoteFile = require_src.convertQuartoFilesToDeepnoteFile;
+exports.countBlocksWithOutputs = require_src.countBlocksWithOutputs;
 exports.detectFormat = require_src.detectFormat;
+exports.findSnapshotsForProject = require_src.findSnapshotsForProject;
+exports.generateSnapshotFilename = require_src.generateSnapshotFilename;
+exports.getSnapshotDir = require_src.getSnapshotDir;
+exports.hasOutputs = require_src.hasOutputs;
+exports.loadLatestSnapshot = require_src.loadLatestSnapshot;
+exports.loadSnapshotFile = require_src.loadSnapshotFile;
+exports.mergeSnapshotIntoSource = require_src.mergeSnapshotIntoSource;
 exports.parseMarimoFormat = require_src.parseMarimoFormat;
 exports.parsePercentFormat = require_src.parsePercentFormat;
 exports.parseQuartoFormat = require_src.parseQuartoFormat;
+exports.parseSnapshotFilename = require_src.parseSnapshotFilename;
+exports.parseSourceFilePath = require_src.parseSourceFilePath;
+exports.readAndConvertIpynbFiles = require_src.readAndConvertIpynbFiles;
+exports.readAndConvertMarimoFiles = require_src.readAndConvertMarimoFiles;
+exports.readAndConvertPercentFiles = require_src.readAndConvertPercentFiles;
+exports.readAndConvertQuartoFiles = require_src.readAndConvertQuartoFiles;
 exports.serializeMarimoFormat = require_src.serializeMarimoFormat;
 exports.serializePercentFormat = require_src.serializePercentFormat;
-exports.serializeQuartoFormat = require_src.serializeQuartoFormat;
+exports.serializeQuartoFormat = require_src.serializeQuartoFormat;
+exports.slugifyProjectName = require_src.slugifyProjectName;
+exports.snapshotExists = require_src.snapshotExists;
+exports.splitDeepnoteFile = require_src.splitDeepnoteFile;
+exports.writeDeepnoteFile = require_src.writeDeepnoteFile;