@sillsdev/docu-notion 0.12.0

package/dist/plugins/pluginTestRun.js

@@ -0,0 +1,248 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oneBlockToMarkdown = exports.makeSamplePageObject = exports.blocksToMarkdown = void 0;
+const client_1 = require("@notionhq/client");
+const notion_to_md_1 = require("notion-to-md");
+const HierarchicalNamedLayoutStrategy_1 = require("../HierarchicalNamedLayoutStrategy");
+const NotionPage_1 = require("../NotionPage");
+const transform_1 = require("../transform");
+function blocksToMarkdown(config, blocks, pages) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const notionClient = new client_1.Client({ auth: "unused" });
+        const notionToMD = new notion_to_md_1.NotionToMarkdown({
+            notionClient,
+        });
+        // if (pages && pages.length) {
+        //   console.log(pages[0]);
+        //   console.log(pages[0].matchesLinkId);
+        // }
+        const docunotionContext = {
+            notionToMarkdown: notionToMD,
+            // TODO when does this actually need to do get some children?
+            // We can add a children argument to this method, but for the tests
+            // I have so far, it's not needed.
+            getBlockChildren: (id) => {
+                return new Promise((resolve, reject) => {
+                    resolve([]);
+                });
+            },
+            //TODO might be needed for some tests, e.g. the image transformer...
+            directoryContainingMarkdown: "not yet",
+            relativeFilePathToFolderContainingPage: "not yet",
+            layoutStrategy: new HierarchicalNamedLayoutStrategy_1.HierarchicalNamedLayoutStrategy(),
+            options: {
+                notionToken: "",
+                rootPage: "",
+                locales: [],
+                markdownOutputPath: "",
+                imgOutputPath: "",
+                imgPrefixInMarkdown: "",
+                statusTag: "",
+            },
+            pages: pages !== null && pages !== void 0 ? pages : [],
+            counts: {
+                output_normally: 0,
+                skipped_because_empty: 0,
+                skipped_because_status: 0,
+                skipped_because_level_cannot_have_content: 0,
+            },
+            // enhance: this needs more thinking, how we want to do logging in tests
+            // one thing is to avoid a situation where we break people's tests that
+            // have come to rely on logs that we later tweak in some way.
+            // log: {
+            //   error: (s: string) => {
+            //     error(s);
+            //   },
+            //   warning: (s: string) => {
+            //     warning(s);
+            //   },
+            //   info: (s: string) => {
+            //     // info(s);
+            //   },
+            //   verbose: (s: string) => {
+            //     // verbose(s);
+            //   },
+            //   debug: (s: string) => {
+            //     // logDebug("Testrun-TODO", s);
+            //   },
+            // },
+        };
+        if (pages && pages.length) {
+            console.log(pages[0].matchesLinkId);
+            console.log(docunotionContext.pages[0].matchesLinkId);
+        }
+        const r = yield (0, transform_1.getMarkdownFromNotionBlocks)(docunotionContext, config, blocks);
+        //console.log("blocksToMarkdown", r);
+        return r;
+    });
+}
+exports.blocksToMarkdown = blocksToMarkdown;
+// This is used for things like testing links to other pages and frontmatter creation,
+// when just testing what happens to individual blocks is not enough.
+// after getting this, you can make changes to it, then pass it to blocksToMarkdown
+function makeSamplePageObject(options) {
+    let slugObject = {
+        Slug: {
+            id: "%7D%3D~K",
+            type: "rich_text",
+            rich_text: [],
+        },
+    };
+    if (options.slug)
+        slugObject = {
+            id: "%7D%3D~K",
+            type: "rich_text",
+            rich_text: [
+                {
+                    type: "text",
+                    text: {
+                        content: options.slug,
+                        link: null,
+                    },
+                    annotations: {
+                        bold: false,
+                        italic: false,
+                        strikethrough: false,
+                        underline: false,
+                        code: false,
+                        color: "default",
+                    },
+                    plain_text: options.slug,
+                    href: null,
+                },
+            ],
+        };
+    const id = options.id || "4a6de8c0-b90b-444b-8a7b-d534d6ec71a4";
+    const m = {
+        object: "page",
+        id: id,
+        created_time: "2022-08-08T21:07:00.000Z",
+        last_edited_time: "2023-01-03T14:38:00.000Z",
+        created_by: {
+            object: "user",
+            id: "11fb7f16-0560-4aee-ab88-ed75a850cfc4",
+        },
+        last_edited_by: {
+            object: "user",
+            id: "11fb7f16-0560-4aee-ab88-ed75a850cfc4",
+        },
+        cover: null,
+        icon: null,
+        parent: {
+            type: "database_id",
+            database_id: "c13f520c-06ad-41e4-a021-bdc2841ab24a",
+        },
+        archived: false,
+        properties: {
+            Keywords: {
+                id: "%3F%7DLZ",
+                type: "rich_text",
+                rich_text: [],
+            },
+            Property: {
+                id: "GmKE",
+                type: "rich_text",
+                rich_text: [],
+            },
+            Label: {
+                id: "Phor",
+                type: "multi_select",
+                multi_select: [],
+            },
+            Status: {
+                id: "oB~%3D",
+                type: "select",
+                select: {
+                    id: "1",
+                    name: "Ready For Review",
+                    color: "red",
+                },
+            },
+            Authors: {
+                id: "tA%3BF",
+                type: "multi_select",
+                multi_select: [],
+            },
+            Slug: slugObject,
+            Name: {
+                id: "title",
+                type: "title",
+                title: [
+                    {
+                        type: "text",
+                        text: {
+                            content: options.name || "Hello World",
+                            link: null,
+                        },
+                        annotations: {
+                            bold: false,
+                            italic: false,
+                            strikethrough: false,
+                            underline: false,
+                            code: false,
+                            color: "default",
+                        },
+                        plain_text: options.name || "Hello World",
+                        href: null,
+                    },
+                ],
+            },
+        },
+        url: `https://www.notion.so/Hello-World-${id}`,
+    };
+    const p = new NotionPage_1.NotionPage({
+        layoutContext: "/Second-Level/Third-Level",
+        pageId: id,
+        order: 0,
+        metadata: m,
+        foundDirectlyInOutline: false,
+    });
+    console.log(p.matchesLinkId);
+    return p;
+}
+exports.makeSamplePageObject = makeSamplePageObject;
+function oneBlockToMarkdown(config, block, targetPage) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // just in case someone expects these other properties that aren't normally relevant,
+        // we merge the given block properties into an actual, full block
+        const fullBlock = Object.assign({
+            object: "block",
+            id: "937e77e5-f058-4316-9805-a538e7b4082d",
+            parent: {
+                type: "page_id",
+                page_id: "d20d8391-b365-42cb-8821-cf3c5382c6ed",
+            },
+            created_time: "2023-01-13T16:33:00.000Z",
+            last_edited_time: "2023-01-13T16:33:00.000Z",
+            created_by: {
+                object: "user",
+                id: "11fb7f16-0560-4aee-ab88-ed75a850cfc4",
+            },
+            last_edited_by: {
+                object: "user",
+                id: "11fb7f16-0560-4aee-ab88-ed75a850cfc4",
+            },
+            has_children: false,
+            archived: false,
+        }, block);
+        const dummyPage1 = makeSamplePageObject({
+            slug: "dummy1",
+            name: "Dummy1",
+        });
+        const dummyPage2 = makeSamplePageObject({
+            slug: "dummy2",
+            name: "Dummy2",
+        });
+        return yield blocksToMarkdown(config, [fullBlock], targetPage ? [dummyPage1, targetPage, dummyPage2] : undefined);
+    });
+}
+exports.oneBlockToMarkdown = oneBlockToMarkdown;

