@sillsdev/docu-notion 0.17.0-alpha.3 → 1.0.0-alpha.1

package/README.md

@@ -4,6 +4,24 @@ docu-notion lets you use Notion as your editor for [Docusaurus](https://docusaur
 
 Example Site: https://sillsdev.github.io/docu-notion-sample-site/
 
+# Docusaurus 3 Output
+
+docu-notion emits Docusaurus v3-compatible markdown by default.
+
+The default output changed in these ways:
+
+- Heading anchors are emitted with Docusaurus v3's MDX-comment syntax, for example `# Heading {/* #my-explicit-id */}`, instead of Docusaurus v2's `{#...}` syntax.
+- `⚠️` callouts now emit `:::warning[Caution]` instead of the deprecated `:::caution` syntax.
+- Callouts with unrecognized emojis now emit `:::note[emoji]` instead of using the emoji itself as a custom admonition keyword.
+- Named Notion callout icons that are not returned by the API as emoji are ignored and fall back to a plain `:::note` admonition.
+- docu-notion now warns when a generated page contains more than one Markdown H1, and the warning lists the H1 headings it found.
+
+If you need the previous output, pass `--docusaurus-v2`. This restores the legacy heading ID syntax, the `:::caution` output, and the raw-emoji admonition fallback.
+
+If you use `--docusaurus-v2` on Docusaurus v3, keep the `markdown.mdx1Compat.headingIds` and `markdown.mdx1Compat.admonitions` compatibility options enabled. They are on by default in Docusaurus v3, but some sites turn them off during migration.
+
+When upgrading an existing Docusaurus site to v3, it is also worth running `npx docusaurus-mdx-checker` on the site to catch MDX v3 issues in any hand-written docs or custom plugin output.
+
 # Instructions
 
 ## 1. Set up your documentation site
@@ -122,19 +140,20 @@ Usage: `docu-notion -n <token> -r <root> [options]`
 
 Options:
 
-| flag                                  | required? | description                                                                                                                                                                                                        |
-| ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `-n, --notion-token <string>`           | required  | notion api token, which looks like `secret_3bc1b50XFYb15123RHF243x43450XFY33250XFYa343`                                                                                                                            |
-| `-r, --root-page <string>`              | required  | The 31 character ID of the page which is the root of your docs page in notion. The code will look like `9120ec9960244ead80fa2ef4bc1bba25`. This page must have a child page named 'Outline'                        |
-| `-m, --markdown-output-path <string>`   |           | Root of the hierarchy for md files. WARNING: node-pull-mdx will delete files from this directory. Note also that if it finds localized images, it will create an i18n/ directory as a sibling. (default: `./docs`) |
-| `-t, --status-tag <string>`             |           | Database pages without a Notion page property 'status' matching this will be ignored. Use '\*' to ignore status altogether. (default: `Publish`)                                                                   |
-| `--locales <codes>`                     |           | Comma-separated list of iso 639-2 codes, the same list as in docusaurus.config.js, minus the primary (i.e. 'en'). This is needed for image localization. (default: `[]`)                                             |
-| `-l, --log-level <level>`               |           | Log level (choices: `info`, `verbose`, `debug`)                                                                                                                                                                    |
-| `-i, --img-output-path <string>`        |           | Path to directory where images will be stored. If this is not included, images will be placed in the same directory as the document that uses them, which then allows for localization of screenshots.             |
-| `-p, --img-prefix-in-markdown <string>` |           | When referencing an image from markdown, prefix with this path instead of the full img-output-path. Should be used only in conjunction with --img-output-path.                                                     |
-| `--require-slugs`                       |           | If set, docu-notion will fail if any pages it would otherwise publish are missing a slug in Notion. |
+| flag                                    | required? | description                                                                                                                                                                                                                                                                                                         |
+| --------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `-n, --notion-token <string>`           | required  | notion api token, which looks like `secret_3bc1b50XFYb15123RHF243x43450XFY33250XFYa343`                                                                                                                                                                                                                             |
+| `-r, --root-page <string>`              | required  | The 31 character ID of the page which is the root of your docs page in notion. The code will look like `9120ec9960244ead80fa2ef4bc1bba25`. This page must have a child page named 'Outline'                                                                                                                         |
+| `-m, --markdown-output-path <string>`   |           | Root of the hierarchy for md files. WARNING: node-pull-mdx will delete files from this directory. Note also that if it finds localized images, it will create an i18n/ directory as a sibling. (default: `./docs`)                                                                                                  |
+| `-t, --status-tag <string>`             |           | Database pages without a Notion page property 'status' matching this will be ignored. Use '\*' to ignore status altogether. (default: `Publish`)                                                                                                                                                                    |
+| `--locales <codes>`                     |           | Comma-separated list of iso 639-2 codes, the same list as in docusaurus.config.js, minus the primary (i.e. 'en'). This is needed for image localization. (default: `[]`)                                                                                                                                            |
+| `-l, --log-level <level>`               |           | Log level (choices: `info`, `verbose`, `debug`)                                                                                                                                                                                                                                                                     |
+| `-i, --img-output-path <string>`        |           | Path to directory where images will be stored. If this is not included, images will be placed in the same directory as the document that uses them, which then allows for localization of screenshots.                                                                                                              |
+| `-p, --img-prefix-in-markdown <string>` |           | When referencing an image from markdown, prefix with this path instead of the full img-output-path. Should be used only in conjunction with --img-output-path.                                                                                                                                                      |
+| `--require-slugs`                       |           | If set, docu-notion will fail if any pages it would otherwise publish are missing a slug in Notion.                                                                                                                                                                                                                 |
+| `--docusaurus-v2`                       |           | Emit Docusaurus v2-compatible markdown instead of the default Docusaurus v3-compatible output. This preserves legacy heading IDs, `:::caution`, and raw-emoji admonition keywords.                                                                                                                                  |
 | `--image-file-name-format <format>`     |           | choices:<ul><li>`default`: {page slug (if any)}.{image block ID}</li><li>`content-hash`: Use a hash of the image content.</li><li>`legacy`: Use the legacy (before v0.16) method of determining file names. Set this to maintain backward compatibility.</li></ul>All formats will use the original file extension. |
-| `-h, --help`                            |           | display help for command                              |
+| `-h, --help`                            |           | display help for command                                                                                                                                                                                                                                                                                            |
 
 # Plugins
 
@@ -142,16 +161,19 @@ If your project needs some processing that docu-notion doesn't already provide,
 
 # Callouts ➜ Admonitions
 
-To map Notion callouts to Docusaurus admonitions, ensure the icon is for the type you want.
+To map Notion callouts to Docusaurus admonitions, ensure the icon is an emoji for the type you want.
 
 - ℹ️ ➜ note
 - 📝➜ note
 - 💡➜ tip
 - ❗➜ info
-- ⚠️➜ caution
+- ⚠️➜ warning[Caution]
 - 🔥➜ danger
+- unknown emoji ➜ note[emoji]
+
+If a Notion callout uses a named Notion icon instead of an emoji, docu-notion does not try to synthesize an equivalent symbol from the icon name or color. Those callouts fall back to a plain `:::note` admonition.
 
-The default admonition type, if no matching icon is found, is "note".
+The default admonition type, if no matching icon is found, is "note". Use `--docusaurus-v2` to keep the legacy `⚠️ ➜ caution` behavior and the old raw-emoji fallback.
 
 # Known Workarounds
 

package/dist/NotionPage.d.ts

@@ -1,4 +1,4 @@
-import { GetPageResponse } from "@notionhq/client/build/src/api-endpoints";
+import { GetPageResponse } from "@notionhq/client";
 import { ListBlockChildrenResponseResults } from "notion-to-md/build/types";
 export declare enum PageType {
     DatabasePage = 0,

package/dist/NotionPage.js

@@ -20,6 +20,11 @@ var PageType;
     PageType[PageType["DatabasePage"] = 0] = "DatabasePage";
     PageType[PageType["Simple"] = 1] = "Simple";
 })(PageType || (exports.PageType = PageType = {}));
