@sillsdev/docu-notion 0.11.1

package/dist/config/configuration.js

@@ -0,0 +1,86 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfigAsync = void 0;
+const Cosmic = __importStar(require("cosmiconfig"));
+const default_docunotion_config_1 = __importDefault(require("./default.docunotion.config"));
+const log_1 = require("../log");
+const cosmiconfig_typescript_loader_1 = require("cosmiconfig-typescript-loader");
+const process_1 = require("process");
+// read the plugins from the config file
+// and add them to the map
+function loadConfigAsync() {
+    var _a, _b, _c, _d, _e;
+    return __awaiter(this, void 0, void 0, function* () {
+        let config = default_docunotion_config_1.default;
+        try {
+            const cosmic = Cosmic.cosmiconfig("docu-notion", {
+                loaders: {
+                    ".ts": (0, cosmiconfig_typescript_loader_1.TypeScriptLoader)(),
+                },
+                searchPlaces: [`docu-notion.config.ts`],
+            });
+            const found = yield cosmic.search();
+            if (found) {
+                (0, log_1.verbose)(`Loading config from ${found.filepath}`);
+            }
+            else {
+                (0, log_1.verbose)(`Did not find configuration file, using defaults.`);
+            }
+            const pluginsWithInitializers = (_b = (_a = found === null || found === void 0 ? void 0 : found.config) === null || _a === void 0 ? void 0 : _a.plugins) === null || _b === void 0 ? void 0 : _b.filter((p) => p.init !== undefined);
+            const initializers = pluginsWithInitializers === null || pluginsWithInitializers === void 0 ? void 0 : pluginsWithInitializers.map((p) => () => p.init(p));
+            yield Promise.all(initializers || []);
+            (_d = (_c = found === null || found === void 0 ? void 0 : found.config) === null || _c === void 0 ? void 0 : _c.plugins) === null || _d === void 0 ? void 0 : _d.forEach((plugin) => __awaiter(this, void 0, void 0, function* () {
+                if (plugin.init !== undefined) {
+                    (0, log_1.verbose)(`Initializing plugin ${plugin.name}...`);
+                    yield plugin.init(plugin);
+                }
+            }));
+            // for now, all we have is plugins
+            config = {
+                plugins: default_docunotion_config_1.default.plugins.concat(((_e = found === null || found === void 0 ? void 0 : found.config) === null || _e === void 0 ? void 0 : _e.plugins) || []),
+            };
+        }
+        catch (e) {
+            (0, log_1.error)(e.message);
+            (0, process_1.exit)(1);
+        }
+        (0, log_1.verbose)(`Active plugins: [${config.plugins.map(p => p.name).join(", ")}]`);
+        return config;
+    });
+}
+exports.loadConfigAsync = loadConfigAsync;

package/dist/config/default.docunotion.config.d.ts

@@ -0,0 +1,3 @@
+import { IDocuNotionConfig } from "./configuration";
+declare const defaultConfig: IDocuNotionConfig;
+export default defaultConfig;

package/dist/config/default.docunotion.config.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const embedTweaks_1 = require("../plugins/embedTweaks");
+const images_1 = require("../images");
+const internalLinks_1 = require("../plugins/internalLinks");
+const CalloutTransformer_1 = require("../plugins/CalloutTransformer");
+const ColumnListTransformer_1 = require("../plugins/ColumnListTransformer");
+const ColumnTransformer_1 = require("../plugins/ColumnTransformer");
+const EscapeHtmlBlockModifier_1 = require("../plugins/EscapeHtmlBlockModifier");
+const HeadingTransformer_1 = require("../plugins/HeadingTransformer");
+const NumberedListTransformer_1 = require("../plugins/NumberedListTransformer");
+const TableTransformer_1 = require("../plugins/TableTransformer");
+const externalLinks_1 = require("../plugins/externalLinks");
+const defaultConfig = {
+    plugins: [
+        // Notion "Block" JSON modifiers
+        EscapeHtmlBlockModifier_1.standardEscapeHtmlBlockModifier,
+        HeadingTransformer_1.standardHeadingTransformer,
+        // Notion to Markdown transformers. Most things get transformed correctly by the notion-to-markdown library,
+        // but some things need special handling.
+        ColumnTransformer_1.standardColumnTransformer,
+        ColumnListTransformer_1.standardColumnListTransformer,
+        images_1.standardImageTransformer,
+        CalloutTransformer_1.standardCalloutTransformer,
+        TableTransformer_1.standardTableTransformer,
+        NumberedListTransformer_1.standardNumberedListTransformer,
+        // Link modifiers, which are special because they can read metadata from all the pages in order to figure out the correct url
+        internalLinks_1.standardInternalLinkConversion,
+        externalLinks_1.standardExternalLinkConversion,
+        // Regexps plus javascript `import`s that operate on the Markdown output
+        embedTweaks_1.imgurGifEmbed,
+        embedTweaks_1.gifEmbed,
+        embedTweaks_1.youtubeEmbed,
+        embedTweaks_1.vimeoEmbed,
+    ],
+};
+exports.default = defaultConfig;