package/dist/plugins/pluginTypes.d.ts

@@ -0,0 +1,42 @@
+import { ListBlockChildrenResponseResult } from "notion-to-md/build/types";
+import { NotionPage } from "../NotionPage";
+import { NotionToMarkdown } from "notion-to-md";
+import { DocuNotionOptions } from "../pull";
+import { LayoutStrategy } from "../LayoutStrategy";
+import { ICounts, NotionBlock } from "../index";
+type linkConversionFunction = (context: IDocuNotionContext, markdownLink: string) => string;
+export type IPlugin = {
+    name: string;
+    notionBlockModifications?: {
+        modify: (block: NotionBlock) => void;
+    }[];
+    notionToMarkdownTransforms?: {
+        type: string;
+        getStringFromBlock: (context: IDocuNotionContext, block: NotionBlock) => string | Promise<string>;
+    }[];
+    linkModifier?: {
+        match: RegExp;
+        convert: linkConversionFunction;
+    };
+    regexMarkdownModifications?: IRegexMarkdownModification[];
+    init?(plugin: IPlugin): Promise<void>;
+};
+export type IRegexMarkdownModification = {
+    regex: RegExp;
+    replacementPattern?: string;
+    getReplacement?(s: string): Promise<string>;
+    imports?: string[];
+};
+export type ICustomNotionToMarkdownConversion = (block: ListBlockChildrenResponseResult, context: IDocuNotionContext) => () => Promise<string>;
+export type IGetBlockChildrenFn = (id: string) => Promise<NotionBlock[]>;
+export type IDocuNotionContext = {
+    layoutStrategy: LayoutStrategy;
+    options: DocuNotionOptions;
+    getBlockChildren: IGetBlockChildrenFn;
+    notionToMarkdown: NotionToMarkdown;
+    directoryContainingMarkdown: string;
+    relativeFilePathToFolderContainingPage: string;
+    pages: NotionPage[];
+    counts: ICounts;
+};
+export {};