+function isDatabaseBackedPage(metadata) {
+    var _a;
+    const parentType = (_a = metadata.parent) === null || _a === void 0 ? void 0 : _a.type;
+    return parentType === "database_id" || parentType === "data_source_id";
+}
 class NotionPage {
     constructor(args) {
         this.layoutContext = args.layoutContext;
@@ -53,7 +58,7 @@ class NotionPage {
                 ...
             },
         */
-        return this.metadata.parent.type === "database_id"
+        return isDatabaseBackedPage(this.metadata)
             ? PageType.DatabasePage
             : PageType.Simple;
     }

package/dist/NotionPage.spec.js

@@ -140,4 +140,66 @@ describe("NotionPage", () => {
             expect(result).toBe("Default Value");
         });
     });
+    describe("page type detection", () => {
+        it("treats data_source_id pages as database pages", () => {
+            const page = new NotionPage_1.NotionPage({
+                layoutContext: "Test Context",
+                pageId: "123",
+                order: 1,
+                metadata: Object.assign(Object.assign({}, mockMetadata), { parent: {
+                        type: "data_source_id",
+                        data_source_id: "source-123",
+                        database_id: "database-123",
+                    }, properties: {
+                        Name: {
+                            id: "title",
+                            type: "title",
+                            title: [
+                                {
+                                    type: "text",
+                                    text: {
+                                        content: "Columns",
+                                        link: null,
+                                    },
+                                    annotations: {
+                                        bold: false,
+                                        italic: false,
+                                        strikethrough: false,
+                                        underline: false,
+                                        code: false,
+                                        color: "default",
+                                    },
+                                    plain_text: "Columns",
+                                    href: null,
+                                },
+                            ],
+                        },
+                        Status: {
+                            id: "status",
+                            type: "select",
+                            select: {
+                                id: "publish",
+                                name: "Publish",
+                                color: "green",
+                            },
+                        },
+                    } }),
+                foundDirectlyInOutline: false,
+            });
+            expect(page.type).toBe(NotionPage_1.PageType.DatabasePage);
+            expect(page.nameOrTitle).toBe("Columns");
+            expect(page.status).toBe("Publish");
+        });
+        it("keeps workspace pages as simple pages", () => {
+            const page = new NotionPage_1.NotionPage({
+                layoutContext: "Test Context",
+                pageId: "123",
+                order: 1,
+                metadata: mockMetadata,
+                foundDirectlyInOutline: true,
+            });
+            expect(page.type).toBe(NotionPage_1.PageType.Simple);
+            expect(page.nameOrTitle).toBe("FooBar");
+        });
+    });
 });