package/dist/images.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { FileTypeResult } from "file-type";
+import { ListBlockChildrenResponseResult } from "notion-to-md/build/types";
+import { IPlugin } from "./plugins/pluginTypes";
+export type ImageSet = {
+    primaryUrl: string;
+    caption?: string;
+    localizedUrls: Array<{
+        iso632Code: string;
+        url: string;
+    }>;
+    pathToParentDocument?: string;
+    relativePathToParentDocument?: string;
+    primaryBuffer?: Buffer;
+    fileType?: FileTypeResult;
+    primaryFileOutputPath?: string;
+    outputFileName?: string;
+    filePathToUseInMarkdown?: string;
+};
+export declare function initImageHandling(prefix: string, outputPath: string, incomingLocales: string[]): Promise<void>;
+export declare const standardImageTransformer: IPlugin;
+export declare function markdownToMDImageTransformer(block: ListBlockChildrenResponseResult, fullPathToDirectoryContainingMarkdown: string, relativePathToThisPage: string): Promise<string>;
+export declare function parseImageBlock(image: any): ImageSet;
+export declare function cleanupOldImages(): Promise<void>;

package/dist/images.js

@@ -0,0 +1,230 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupOldImages = exports.parseImageBlock = exports.markdownToMDImageTransformer = exports.standardImageTransformer = exports.initImageHandling = void 0;
+const fs = __importStar(require("fs-extra"));
+const file_type_1 = __importDefault(require("file-type"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const Path = __importStar(require("path"));
+const MakeImagePersistencePlan_1 = require("./MakeImagePersistencePlan");
+const log_1 = require("./log");
+// We several things here:
+// 1) copy images locally instead of leaving them in Notion
+// 2) change the links to point here
+// 3) read the caption and if there are localized images, get those too
+// 4) prepare for localized documents, which need a copy of every image
+let existingImagesNotSeenYetInPull = [];
+let imageOutputPath = ""; // default to putting in the same directory as the document referring to it.
+let imagePrefix = ""; // default to "./"
+let locales;
+function initImageHandling(prefix, outputPath, incomingLocales) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // If they gave us a trailing slash, remove it because we add it back later.
+        // Note that it's up to the caller to have a *leading* slash or not.
+        imagePrefix = prefix.replace(/\/$/, "");
+        imageOutputPath = outputPath;
+        locales = incomingLocales;
+        // Currently we don't delete the image directory, because if an image
+        // changes, it gets a new id. This way can then prevent downloading
+        // and image after the 1st time. The downside is currently we don't
+        // have the smarts to remove unused images.
+        if (imageOutputPath) {
+            yield fs.mkdir(imageOutputPath, { recursive: true });
+        }
+    });
+}
+exports.initImageHandling = initImageHandling;
+exports.standardImageTransformer = {
+    name: "DownloadImagesToRepo",
+    notionToMarkdownTransforms: [
+        {
+            type: "image",
+            // we have to set this one up for each page because we need to
+            // give it two extra parameters that are context for each page
+            getStringFromBlock: (context, block) => markdownToMDImageTransformer(block, context.directoryContainingMarkdown, context.relativeFilePathToFolderContainingPage),
+        },
+    ],
+};
+// This is a "custom transformer" function passed to notion-to-markdown
+// eslint-disable-next-line @typescript-eslint/require-await
+function markdownToMDImageTransformer(block, fullPathToDirectoryContainingMarkdown, relativePathToThisPage) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const image = block.image;
+        yield processImageBlock(image, fullPathToDirectoryContainingMarkdown, relativePathToThisPage);
+        // just concatenate the caption text parts together
+        const altText = image.caption
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            .map((item) => item.plain_text)
+            .join("");
+        const href = image.type === "external" ? image.external.url : image.file.url;
+        return `![${altText}](${href})`;
+    });
+}
+exports.markdownToMDImageTransformer = markdownToMDImageTransformer;
+function processImageBlock(imageBlock, pathToParentDocument, relativePathToThisPage) {
+    return __awaiter(this, void 0, void 0, function* () {
+        (0, log_1.logDebug)("processImageBlock", JSON.stringify(imageBlock));
+        const imageSet = parseImageBlock(imageBlock);
+        imageSet.pathToParentDocument = pathToParentDocument;
+        imageSet.relativePathToParentDocument = relativePathToThisPage;
+        // enhance: it would much better if we could split the changes to markdown separately from actual reading/writing,
+        // so that this wasn't part of the markdown-creation loop. It's already almost there; we just need to
+        // save the imageSets somewhere and then do the actual reading/writing later.
+        yield readPrimaryImage(imageSet);
+        (0, MakeImagePersistencePlan_1.makeImagePersistencePlan)(imageSet, imageOutputPath, imagePrefix);
+        yield saveImage(imageSet);
+        // change the src to point to our copy of the image
+        if ("file" in imageBlock) {
+            imageBlock.file.url = imageSet.filePathToUseInMarkdown;
+        }
+        else {
+            imageBlock.external.url = imageSet.filePathToUseInMarkdown;
+        }
+        // put back the simplified caption, stripped of the meta information
+        if (imageSet.caption) {
+            imageBlock.caption = [
+                {
+                    type: "text",
+                    text: { content: imageSet.caption, link: null },
+                    plain_text: imageSet.caption,
+                },
+            ];
+        }
+        else {
+            imageBlock.caption = [];
+        }
+    });
+}
+function readPrimaryImage(imageSet) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield (0, node_fetch_1.default)(imageSet.primaryUrl);
+        const arrayBuffer = yield response.arrayBuffer();
+        imageSet.primaryBuffer = Buffer.from(arrayBuffer);
+        imageSet.fileType = yield file_type_1.default.fromBuffer(imageSet.primaryBuffer);
+    });
+}
+function saveImage(imageSet) {
+    return __awaiter(this, void 0, void 0, function* () {
+        writeImageIfNew(imageSet.primaryFileOutputPath, imageSet.primaryBuffer);
+        for (const localizedImage of imageSet.localizedUrls) {
+            let buffer = imageSet.primaryBuffer;
+            // if we have a urls for the localized screenshot, download it
+            if ((localizedImage === null || localizedImage === void 0 ? void 0 : localizedImage.url.length) > 0) {
+                (0, log_1.verbose)(`Retrieving ${localizedImage.iso632Code} version...`);
+                const response = yield (0, node_fetch_1.default)(localizedImage.url);
+                const arrayBuffer = yield response.arrayBuffer();
+                buffer = Buffer.from(arrayBuffer);
+            }
+            else {
+                (0, log_1.verbose)(`No localized image specified for ${localizedImage.iso632Code}, will use primary image.`);
+                // otherwise, we're going to fall back to outputting the primary image here
+            }
+            const directory = `./i18n/${localizedImage.iso632Code}/docusaurus-plugin-content-docs/current/${imageSet.relativePathToParentDocument}`;
+            writeImageIfNew((directory + "/" + imageSet.outputFileName).replaceAll("//", "/"), buffer);
+        }
+    });
+}
+function writeImageIfNew(path, buffer) {
+    imageWasSeen(path);
+    // Note: it's tempting to not spend time writing this out if we already have
+    // it from a previous run. But we don't really know it's the same. A) it
+    // could just have the same name, B) it could have been previously
+    // unlocalized and thus filled with a copy of the primary language image
+    // while and now is localized.
+    if (fs.pathExistsSync(path)) {
+        (0, log_1.verbose)("Replacing image " + path);
+    }
+    else {
+        (0, log_1.verbose)("Adding image " + path);
+        fs.mkdirsSync(Path.dirname(path));
+    }
+    fs.createWriteStream(path).write(buffer); // async but we're not waiting
+}
+function parseImageBlock(image) {
+    var _a;
+    if (!locales)
+        throw Error("Did you call initImageHandling()?");
+    const imageSet = {
+        primaryUrl: "",
+        caption: "",
+        localizedUrls: locales.map(l => ({ iso632Code: l, url: "" })),
+    };
+    if ("file" in image) {
+        imageSet.primaryUrl = image.file.url; // image saved on notion (actually AWS)
+    }
+    else {
+        imageSet.primaryUrl = image.external.url; // image still pointing somewhere else. I've see this happen when copying a Google Doc into Notion. Notion kep pointing at the google doc.
+    }
+    const mergedCaption = image.caption
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        .map((c) => c.plain_text)
+        .join("");
+    const lines = mergedCaption.split("\n");
+    // Example:
+    // Caption before images.\nfr https://i.imgur.com/pYmE7OJ.png\nES  https://i.imgur.com/8paSZ0i.png\nCaption after images
+    lines.forEach(l => {
+        const match = /\s*(..)\s*(https:\/\/.*)/.exec(l);
+        if (match) {
+            imageSet.localizedUrls.push({
+                iso632Code: match[1].toLowerCase(),
+                url: match[2],
+            });
+        }
+        else {
+            // NB: carriage returns seem to mess up the markdown, so should be removed
+            imageSet.caption += l + " ";
+        }
+    });
+    // NB: currently notion-md puts the caption in Alt, which noone sees (unless the image isn't found)
+    // We could inject a custom element handler to emit a <figure> in order to show the caption.
+    imageSet.caption = (_a = imageSet.caption) === null || _a === void 0 ? void 0 : _a.trim();
+    //console.log(JSON.stringify(imageSet, null, 2));
+    return imageSet;
+}
+exports.parseImageBlock = parseImageBlock;
+function imageWasSeen(path) {
+    existingImagesNotSeenYetInPull = existingImagesNotSeenYetInPull.filter(p => p !== path);
+}
+function cleanupOldImages() {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const p of existingImagesNotSeenYetInPull) {
+            (0, log_1.verbose)(`Removing old image: ${p}`);
+            yield fs.rm(p);
+        }
+    });
+}
+exports.cleanupOldImages = cleanupOldImages;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+export * as Log from "./log";
+export * from "./types";
+export * from "./config/configuration";
+export * from "./plugins/pluginTypes";
+import type { IDocuNotionConfig } from "./config/configuration";
+export type { IDocuNotionConfig };