package/dist/plugins/pluginTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/pull.d.ts

@@ -0,0 +1,12 @@
+import { Client } from "@notionhq/client";
+export type DocuNotionOptions = {
+    notionToken: string;
+    rootPage: string;
+    locales: string[];
+    markdownOutputPath: string;
+    imgOutputPath: string;
+    imgPrefixInMarkdown: string;
+    statusTag: string;
+};
+export declare function notionPull(options: DocuNotionOptions): Promise<void>;
+export declare function initNotionClient(notionToken: string): Client;

package/dist/pull.js

@@ -0,0 +1,253 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initNotionClient = exports.notionPull = void 0;
+const fs = __importStar(require("fs-extra"));
+const notion_to_md_1 = require("notion-to-md");
+const HierarchicalNamedLayoutStrategy_1 = require("./HierarchicalNamedLayoutStrategy");
+const NotionPage_1 = require("./NotionPage");
+const images_1 = require("./images");
+const Path = __importStar(require("path"));
+const log_1 = require("./log");
+const transform_1 = require("./transform");
+const limiter_1 = require("limiter");
+const client_1 = require("@notionhq/client");
+const process_1 = require("process");
+const configuration_1 = require("./config/configuration");
+let layoutStrategy;
+let notionToMarkdown;
+const pages = new Array();
+const counts = {
+    output_normally: 0,
+    skipped_because_empty: 0,
+    skipped_because_status: 0,
+    skipped_because_level_cannot_have_content: 0,
+};
+function notionPull(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // It's helpful when troubleshooting CI secrets and environment variables to see what options actually made it to docu-notion.
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        const optionsForLogging = Object.assign({}, options);
+        // Just show the first few letters of the notion token, which start with "secret" anyhow.
+        optionsForLogging.notionToken =
+            optionsForLogging.notionToken.substring(0, 3) + "...";
+        const config = yield (0, configuration_1.loadConfigAsync)();
+        (0, log_1.verbose)(`Options:${JSON.stringify(optionsForLogging, null, 2)}`);
+        yield (0, images_1.initImageHandling)(options.imgPrefixInMarkdown || options.imgOutputPath || "", options.imgOutputPath || "", options.locales);
+        const notionClient = initNotionClient(options.notionToken);
+        notionToMarkdown = new notion_to_md_1.NotionToMarkdown({ notionClient });
+        layoutStrategy = new HierarchicalNamedLayoutStrategy_1.HierarchicalNamedLayoutStrategy();
+        yield fs.mkdir(options.markdownOutputPath, { recursive: true });
+        layoutStrategy.setRootDirectoryForMarkdown(options.markdownOutputPath.replace(/\/+$/, "") // trim any trailing slash
+        );
+        (0, log_1.info)("Connecting to Notion...");
+        (0, log_1.group)("Stage 1: walk children of the page named 'Outline', looking for pages...");
+        yield getPagesRecursively(options, "", options.rootPage, 0, true);
+        (0, log_1.logDebug)("getPagesRecursively", JSON.stringify(pages, null, 2));
+        (0, log_1.info)(`Found ${pages.length} pages`);
+        (0, log_1.endGroup)();
+        (0, log_1.group)(`Stage 2: convert ${pages.length} Notion pages to markdown and save locally...`);
+        yield outputPages(options, config, pages);
+        (0, log_1.endGroup)();
+        (0, log_1.group)("Stage 3: clean up old files & images...");
+        yield layoutStrategy.cleanupOldFiles();
+        yield (0, images_1.cleanupOldImages)();
+        (0, log_1.endGroup)();
+    });
+}
+exports.notionPull = notionPull;
+function outputPages(options, config, pages) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = {
+            getBlockChildren: getBlockChildren,
+            directoryContainingMarkdown: "",
+            relativeFilePathToFolderContainingPage: "",
+            layoutStrategy: layoutStrategy,
+            notionToMarkdown: notionToMarkdown,
+            options: options,
+            pages: pages,
+            counts: counts, // review will this get copied or pointed to?
+        };
+        for (const page of pages) {
+            layoutStrategy.pageWasSeen(page);
+            const mdPath = layoutStrategy.getPathForPage(page, ".md");
+            // most plugins should not write to disk, but those handling image files need these paths
+            context.directoryContainingMarkdown = Path.dirname(mdPath);
+            // TODO: This needs clarifying: getLinkPathForPage() is about urls, but
+            // downstream images.ts is using it as a file system path
+            context.relativeFilePathToFolderContainingPage = Path.dirname(layoutStrategy.getLinkPathForPage(page));
+            if (page.type === NotionPage_1.PageType.DatabasePage &&
+                context.options.statusTag != "*" &&
+                page.status !== context.options.statusTag) {
+                (0, log_1.verbose)(`Skipping page because status is not '${context.options.statusTag}': ${page.nameOrTitle}`);
+                ++context.counts.skipped_because_status;
+            }
+            else {
+                const markdown = yield (0, transform_1.getMarkdownForPage)(config, context, page);
+                writePage(page, markdown);
+            }
+        }
+        (0, log_1.info)(`Finished processing ${pages.length} pages`);
+        (0, log_1.info)(JSON.stringify(counts));
+    });
+}
+// This walks the "Outline" page and creates a list of all the nodes that will
+// be in the sidebar, including the directories, the pages that are linked to
+// that are parented in from the "Database", and any pages we find in the
+// outline that contain content (which we call "Simple" pages). Later, we can
+// then step through this list creating the files we need, and, crucially, be
+// able to figure out what the url will be for any links between content pages.
+function getPagesRecursively(options, incomingContext, pageIdOfThisParent, orderOfThisParent, rootLevel) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const pageInTheOutline = yield fromPageId(incomingContext, pageIdOfThisParent, orderOfThisParent, true);
+        (0, log_1.info)(`Looking for children and links from ${incomingContext}/${pageInTheOutline.nameOrTitle}`);
+        const r = yield getBlockChildren(pageInTheOutline.pageId);
+        const pageInfo = yield pageInTheOutline.getContentInfo(r);
+        if (!rootLevel &&
+            pageInfo.hasParagraphs &&
+            pageInfo.childPageIdsAndOrder.length) {
+            (0, log_1.error)(`Skipping "${pageInTheOutline.nameOrTitle}"  and its children. docu-notion does not support pages that are both levels and have content at the same time.`);
+            ++counts.skipped_because_level_cannot_have_content;
+            return;
+        }
+        if (!rootLevel && pageInfo.hasParagraphs) {
+            pages.push(pageInTheOutline);
+            // The best practice is to keep content pages in the "database" (e.g. kanban board), but we do allow people to make pages in the outline directly.
+            // So how can we tell the difference between a page that is supposed to be content and one that is meant to form the sidebar? If it
+            // has only links, then it's a page for forming the sidebar. If it has contents and no links, then it's a content page. But what if
+            // it has both? Well then we assume it's a content page.
+            if ((_a = pageInfo.linksPageIdsAndOrder) === null || _a === void 0 ? void 0 : _a.length) {
+                (0, log_1.warning)(`Note: The page "${pageInTheOutline.nameOrTitle}" is in the outline, has content, and also points at other pages. It will be treated as a simple content page. This is no problem, unless you intended to have all your content pages in the database (kanban workflow) section.`);
+            }
+        }
+        // a normal outline page that exists just to create the level, pointing at database pages that belong in this level
+        else if (pageInfo.childPageIdsAndOrder.length ||
+            pageInfo.linksPageIdsAndOrder.length) {
+            let layoutContext = incomingContext;
+            // don't make a level for "Outline" page at the root
+            if (!rootLevel && pageInTheOutline.nameOrTitle !== "Outline") {
+                layoutContext = layoutStrategy.newLevel(options.markdownOutputPath, pageInTheOutline.order, incomingContext, pageInTheOutline.nameOrTitle);
+            }
+            for (const childPageInfo of pageInfo.childPageIdsAndOrder) {
+                yield getPagesRecursively(options, layoutContext, childPageInfo.id, childPageInfo.order, false);
+            }
+            for (const linkPageInfo of pageInfo.linksPageIdsAndOrder) {
+                pages.push(yield fromPageId(layoutContext, linkPageInfo.id, linkPageInfo.order, false));
+            }
+        }
+        else {
+            console.info((0, log_1.warning)(`Warning: The page "${pageInTheOutline.nameOrTitle}" is in the outline but appears to not have content, links to other pages, or child pages. It will be skipped.`));
+            ++counts.skipped_because_empty;
+        }
+    });
+}
+function writePage(page, finalMarkdown) {
+    const mdPath = layoutStrategy.getPathForPage(page, ".md");
+    (0, log_1.verbose)(`writing ${mdPath}`);
+    fs.writeFileSync(mdPath, finalMarkdown, {});
+    ++counts.output_normally;
+}
+const notionLimiter = new limiter_1.RateLimiter({
+    tokensPerInterval: 3,
+    interval: "second",
+});
+let notionClient;
+function getPageMetadata(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield rateLimit();
+        return yield notionClient.pages.retrieve({
+            page_id: id,
+        });
+    });
+}
+function rateLimit() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (notionLimiter.getTokensRemaining() < 1) {
+            (0, log_1.logDebug)("rateLimit", "*** delaying for rate limit");
+        }
+        yield notionLimiter.removeTokens(1);
+    });
+}
+function getBlockChildren(id) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        // we can only get so many responses per call, so we set this to
+        // the first response we get, then keep adding to its array of blocks
+        // with each subsequent response
+        let overallResult = undefined;
+        let start_cursor = undefined;
+        // Note: there is a now a collectPaginatedAPI() in the notion client, so
+        // we could switch to using that (I don't know if it does rate limiting?)
+        do {
+            yield rateLimit();
+            const response = yield notionClient.blocks.children.list({
+                start_cursor: start_cursor,
+                block_id: id,
+            });
+            if (!overallResult) {
+                overallResult = response;
+            }
+            else {
+                overallResult.results.push(...response.results);
+            }
+            start_cursor = response === null || response === void 0 ? void 0 : response.next_cursor;
+        } while (start_cursor != null);
+        if ((_a = overallResult === null || overallResult === void 0 ? void 0 : overallResult.results) === null || _a === void 0 ? void 0 : _a.some(b => !(0, client_1.isFullBlock)(b))) {
+            (0, log_1.error)(`The Notion API returned some blocks that were not full blocks. docu-notion does not handle this yet. Please report it.`);
+            (0, process_1.exit)(1);
+        }
+        return (_b = overallResult === null || overallResult === void 0 ? void 0 : overallResult.results) !== null && _b !== void 0 ? _b : [];
+    });
+}
+function initNotionClient(notionToken) {
+    notionClient = new client_1.Client({
+        auth: notionToken,
+    });
+    return notionClient;
+}
+exports.initNotionClient = initNotionClient;
+function fromPageId(context, pageId, order, foundDirectlyInOutline) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const metadata = yield getPageMetadata(pageId);
+        //logDebug("notion metadata", JSON.stringify(metadata));
+        return new NotionPage_1.NotionPage({
+            layoutContext: context,
+            pageId,
+            order,
+            metadata,
+            foundDirectlyInOutline,
+        });
+    });
+}