package/dist/latex.spec.js

@@ -49,6 +49,7 @@ test("Latex Rendering", () => __awaiter(void 0, void 0, void 0, function* () {
             imgOutputPath: "",
             imgPrefixInMarkdown: "",
             statusTag: "",
+            docusaurusV2: false,
         },
         pages: pages,
         counts: counts, // review will this get copied or pointed to?
@@ -75,6 +76,7 @@ test("Latex Rendering", () => __awaiter(void 0, void 0, void 0, function* () {
             },
             has_children: false,
             archived: false,
+            in_trash: false,
             type: "paragraph",
             paragraph: {
                 rich_text: [
@@ -93,6 +95,7 @@ test("Latex Rendering", () => __awaiter(void 0, void 0, void 0, function* () {
                         href: null,
                     },
                 ],
+                icon: null,
                 color: "default",
             },
         },

package/dist/plugins/CalloutTransformer.js

@@ -10,14 +10,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.standardCalloutTransformer = void 0;
-// In Notion, you can make a callout and change its emoji. We map 5 of these
-// to the 5 Docusaurus admonition styles.
+// In Notion, you can make a callout and change its emoji. We map common callout
+// emojis to the built-in Docusaurus admonition styles.
 // This is mostly a copy of the callout code from notion-to-md. The change is to output docusaurus
 // admonitions instead of emulating a callout with markdown > syntax.
 // Note: I haven't yet tested this with any emoji except "💡"/"tip", nor the case where the
 // callout has-children. Not even sure what that would mean, since the document I was testing
 // with has quite complex markup inside the callout, but still takes the no-children branch.
-function notionCalloutToAdmonition(notionToMarkdown, getBlockChildren, block) {
+function notionCalloutToAdmonition(context, block) {
     return __awaiter(this, void 0, void 0, function* () {
         // In this case typescript is not able to index the types properly, hence ignoring the error
         // @ts-ignore
@@ -28,7 +28,7 @@ function notionCalloutToAdmonition(notionToMarkdown, getBlockChildren, block) {
         blockContent.map((content) => {
             const annotations = content.annotations;
             let plain_text = content.plain_text;
-            plain_text = notionToMarkdown.annotatePlainText(plain_text, annotations);
+            plain_text = context.notionToMarkdown.annotatePlainText(plain_text, annotations);
             if (content["href"])
                 plain_text = `[${plain_text}](${content["href"]})`;
             parsedData += plain_text;
@@ -36,17 +36,17 @@ function notionCalloutToAdmonition(notionToMarkdown, getBlockChildren, block) {
         let callout_string = "";
         const { id, has_children } = block;
         if (!has_children) {
-            const result1 = callout(parsedData, icon);
+            const result1 = callout(parsedData, icon, context.options);
             return result1;
         }
-        const callout_children_object = yield getBlockChildren(id);
+        const callout_children_object = yield context.getBlockChildren(id);
         // // parse children blocks to md object
-        const callout_children = yield notionToMarkdown.blocksToMarkdown(callout_children_object);
+        const callout_children = yield context.notionToMarkdown.blocksToMarkdown(callout_children_object);
         callout_string += `${parsedData}\n`;
         callout_children.map(child => {
             callout_string += `${child.parent}\n\n`;
         });
-        const result = callout(callout_string.trim(), icon);
+        const result = callout(callout_string.trim(), icon, context.options);
         return result;
     });
 }
@@ -55,34 +55,46 @@ const calloutsToAdmonitions = {
     "📝": "note",
     "💡": "tip",
     "❗": "info",
-    "⚠️": "caution",
+    "⚠️": "warning",
     "🔥": "danger",
 };
 // This is the main change from the notion-to-md code.
-function callout(text, icon) {
-    var _a;
+function callout(text, icon, options) {
+    var _a, _b, _c;
     let emoji;
     if ((icon === null || icon === void 0 ? void 0 : icon.type) === "emoji") {
         emoji = icon.emoji;
     }
+    const docusaurusV2 = (_a = options.docusaurusV2) !== null && _a !== void 0 ? _a : false;
     let docusaurusAdmonition = "note";
+    let admonitionTitle = "";
     if (emoji) {
+        if (docusaurusV2) {
+            docusaurusAdmonition =
+                (_b = calloutsToAdmonitions[emoji]) !== null && _b !== void 0 ? _b : emoji;
+            if (docusaurusAdmonition === "warning") {
+                docusaurusAdmonition = "caution";
+            }
+            return `:::${docusaurusAdmonition}\n\n${text}\n\n:::\n\n`;
+        }
         // the keyof typeof magic persuades typescript that it really is OK to use emoji as a key into calloutsToAdmonitions
         docusaurusAdmonition =
-            (_a = calloutsToAdmonitions[emoji]) !== null && _a !== void 0 ? _a : 
-            // For Notion callouts with other emojis, pass them through using hte emoji as the name.
-            // For this to work on a Docusaurus site, it will need to define that time on the remark-admonitions options in the docusaurus.config.js.
-            // See https://github.com/elviswolcott/remark-admonitions and https://docusaurus.io/docs/using-plugins#using-presets.
-            emoji;
+            (_c = calloutsToAdmonitions[emoji]) !== null && _c !== void 0 ? _c : "note";
+        if (emoji === "⚠️") {
+            admonitionTitle = "[Caution]";
+        }
+        else if (!(emoji in calloutsToAdmonitions)) {
+            admonitionTitle = `[${emoji}]`;
+        }
     }
-    return `:::${docusaurusAdmonition}\n\n${text}\n\n:::\n\n`;
+    return `:::${docusaurusAdmonition}${admonitionTitle}\n\n${text}\n\n:::\n\n`;
 }
 exports.standardCalloutTransformer = {
     name: "standardCalloutTransformer",
     notionToMarkdownTransforms: [
         {
             type: "callout",
-            getStringFromBlock: (context, block) => notionCalloutToAdmonition(context.notionToMarkdown, context.getBlockChildren, block),
+            getStringFromBlock: (context, block) => notionCalloutToAdmonition(context, block),
         },
     ],
 };

package/dist/plugins/CalloutTransformer.spec.js

@@ -116,7 +116,7 @@ test("external link inside callout, bold preserved", () => __awaiter(void 0, voi
             },
         },
     ]);
-    expect(results.trim()).toBe(`:::caution
+    expect(results.trim()).toBe(`:::warning[Caution]
 
 Callouts inline [**great page**](https://github.com).
 
@@ -191,9 +191,46 @@ test("internal link inside callout, bold preserved", () => __awaiter(void 0, voi
             },
         },
     ], [slugTargetPage]);
-    expect(results.trim()).toBe(`:::caution
+    expect(results.trim()).toBe(`:::warning[Caution]
 
 Callouts inline [**great page**](/hello-world#456) the end.
 
 :::`);
 }));
+test("unknown emoji callout falls back to note with title in docusaurus v3 mode", () => __awaiter(void 0, void 0, void 0, function* () {
+    const config = { plugins: [CalloutTransformer_1.standardCalloutTransformer] };
+    block.callout.icon.emoji = "🧪";
+    const results = yield (0, pluginTestRun_1.blocksToMarkdown)(config, [
+        block,
+    ]);
+    expect(results.trim()).toBe(`:::note[🧪]
+
+This is the callout
+
+:::`);
+}));
+test("named notion icon callout falls back to plain note in docusaurus v3 mode", () => __awaiter(void 0, void 0, void 0, function* () {
+    const config = { plugins: [CalloutTransformer_1.standardCalloutTransformer] };
+    block.callout.icon = {
+        type: "icon",
+        icon: { name: "airplane", color: "purple" },
+    };
+    const results = yield (0, pluginTestRun_1.blocksToMarkdown)(config, [
+        block,
+    ]);
+    expect(results.trim()).toBe(`:::note
+
+This is the callout
+
+:::`);
+}));
+test("docusaurus-v2 flag keeps legacy callout syntax", () => __awaiter(void 0, void 0, void 0, function* () {
+    const config = { plugins: [CalloutTransformer_1.standardCalloutTransformer] };
+    block.callout.icon.emoji = "⚠️";
+    const results = yield (0, pluginTestRun_1.blocksToMarkdown)(config, [block], undefined, undefined, undefined, { docusaurusV2: true });
+    expect(results.trim()).toBe(`:::caution
+
+This is the callout
+
+:::`);
+}));

package/dist/plugins/ColumnListTransformer.js

@@ -10,16 +10,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.standardColumnListTransformer = void 0;
+const ColumnTransformer_1 = require("./ColumnTransformer");
 function notionColumnListToMarkdown(notionToMarkdown, getBlockChildren, block) {
     return __awaiter(this, void 0, void 0, function* () {
-        // Enhance: The @notionhq/client, which uses the official API, cannot yet get at column formatting information (column_ratio)
-        // However https://github1s.com/NotionX/react-notion-x/blob/master/packages/react-notion-x/src/block.tsx#L528 can get it.
-        const { id, has_children } = block; // "any" because the notion api type system is complex with a union that don't know how to help TS to cope with
-        if (!has_children)
+        if (!(0, ColumnTransformer_1.isColumnListBlock)(block) || !block.has_children)
             return "";
-        const column_list_children = yield getBlockChildren(id);
+        const column_list_children = yield getBlockChildren(block.id);
+        (0, ColumnTransformer_1.rememberColumnListChildren)(column_list_children);
+        const columnsToRender = column_list_children.filter((child) => child.type === "column");
         const columns = [];
-        for (const column of column_list_children) {
+        for (const column of columnsToRender) {
             // Keep column rendering sequential. A column block can trigger more Notion
             // reads downstream, so Promise.all() here would turn one page into a burst
             // of concurrent API requests during stage 2.

package/dist/plugins/ColumnTransformer.d.ts

@@ -1,2 +1,8 @@
+import { ColumnListBlockObjectResponse } from "@notionhq/client";
+import { ListBlockChildrenResponseResult } from "notion-to-md/build/types";
 import { IPlugin } from "./pluginTypes";
+import { NotionBlock } from "../types";
+export declare function isColumnListBlock(block: NotionBlock | ListBlockChildrenResponseResult): block is ColumnListBlockObjectResponse;
 export declare const standardColumnTransformer: IPlugin;
+export declare function rememberColumnListChildren(columnBlocks: NotionBlock[]): void;
+export declare function getColumnWidth(block: ListBlockChildrenResponseResult): string;

package/dist/plugins/ColumnTransformer.js

@@ -10,8 +10,31 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.standardColumnTransformer = void 0;
-const notion_client_1 = require("notion-client");
-const pull_1 = require("../pull");
+exports.isColumnListBlock = isColumnListBlock;
+exports.rememberColumnListChildren = rememberColumnListChildren;
+exports.getColumnWidth = getColumnWidth;
+const columnCountById = new Map();
+const normalizedColumnRatioById = new Map();
+function isColumnBlock(block) {
+    return "type" in block && block.type === "column";
+}
+function isColumnListBlock(block) {
+    return "type" in block && block.type === "column_list";
+}
+function getRawColumnRatio(block) {
+    if (!isColumnBlock(block))
+        return undefined;
+    const ratio = block.column.width_ratio;
+    return typeof ratio === "number" && Number.isFinite(ratio)
+        ? ratio
+        : undefined;
+}
+function approximatelyEqual(left, right, epsilon = 0.000001) {
+    return Math.abs(left - right) < epsilon;
+}
+function isDefinedNumber(value) {
+    return value !== undefined;
+}
 exports.standardColumnTransformer = {
     name: "standardColumnTransformer",
     notionToMarkdownTransforms: [
@@ -21,14 +44,32 @@ exports.standardColumnTransformer = {
         },
     ],
 };
+function rememberColumnListChildren(columnBlocks) {
+    const columns = columnBlocks.filter(isColumnBlock);
+    const columnCount = columns.length;
+    const explicitRatios = columns.map(getRawColumnRatio);
+    const allExplicit = explicitRatios.every(isDefinedNumber);
+    const explicitSum = explicitRatios.reduce((sum, ratio) => sum + (ratio !== null && ratio !== void 0 ? ratio : 0), 0);
+    const normalizedRatios = allExplicit && approximatelyEqual(explicitSum, 1)
+        ? explicitRatios
+        : (() => {
+            const weights = explicitRatios.map(ratio => ratio !== null && ratio !== void 0 ? ratio : 1);
+            const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
+            return totalWeight > 0
+                ? weights.map(weight => weight / totalWeight)
+                : weights.map(() => 1 / Math.max(columnCount, 1));
+        })();
+    for (const [index, columnBlock] of columns.entries()) {
+        columnCountById.set(columnBlock.id, columnCount);
+        normalizedColumnRatioById.set(columnBlock.id, normalizedRatios[index]);
+    }
+}
 // This runs when notion-to-md encounters a column block
 function notionColumnToMarkdown(notionToMarkdown, getBlockChildren, block) {
     return __awaiter(this, void 0, void 0, function* () {
-        //console.log(JSON.stringify(block));
-        const { id, has_children } = block; // "any" because the notion api type system is complex with a union that don't know how to help TS to cope with
-        if (!has_children)
+        if (!isColumnBlock(block) || !block.has_children)
             return "";
-        const columnChildren = yield getBlockChildren(id);
+        const columnChildren = yield getBlockChildren(block.id);
         const childrenMdBlocksArray = [];
         for (const child of columnChildren) {
             // Intentionally serialize these subtree conversions. notion-to-md will fetch
@@ -37,38 +78,20 @@ function notionColumnToMarkdown(notionToMarkdown, getBlockChildren, block) {
             childrenMdBlocksArray.push(yield notionToMarkdown.blocksToMarkdown([child]));
         }
         const childrenMarkdown = childrenMdBlocksArray.map(mdBlockArray => notionToMarkdown.toMarkdownString(mdBlockArray).parent);
-        const columnWidth = yield getColumnWidth(block);
+        const columnWidth = getColumnWidth(block);
         return (`<div class='notion-column' style={{width: '${columnWidth}'}}>\n\n${childrenMarkdown.join("\n")}\n</div>` +
             // Spacer between columns. CSS takes care of hiding this for the last column
             // and when the screen is too narrow for multiple columns.
             `<div className='notion-spacer'></div>`);
     });
 }
-// The official API doesn't give us access to the format information, including column_ratio.
-// So we use 'notion-client' which uses the unofficial API.
-// Once the official API gives us access to the format information, we can remove this
-// and the 'notion-client' dependency.
-// This logic was mostly taken from react-notion-x (sister project of notion-client).
 function getColumnWidth(block) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d;
-        const unofficialNotionClient = new notion_client_1.NotionAPI();
-        const blockId = block.id;
-        const recordMap = yield (0, pull_1.executeWithRateLimitAndRetries)(`unofficialNotionClient.getPage(${blockId}) in getColumnWidth()`, () => {
-            // Yes, it is odd to call 'getPage' for a block, but that's how we access the format info.
-            return unofficialNotionClient.getPage(blockId);
-        });
-        const blockResult = recordMap.block[blockId];
-        // ENHANCE: could we use https://github.com/NotionX/react-notion-x/tree/master/packages/notion-types
-        // to get away from "any", which might be particularly helpful in the future
-        // since this is using the unofficial (reverse engineered?) API.
-        const columnFormat = (_a = blockResult === null || blockResult === void 0 ? void 0 : blockResult.value) === null || _a === void 0 ? void 0 : _a.format;
-        const columnRatio = (columnFormat === null || columnFormat === void 0 ? void 0 : columnFormat.column_ratio) || 0.5;
-        const parentBlock = (_c = recordMap.block[(_b = blockResult === null || blockResult === void 0 ? void 0 : blockResult.value) === null || _b === void 0 ? void 0 : _b.parent_id]) === null || _c === void 0 ? void 0 : _c.value;
-        // I'm not sure why we wouldn't get a parent, but the react-notion-x has
-        // this fallback to a guess based on the columnRatio.
-        const columnCount = ((_d = parentBlock === null || parentBlock === void 0 ? void 0 : parentBlock.content) === null || _d === void 0 ? void 0 : _d.length) || Math.max(2, Math.ceil(1.0 / columnRatio));
-        const spacerWidth = `min(32px, 4vw)`; // This matches the value in css for 'notion-spacer'.
-        return `calc((100% - (${spacerWidth} * ${columnCount - 1})) * ${columnRatio})`;
-    });
+    var _a, _b;
+    const columnRatio = (_b = (_a = normalizedColumnRatioById.get(block.id)) !== null && _a !== void 0 ? _a : getRawColumnRatio(block)) !== null && _b !== void 0 ? _b : 0.5;
+    // The spacer width depends on how many sibling columns are present. We record
+    // that when the parent column_list is converted, then fall back to the older
+    // estimate when a column is converted without that context.
+    const columnCount = columnCountById.get(block.id) || Math.max(2, Math.ceil(1.0 / columnRatio));
+    const spacerWidth = `min(32px, 4vw)`; // This matches the value in css for 'notion-spacer'.
+    return `calc((100% - (${spacerWidth} * ${columnCount - 1})) * ${columnRatio})`;
 }

package/dist/plugins/ColumnTransformer.spec.js

@@ -37,6 +37,90 @@ function getResults(children) {
 }
 const columnWrapperStart = "<div class='notion-column' style=\\{\\{width: '.*?'\\}\\}>\\n\\n";
 const columnWrapperEnd = "\\n\\n<\\/div><div className='notion-spacer'><\\/div>";
+test("getColumnWidth preserves docs-compliant normalized ratios", () => {
+    (0, ColumnTransformer_1.rememberColumnListChildren)([
+        {
+            id: "column-1",
+            type: "column",
+            column: {
+                width_ratio: 0.25,
+            },
+        },
+        {
+            id: "column-2",
+            type: "column",
+            column: {
+                width_ratio: 0.75,
+            },
+        },
+    ]);
+    const width = (0, ColumnTransformer_1.getColumnWidth)({
+        id: "column-1",
+        type: "column",
+        column: {
+            width_ratio: 0.25,
+        },
+    });
+    expect(width).toBe("calc((100% - (min(32px, 4vw) * 1)) * 0.25)");
+});
+test("getColumnWidth normalizes missing ratios as equal weights", () => {
+    (0, ColumnTransformer_1.rememberColumnListChildren)([
+        {
+            id: "column-1",
+            type: "column",
+            column: {},
+        },
+        {
+            id: "column-2",
+            type: "column",
+            column: {},
+        },
+        {
+            id: "column-3",
+            type: "column",
+            column: {},
+        },
+    ]);
+    const width = (0, ColumnTransformer_1.getColumnWidth)({
+        id: "column-2",
+        type: "column",
+        column: {},
+    });
+    expect(width).toBe("calc((100% - (min(32px, 4vw) * 2)) * 0.3333333333333333)");
+});
+test("getColumnWidth normalizes mixed explicit and missing ratios", () => {
+    (0, ColumnTransformer_1.rememberColumnListChildren)([
+        {
+            id: "column-1",
+            type: "column",
+            column: {
+                width_ratio: 1,
+            },
+        },
+        {
+            id: "column-2",
+            type: "column",
+            column: {
+                width_ratio: 0.375,
+            },
+        },
+        {
+            id: "column-3",
+            type: "column",
+            column: {
+                width_ratio: 1,
+            },
+        },
+    ]);
+    const width = (0, ColumnTransformer_1.getColumnWidth)({
+        id: "column-2",
+        type: "column",
+        column: {
+            width_ratio: 0.375,
+        },
+    });
+    expect(width).toBe("calc((100% - (min(32px, 4vw) * 2)) * 0.15789473684210525)");
+});
 if (runTestsWhichRequireAnyValidApiKey) {
     columnBlock.has_children = true;
     test("requires API key - column with paragraph", () => __awaiter(void 0, void 0, void 0, function* () {