package/dist/index.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = void 0;
+const run_1 = require("./run");
+(0, run_1.run)();
+// for plugins to import
+exports.Log = __importStar(require("./log"));
+__exportStar(require("./types"), exports);
+__exportStar(require("./config/configuration"), exports);
+__exportStar(require("./plugins/pluginTypes"), exports);

package/dist/log.d.ts

@@ -0,0 +1,11 @@
+type levels = "info" | "verbose" | "debug";
+export declare function setLogLevel(l: levels): void;
+export declare function error(s: string): void;
+export declare function warning(s: string): void;
+export declare function info(s: string): void;
+export declare function group(s: string): void;
+export declare function endGroup(): void;
+export declare function verbose(s: string): void;
+export declare function logDebugFn(label: string, runIfLoggingDebug: () => string): void;
+export declare function logDebug(label: string, info: string): void;
+export {};

package/dist/log.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logDebug = exports.logDebugFn = exports.verbose = exports.endGroup = exports.group = exports.info = exports.warning = exports.error = exports.setLogLevel = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+chalk_1.default;
+let logLevel;
+function setLogLevel(l) {
+    logLevel = l;
+}
+exports.setLogLevel = setLogLevel;
+function error(s) {
+    console.error(chalk_1.default.red(wrapForCI(s, "error")));
+}
+exports.error = error;
+function warning(s) {
+    console.log(chalk_1.default.hex("#FFA500")(wrapForCI(s, "warning")));
+}
+exports.warning = warning;
+function info(s) {
+    console.log(s);
+}
+exports.info = info;
+// make sure to call endGroup(), eventually, after calling this
+function group(s) {
+    console.log(chalk_1.default.blue(wrapForCI(s, "group")));
+}
+exports.group = group;
+// github actions needs an ::endgroup:: to end a group
+function endGroup() {
+    console.log(wrapForCI("", "endgroup"));
+}
+exports.endGroup = endGroup;
+function verbose(s) {
+    if (logLevel === "verbose" || logLevel === "debug")
+        console.log(chalk_1.default.green(s));
+}
+exports.verbose = verbose;
+// use this one if the debug info would take time to construct,
+// so you want to skip doing it if not in debug mode
+function logDebugFn(label, runIfLoggingDebug) {
+    if (logLevel === "debug") {
+        logDebug(label, runIfLoggingDebug());
+    }
+}
+exports.logDebugFn = logDebugFn;
+function logDebug(label, info) {
+    if (logLevel === "debug") {
+        console.log(chalk_1.default.dim(wrapForCI(`[${label}]`, "debug")));
+        console.log(chalk_1.default.dim(wrapForCI(info, "debug")));
+    }
+}
+exports.logDebug = logDebug;
+function wrapForCI(s, githubActionsPrefix) {
+    // for now, we only know about github actions, but submit a PR if you want to add more
+    return process.env["GITHUB_ACTIONS"] === "true"
+        ? `::${githubActionsPrefix}::${s}`
+        : s;
+}