package/dist/run.d.ts

@@ -0,0 +1 @@
+export declare function run(): void;

package/dist/run.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const commander_1 = require("commander");
+const log_1 = require("./log");
+const pull_1 = require("./pull");
+function run() {
+    const pkg = require("../package.json");
+    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+    console.log(`docu-notion version ${pkg.version}`);
+    commander_1.program.name("docu-notion").description("");
+    commander_1.program.usage("-n <token> -r <root> [options]");
+    commander_1.program
+        .requiredOption("-n, --notion-token <string>", "notion api token, which looks like secret_3bc1b50XFYb15123RHF243x43450XFY33250XFYa343")
+        .requiredOption("-r, --root-page <string>", "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'")
+        .option("-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.", "./docs")
+        .option("-t, --status-tag  <string>", "Database pages without a Notion page property 'status' matching this will be ignored. Use '*' to ignore status altogether.", "Publish")
+        .option("--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.", parseLocales, [])
+        .addOption(new commander_1.Option("-l, --log-level <level>", "Log level").choices([
+        "info",
+        "verbose",
+        "debug",
+    ]))
+        .option("-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.")
+        .option("-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.");
+    commander_1.program.showHelpAfterError();
+    commander_1.program.parse();
+    (0, log_1.setLogLevel)(commander_1.program.opts().logLevel);
+    console.log(JSON.stringify(commander_1.program.opts));
+    (0, pull_1.notionPull)(commander_1.program.opts()).then(() => console.log("docu-notion Finished."));
+}
+exports.run = run;
+function parseLocales(value) {
+    return value.split(",").map(l => l.trim().toLowerCase());
+}

package/dist/transform.d.ts

@@ -0,0 +1,6 @@
+import { IDocuNotionContext } from "./plugins/pluginTypes";
+import { NotionPage } from "./NotionPage";
+import { IDocuNotionConfig } from "./config/configuration";
+import { NotionBlock } from "./types";
+export declare function getMarkdownForPage(config: IDocuNotionConfig, context: IDocuNotionContext, page: NotionPage): Promise<string>;
+export declare function getMarkdownFromNotionBlocks(context: IDocuNotionContext, config: IDocuNotionConfig, blocks: Array<NotionBlock>): Promise<string>;