package/dist/makeImagePersistencePlan.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/makeImagePersistencePlan.spec.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const MakeImagePersistencePlan_1 = require("./MakeImagePersistencePlan");
+test("primary file with explicit file output path and prefix", () => {
+    const imageSet = {
+        primaryUrl: "https://s3.us-west-2.amazonaws.com/primaryImage?Blah=foo",
+        localizedUrls: [],
+        pathToParentDocument: "/pathToParentSomewhere/",
+        fileType: { ext: "png", mime: "image/png" },
+    };
+    (0, MakeImagePersistencePlan_1.makeImagePersistencePlan)(imageSet, "./static/notion_imgs", "/notion_imgs");
+    expect(imageSet.outputFileName).toBe("463556435.png");
+    expect(imageSet.primaryFileOutputPath).toBe("static/notion_imgs/463556435.png");
+    expect(imageSet.filePathToUseInMarkdown).toBe("/notion_imgs/463556435.png");
+});
+test("primary file with defaults for image output path and prefix", () => {
+    const imageSet = {
+        primaryUrl: "https://s3.us-west-2.amazonaws.com/primaryImage?Blah=foo",
+        localizedUrls: [],
+        pathToParentDocument: "/pathToParentSomewhere/",
+        fileType: { ext: "png", mime: "image/png" },
+    };
+    (0, MakeImagePersistencePlan_1.makeImagePersistencePlan)(imageSet, "", "");
+    expect(imageSet.outputFileName).toBe("463556435.png");
+    // the default behavior is to put the image next to the markdown file
+    expect(imageSet.primaryFileOutputPath).toBe("/pathToParentSomewhere/463556435.png");
+    expect(imageSet.filePathToUseInMarkdown).toBe("./463556435.png");
+});
+// In order to make image fallback work with other languages, we have to have
+// a file for each image, in each Docusaurus language directory. This is true
+// whether we have a localized version of the image or not.
+// The imageSet is initially populated with placeholders for each language.
+// This test ensures that these placeholders are replaced with actual urls
+// when localized versions of the image are listed.
+// TODO write this test

package/dist/notion-styles.css

@@ -0,0 +1,58 @@
+/* Note, I haven't figure out how a Docusaurus app can actually include this, yet.
+  So currently this has to be duplicated by the client.
+*/
+
+/* Copied from
+    https://github1s.com/NotionX/react-notion-x/blob/master/packages/react-notion-x/src/styles.css#L934
+    and
+    https://github1s.com/NotionX/react-notion-x/blob/master/packages/react-notion-x/src/styles.css#L1063
+*/
+.notion-column {
+  display: flex;
+  flex-direction: column;
+  padding-top: 12px;
+  padding-bottom: 12px;
+}
+
+.notion-column > *:first-child {
+  margin-top: 0;
+  margin-left: 0;
+  margin-right: 0;
+}
+
+.notion-column > *:last-child {
+  margin-left: 0;
+  margin-right: 0;
+  margin-bottom: 0;
+}
+
+.notion-row {
+  display: flex;
+  overflow: hidden;
+  width: 100%;
+  max-width: 100%;
+}
+
+@media (max-width: 640px) {
+  .notion-row {
+    flex-direction: column;
+  }
+
+  .notion-row .notion-column {
+    width: 100% !important;
+  }
+
+  .notion-row .notion-spacer {
+    display: none;
+  }
+}
+
+.notion-spacer {
+  /* This matches the value in ColumnTransformer.ts */
+  width: calc(min(32px, 4vw));
+}
+
+.notion-spacer:last-child {
+  display: none;
+}
+/* End copied from NotionX */

package/dist/plugins/CalloutTransformer.d.ts

@@ -0,0 +1,24 @@
+import { IPlugin } from "./pluginTypes";
+type TextRequest = string;
+type Annotations = {
+    bold: boolean;
+    italic: boolean;
+    strikethrough: boolean;
+    underline: boolean;
+    code: boolean;
+    color: "default" | "gray" | "brown" | "orange" | "yellow" | "green" | "blue" | "purple" | "pink" | "red" | "gray_background" | "brown_background" | "orange_background" | "yellow_background" | "green_background" | "blue_background" | "purple_background" | "pink_background" | "red_background";
+};
+export type Text = {
+    type: "text";
+    text: {
+        content: string;
+        link: {
+            url: TextRequest;
+        } | null;
+    };
+    annotations: Annotations;
+    plain_text: string;
+    href: string | null;
+};
+export declare const standardCalloutTransformer: IPlugin;
+export {};