noblog 0.2.2 → 0.3.0-beta.1

package/dist/generate.js

@@ -1,940 +1,205 @@
 #!/usr/bin/env node
-import * as path from 'path';
-import { dirname, join } from 'path';
-import * as fs from 'fs/promises';
-import fetch from 'node-fetch';
-import { markdownTable } from 'markdown-table';
-import 'dotenv/config';
-import retry from 'async-retry';
-import { Client, isNotionClientError } from '@notionhq/client';
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-
-const suffixInlineCode = "`";
-const prefixInlineCode = "`";
-const suffixBold = "**";
-const prefixBold = "**";
-const suffixItalic = "_";
-const prefixItalic = "_";
-const suffixStrikethrough = "~~";
-const prefixStrikethrough = "~~";
-const suffixUnderline = "<u>";
-const prefixUnderline = "</u>";
-function GetPrefixSuffix(type) {
-    switch (type) {
-        case "code":
-            return [prefixInlineCode, suffixInlineCode];
-        case "bold":
-            return [prefixBold, suffixBold];
-        case "italic":
-            return [prefixItalic, suffixItalic];
-        case "strikethrough":
-            return [prefixStrikethrough, suffixStrikethrough];
-        case "underline":
-            return [prefixUnderline, suffixUnderline];
-        default:
-            return ["", ""];
-    }
-}
-const inlineEquation = (text) => {
-    return `$${text}$`;
-};
-const link = (text, href) => {
-    return `[${text}](${href})`;
-};
-const codeBlock = (text, language) => {
-    if (language === "plain text")
-        language = "text";
-    return `\`\`\`${language}
-${text}
-\`\`\``;
-};
-const equation = (text) => {
-    return `$$
-${text}
-$$`;
-};
-const heading1 = (text) => {
-    return `# ${text}`;
-};
-const heading2 = (text) => {
-    return `## ${text}`;
-};
-const heading3 = (text) => {
-    return `### ${text}`;
-};
-const quote = (text) => {
-    // the replace is done to handle multiple lines
-    return `> ${text.replace(/\n/g, "  \n> ")}`;
-};
-const callout = (text, icon) => {
-    let emoji;
-    if (icon?.type === "emoji") {
-        emoji = icon.emoji;
-    }
-    // the replace is done to handle multiple lines
-    return `> ${emoji ? emoji + " " : ""}${text.replace(/\n/g, "  \n> ")}`;
-};
-const bullet = (text, count) => {
-    const renderText = text.trim();
-    return count ? `${count}. ${renderText}` : `- ${renderText}`;
-};
-const todo = (text, checked) => {
-    return checked ? `- [x] ${text}` : `- [ ] ${text}`;
-};
-const image = async (alt, href, convertToBase64 = false) => {
-    // In case the user does not want to convert the images to Base64
-    // or the image is already base64
-    if (!convertToBase64 || href.startsWith("data:")) {
-        if (href.startsWith("data:")) {
-            // Extract base64 data, i.e. the string after 'data:mime/type;base64,'
-            const base64 = href.split(",").pop();
-            // This overrides incorrect data: string format to png
-            // so that browsers can correctly render the data
-            return `![${alt}](data:image/png;base64,${base64})`;
-        }
-        return `![${alt}](${href})`;
-    }
-    else {
-        // Otherwise, download the image and convert it to base64
-        const res = await fetch(href);
-        const buf = await res.arrayBuffer();
-        const base64 = Buffer.from(buf).toString("base64");
-        return `![${alt}](data:image/png;base64,${base64})`;
-    }
-};
-const addTabSpace = (text, n = 0) => {
-    const tab = "	";
-    for (let i = 0; i < n; i++) {
-        if (text.includes("\n")) {
-            const multiLineText = text.split(/(?:^|\n)/).join(`\n${tab}`);
-            text = tab + multiLineText;
-        }
-        else
-            text = tab + text;
-    }
-    return text;
-};
-const divider = () => {
-    return "---";
-};
-const toggle = (summary, children) => {
-    if (!summary)
-        return children || "";
-    return `<details>
-<summary>${summary}</summary>
-${children || ""}
-</details>\n\n`;
-};
-const table = (cells) => {
-    return markdownTable(cells);
-};
-
-const NOTION_API_SECRET = process.env.NOTION_API_SECRET ?? "";
-const NOBLOG_DATABASE_ID = process.env.NOBLOG_DATABASE_ID ?? "";
-const client = new Client({
-    auth: NOTION_API_SECRET,
+import { t as ConfigurationError } from "./config-csbquMhF.js";
+import { a as renderPages, n as resolveStoreLayoutPath, r as writePages, t as createNotionSource } from "./client-CkOIgSvW.js";
+import { config } from "dotenv";
+import { ExitCode, buildApplication, buildCommand, buildRouteMap, help, run, version } from "@stricli/core";
+const app = buildApplication(buildRouteMap({
+	routes: {
+		config: buildRouteMap({
+			routes: { check: buildCommand({
+				loader: async () => import("./config-check.impl-BQvIrgNe.js"),
+				parameters: {
+					flags: { config: {
+						kind: "parsed",
+						brief: "YAML configuration file",
+						placeholder: "PATH",
+						parse: (input) => input
+					} },
+					positional: {
+						kind: "tuple",
+						parameters: []
+					}
+				},
+				docs: { brief: "Validate a YAML configuration without network access" }
+			}) },
+			docs: { brief: "Inspect Noblog configuration" }
+		}),
+		generate: buildCommand({
+			loader: async () => import("./generate.impl-BKu-Ix4a.js"),
+			parameters: {
+				flags: {
+					verbose: {
+						kind: "boolean",
+						brief: "Print diagnostic information",
+						default: false,
+						withNegated: false
+					},
+					config: {
+						kind: "parsed",
+						brief: "YAML configuration file",
+						placeholder: "PATH",
+						parse: (input) => input,
+						optional: true
+					},
+					layout: {
+						kind: "parsed",
+						brief: "Layout path relative to SAVE_PATH",
+						placeholder: "PATH",
+						parse: (input) => input,
+						optional: true
+					},
+					store: {
+						kind: "parsed",
+						brief: "Directory for canonical Markdown files",
+						placeholder: "PATH",
+						parse: (input) => input,
+						optional: true
+					}
+				},
+				aliases: { v: "verbose" },
+				positional: {
+					kind: "tuple",
+					parameters: [{
+						brief: "Public view directory for database posts",
+						placeholder: "SAVE_PATH",
+						parse: (input) => input,
+						optional: true
+					}, {
+						brief: "Deprecated compatibility argument; ignored",
+						placeholder: "SUB_PATH",
+						parse: (input) => input,
+						optional: true
+					}]
+				}
+			},
+			docs: {
+				brief: "Generate blog content from Notion",
+				fullDescription: "Fetch published pages from Notion and write Astro-compatible Markdown files. Only database posts receive public symlinks; child pages live in the canonical store. The legacy SUB_PATH argument is accepted but ignored."
+			}
+		})
+	},
+	docs: {
+		brief: "Generate static blog content from Notion",
+		fullDescription: "Running noblog without a subcommand is equivalent to 'noblog generate'.\nThe legacy 'help' and 'version' commands are also supported.\n\nGeneration requires environment variables:\n  NOTION_API_SECRET    Your Notion API secret\n  NOBLOG_DATABASE_ID   Your Notion database ID"
+	}
+}), {
+	name: "noblog",
+	scanner: { allowArgumentEscapeSequence: true },
+	determineExitCode: (error) => error instanceof ConfigurationError ? 2 : ExitCode.CommandRunError
+}, {
+	help: help({
+		brief: "Show help information",
+		defaultForRouteMap: true,
+		formatting: {
+			caseStyle: "original",
+			useAliasInUsageLine: false,
+			onlyRequiredInUsageLine: false
+		}
+	}),
+	version: version({
+		brief: "Show version information",
+		info: { currentVersion: `noblog v0.3.0-beta.1` },
+		alias: false
+	})
 });
-const numberOfRetry = 2;
-async function ListPages() {
-    const respDatabase = (await client.databases.retrieve({
-        database_id: NOBLOG_DATABASE_ID,
-    }));
-    const reqDataSources = respDatabase.data_sources.map((source) => ({
-        data_source_id: source.id,
-        filter: {
-            and: [
-                {
-                    property: "publish",
-                    checkbox: { equals: true },
-                },
-            ],
-        },
-        sorts: [
-            {
-                property: "date",
-                direction: "descending",
-            },
-        ],
-        page_size: 100,
-    }));
-    let results = [];
-    for (const req of reqDataSources) {
-        let params = req;
-        while (true) {
-            const resp = await retry(async (bail) => {
-                try {
-                    return client.dataSources.query(params);
-                }
-                catch (error) {
-                    if (isNotionClientError(error)) {
-                        bail(error);
-                    }
-                    throw error;
-                }
-            }, { retries: numberOfRetry });
-            results = results.concat(resp.results);
-            if (!resp.has_more) {
-                break;
-            }
-            params.start_cursor = resp.next_cursor;
-        }
-    }
-    return results;
+const PATH_FLAGS = /* @__PURE__ */ new Set([
+	"--config",
+	"--layout",
+	"--store"
+]);
+async function runCli(inputs, context) {
+	const escapeIndex = inputs.indexOf("--");
+	const commandInputs = escapeIndex === -1 ? inputs : inputs.slice(0, escapeIndex);
+	const escapedInputs = escapeIndex === -1 ? [] : inputs.slice(escapeIndex);
+	let normalizedInputs;
+	if (hasLegacyControl(commandInputs, "help")) normalizedInputs = ["--help"];
+	else if (hasLegacyControl(commandInputs, "version") || hasLegacyControl(commandInputs, "--version")) normalizedInputs = ["--version"];
+	else {
+		const remainingInputs = [];
+		for (let index = 0; index < commandInputs.length; index++) {
+			const input = commandInputs[index];
+			if (input === void 0) continue;
+			if (input === "generate" && index !== 0) continue;
+			remainingInputs.push(input);
+			const flagValue = getFlagValue(commandInputs, index);
+			if (PATH_FLAGS.has(input) && flagValue !== void 0) {
+				remainingInputs.push(flagValue);
+				index++;
+			}
+		}
+		normalizedInputs = [...remainingInputs, ...escapedInputs];
+		if (normalizedInputs[0] !== "generate" && normalizedInputs[0] !== "config" && normalizedInputs[0] !== "-h" && normalizedInputs[0] !== "--help" && normalizedInputs[0] !== "--version") normalizedInputs = ["generate", ...normalizedInputs];
+	}
+	await run(app, normalizedInputs, context);
+	const exitCode = context.process.exitCode;
+	if (typeof exitCode === "number" && exitCode < 0) context.process.exitCode = exitCode === ExitCode.InvalidArgument || exitCode === ExitCode.UnknownCommand ? 2 : 1;
 }
-async function GetPage(page_id) {
-    const result = await retry(async (bail) => {
-        try {
-            return (await client.pages.retrieve({
-                page_id: page_id,
-            }));
-        }
-        catch (error) {
-            if (isNotionClientError(error)) {
-                bail(error);
-            }
-            throw error;
-        }
-    }, { retries: numberOfRetry });
-    return result;
+function hasLegacyControl(inputs, control) {
+	for (let index = 0; index < inputs.length; index++) {
+		const input = inputs[index];
+		if (input === void 0) continue;
+		if (PATH_FLAGS.has(input) && getFlagValue(inputs, index) !== void 0) {
+			index++;
+			continue;
+		}
+		if (input === control) return true;
+	}
+	return false;
 }
-async function GetBlockChildren(block_id, totalPage) {
-    const results = [];
-    let pageCount = 0;
-    let start_cursor = undefined;
-    do {
-        const response = (await client.blocks.children.list({
-            start_cursor: start_cursor,
-            block_id: block_id,
-        }));
-        results.push(...response.results);
-        start_cursor = response?.next_cursor;
-        pageCount += 1;
-    } while (start_cursor != null &&
-        (totalPage == null || pageCount < totalPage));
-    ModifyNumberedListObject(results);
-    return results;
+function getFlagValue(inputs, flagIndex) {
+	const value = inputs[flagIndex + 1];
+	return value !== void 0 && !value.startsWith("-") ? value : void 0;
 }
-function ModifyNumberedListObject(blocks) {
-    let numberedListIndex = 0;
-    for (const block of blocks) {
-        if ("type" in block && block.type === "numbered_list_item") {
-            // add numbers
-            // @ts-ignore
-            block.numbered_list_item.number = ++numberedListIndex;
-        }
-        else {
-            numberedListIndex = 0;
-        }
-    }
+//#endregion
+//#region src/workflows/generate.ts
+async function generateBlog(config, options, output) {
+	const notion = createNotionSource(config);
+	const storeLayoutPath = resolveStoreLayoutPath(options);
+	if (options.verbose) output.stderr.write("Fetching posts from Notion...\n");
+	const posts = await notion.listPages();
+	if (options.verbose) output.stderr.write(`Found ${posts.length} pages\nSave path: ${options.savePath}\nStore path: ${options.storePath}\nLayout path: ${options.layoutPath}\n`);
+	await writePages(await renderPages(posts, notion, {
+		layoutPath: storeLayoutPath,
+		recursive: options.recursive,
+		...options.propertyMap !== void 0 ? { propertyMap: options.propertyMap } : {},
+		...options.frontmatter !== void 0 ? { frontmatter: options.frontmatter } : {}
+	}), {
+		savePath: options.savePath,
+		storePath: options.storePath
+	});
+	output.stdout.write("✅ Successfully generated blog content\n");
 }
-
-const BLOCK_TO_DO = "to_do";
-const BLOCK_TOGGLE = "toggle";
-const BLOCK_CALLOUT = "callout";
-const BLOCK_CHILD_PAGE = "child_page";
-const BLOCK_UNSUPPORTED = "supported";
-const BLOCK_SYNCED_BLOCK = "synced_block";
-const BLOCK_NUMBERED_LIST_ITEM = "numbered_list_item";
-const BLOCK_BULLETED_LIST_ITEM = "bulleted_list_item";
-const BLOCK_IMAGE = "image";
-const BLOCK_DIVIDER = "divider";
-const BLOCK_EQUATION = "equation";
-const BLOCK_PDF = "pdf";
-const BLOCK_FILE = "file";
-const BLOCK_VIDEO = "video";
-const BLOCK_EMBED = "embed";
-const BLOCK_BOOKMARK = "bookmark";
-const BLOCK_LINK_PREVIEW = "link_preview";
-const BLOCK_LINK_TO_PAGE = "link_to_page";
-const BLOCK_CHILD_DATABASE = "child_database";
-const BLOCK_TABLE = "table";
-const BLOCK_CODE = "code";
-const BLOCK_HEADING_1 = "heading_1";
-const BLOCK_HEADING_2 = "heading_2";
-const BLOCK_HEADING_3 = "heading_3";
-const BLOCK_QUOTE = "quote";
-const BLOCK_PARAGRAPH = "paragraph";
-const LINEWRAP_NULL = "";
-const LINEWRAP_NEWLINE = "\n";
-
-async function SaveJelly(fname, dir, jelly, dry_run = false) {
-    if (jelly === undefined)
-        return `failed: ${fname} has empty jelly: `;
-    try {
-        if (dry_run) {
-            console.log(jelly.content);
-            return `success: ${fname} saved to ${dir}`;
-        }
-        await fs.mkdir(dir, { recursive: true });
-        const filePath = path.join(dir, fname);
-        await fs.writeFile(filePath, jelly.content, "utf-8");
-        return `success: ${fname} saved to ${filePath}`;
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            return `failed: ${fname} - ${error.message}`;
-        }
-        else {
-            return "failed: an unknown error occurred";
-        }
-    }
+//#endregion
+//#region src/main.ts
+const nodeProcess = {
+	env: process.env,
+	stdout: process.stdout,
+	stderr: process.stderr,
+	get exitCode() {
+		const exitCode = process.exitCode;
+		return typeof exitCode === "number" ? exitCode : null;
+	},
+	set exitCode(value) {
+		process.exitCode = value ?? void 0;
+	}
+};
+async function main(inputs = process.argv.slice(2), context = {
+	process: nodeProcess,
+	generateBlog
+}) {
+	const environment = context.process.env ?? {};
+	const processEnv = Object.fromEntries(Object.entries(environment).filter((entry) => entry[1] !== void 0));
+	config({
+		processEnv,
+		quiet: true
+	});
+	Object.assign(environment, processEnv);
+	await runCli(inputs, context);
 }
-class Noblog {
-    Posts = [];
-    CurrPage = "";
-    SavePath = "./src/pages/posts/";
-    ChildPath = "nob_children/";
-    LayoutPath = "../../layouts/MarkdownPostLayout.astro";
-    MdCollection = {};
-    CustomTransformers = {};
-    constructor(posts, save_path, child_path, layout_path) {
-        this.Posts = posts;
-        if (child_path != undefined) {
-            this.ChildPath = child_path;
-        }
-        if (save_path != undefined) {
-            this.SavePath = save_path;
-        }
-        if (layout_path != undefined) {
-            this.LayoutPath = layout_path;
-        }
-        this.CustomTransformers[BLOCK_CHILD_PAGE] = async (block) => {
-            const page = block;
-            if (!page?.id) {
-                return false;
-            }
-            // if (curr_page.id in this.Post) and (page.id in this.Post) ||
-            //    (curr_page.id not in this.Post) and (page.id not in this.Post)
-            //    * path should be "../pageid"
-            // if (curr_page.id in this.Post) and (page.id not in this.Post)
-            //    * path should be "../save_path/pageid"
-            // if (curr_page.id not in this.Post) and (page.id in this.Post)
-            //    * path should be "../../pageid"
-            let sub_path;
-            const parent_surface = this.Posts.filter((post) => post.id === this.CurrPage).length > 0;
-            const child_surface = this.Posts.filter((post) => post.id === page.id).length > 0;
-            if (parent_surface === child_surface) {
-                sub_path = "";
-            }
-            else if (parent_surface) {
-                sub_path = this.ChildPath;
-            }
-            else {
-                sub_path = "..";
-            }
-            const full_path = path.join("../", sub_path, page.id);
-            return `(」ﾟﾛﾟ)｣ [${page.child_page.title}](${full_path})`;
-        };
-    }
-    // Collect converts all pages in database to markdown files
-    async Collect(recursive = true) {
-        const save_dir = this.SavePath;
-        const sub_dir = path.join(save_dir, this.ChildPath);
-        for (const page of this.Posts) {
-            await this.FromPageId(page.id, recursive);
-        }
-        try {
-            for (const page_id of Object.keys(this.MdCollection)) {
-                let fpath = sub_dir;
-                if (this.Posts.find((page) => page.id === page_id))
-                    fpath = save_dir;
-                await SaveJelly(page_id + ".md", fpath, this.MdCollection[page_id]);
-            }
-            console.log(`success: finish dump all files to "${save_dir}"`);
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                console.log(`failed: consider run verbose with v=true - ${error.message}`);
-            }
-            else {
-                console.log("failed: an unknown error occurred");
-            }
-        }
-    }
-    // FromBlocks converts blocks fetched from notion api to
-    // rendered chunk (which is called jelly). Content in jelly
-    // will be collected to form the final markdown. If recursive
-    // is true, it will also fetch child pages exists in the given
-    // blocks.
-    async FromBlocks(blocks, recursive) {
-        const jelly = { content: "", children: [] };
-        for (const block of blocks) {
-            const subjelly = await this.FromBlocks(block.children, recursive);
-            let line_wrap = LINEWRAP_NULL;
-            if (block.type !== BLOCK_TO_DO &&
-                block.type !== BLOCK_BULLETED_LIST_ITEM &&
-                block.type !== BLOCK_NUMBERED_LIST_ITEM) {
-                line_wrap = LINEWRAP_NEWLINE;
-            }
-            switch (block.type) {
-                case BLOCK_TOGGLE:
-                    jelly.content += toggle(block.parent, subjelly.content);
-                    jelly.children = [...jelly.children, ...subjelly.children];
-                    continue;
-                default:
-                    jelly.content +=
-                        line_wrap + `${addTabSpace(block.parent, 0)}\n` + line_wrap;
-            }
-            if (block.type === BLOCK_CHILD_PAGE) {
-                jelly.children = [...jelly.children, block.blockId];
-                if (recursive)
-                    await this.FromPageId(block.blockId, recursive);
-            }
-            else {
-                jelly.content += subjelly.content;
-                jelly.children = [...jelly.children, ...subjelly.children];
-            }
-        }
-        return jelly;
-    }
-    // FromPageid converts a page id to rendered chunk (which is
-    // called jelly). Content in jelly will be collected to form
-    // the final markdown. If recursive is true, it will also
-    // fetch child pages exists in the given page.
-    async FromPageId(page_id, recursive = true) {
-        // preserve the curr page info
-        const prev_page = this.CurrPage;
-        this.CurrPage = page_id;
-        if (this.MdCollection.hasOwnProperty(page_id)) {
-            return this.MdCollection[page_id];
-        }
-        const blocks = await this.PageToMarkdown(page_id);
-        const jelly = await this.FromBlocks(blocks, recursive);
-        const meta = await GetPage(page_id);
-        const astro_meta = await this.AssembleAstroFrontmatter(meta);
-        jelly.content = astro_meta + jelly.content;
-        this.MdCollection[page_id] = jelly;
-        // restore the prev page info
-        this.CurrPage = prev_page;
-        return jelly;
-    }
-    async PageToMarkdown(id, totalPage) {
-        if (!client) {
-            throw new Error("notion client is not provided");
-        }
-        const blocks = await GetBlockChildren(id, totalPage);
-        const parsedData = await this.BlocksToMarkdown(blocks);
-        return parsedData;
-    }
-    async BlocksToMarkdown(blocks, totalPage = null, mdBlocks = []) {
-        if (!client) {
-            throw new Error("notion client is not provided");
-        }
-        if (!blocks)
-            return mdBlocks;
-        for (const block of blocks) {
-            // @ts-ignore
-            if (block.type === BLOCK_UNSUPPORTED) {
-                continue;
-            }
-            if (!("has_children" in block) || !block.has_children) {
-                mdBlocks.push({
-                    // @ts-ignore
-                    type: block.type,
-                    blockId: block.id,
-                    children: [],
-                    parent: await this.BlockToMarkdown(block),
-                });
-                continue;
-            }
-            const block_id = block.type == BLOCK_SYNCED_BLOCK &&
-                block.synced_block?.synced_from?.block_id
-                ? block.synced_block.synced_from.block_id
-                : block.id;
-            // Get children of this block.
-            const child_blocks = await GetBlockChildren(block_id, totalPage);
-            // Push this block to mdBlocks.
-            mdBlocks.push({
-                type: block.type,
-                blockId: block.id,
-                parent: await this.BlockToMarkdown(block),
-                children: [],
-            });
-            if (block.type === BLOCK_CALLOUT) {
-                continue;
-            }
-            if (!(block.type in this.CustomTransformers)) {
-                continue;
-            }
-            // Recursively call BlocksToMarkdown to collect children. check for custom transformer before parsing child
-            if (mdBlocks !== undefined) {
-                await this.BlocksToMarkdown(child_blocks, totalPage, mdBlocks[mdBlocks.length - 1]?.children);
-            }
-        }
-        return mdBlocks;
-    }
-    async BlockToMarkdown(block) {
-        if (typeof block !== "object" || !("type" in block))
-            return "";
-        let renderedData = "";
-        const { type } = block;
-        if (type in this.CustomTransformers && !!this.CustomTransformers[type]) {
-            const transformer = this.CustomTransformers[type];
-            const customTransformerValue = await transformer(block);
-            if (typeof customTransformerValue === "string")
-                return customTransformerValue;
-        }
-        switch (type) {
-            case BLOCK_IMAGE:
-                const blockContent = block.image;
-                let image_title = "image";
-                const image_caption_plain = blockContent.caption
-                    .map((item) => item.plain_text)
-                    .join("");
-                let link$1 = "";
-                const image_type = blockContent.type;
-                if (image_type === "external") {
-                    link$1 = blockContent.external.url;
-                }
-                if (image_type === "file") {
-                    link$1 = blockContent.file.url;
-                }
-                // image caption with high priority
-                if (image_caption_plain.trim().length > 0) {
-                    image_title = image_caption_plain;
-                }
-                else if (image_type === "file" || image_type === "external") {
-                    const matches = link$1.match(/[^\/\\&\?]+\.\w{3,4}(?=([\?&].*$|$))/);
-                    image_title = matches ? matches[0] : image_title;
-                }
-                return await image(image_title, link$1, false);
-            case BLOCK_DIVIDER:
-                return divider();
-            case BLOCK_EQUATION:
-                return equation(block.equation.expression);
-            case BLOCK_PDF:
-            case BLOCK_FILE:
-            case BLOCK_VIDEO:
-                {
-                    let blockContent;
-                    let title = type;
-                    if (type === BLOCK_PDF)
-                        blockContent = block.pdf;
-                    if (type === BLOCK_FILE)
-                        blockContent = block.file;
-                    if (type === BLOCK_VIDEO)
-                        blockContent = block.video;
-                    const caption = blockContent?.caption
-                        .map((item) => item.plain_text)
-                        .join("");
-                    if (blockContent) {
-                        const file_type = blockContent.type;
-                        let link$1 = "";
-                        if (file_type === "file")
-                            link$1 = blockContent.file.url;
-                        if (file_type === "external")
-                            link$1 = blockContent.external.url;
-                        if (caption && caption.trim().length > 0) {
-                            title = caption;
-                        }
-                        else if (link$1) {
-                            const matches = link$1.match(/[^\/\\&\?]+\.\w{3,4}(?=([\?&].*$|$))/);
-                            title = matches ? matches[0] : type;
-                        }
-                        return link(title, link$1);
-                    }
-                }
-                break;
-            case BLOCK_EMBED:
-            case BLOCK_BOOKMARK:
-            case BLOCK_LINK_PREVIEW:
-            case BLOCK_LINK_TO_PAGE:
-                {
-                    let blockContent;
-                    const title = type;
-                    if (type === BLOCK_EMBED)
-                        blockContent = block.embed;
-                    if (type === BLOCK_BOOKMARK)
-                        blockContent = block.bookmark;
-                    if (type === BLOCK_LINK_PREVIEW)
-                        blockContent = block.link_preview;
-                    if (type === BLOCK_LINK_TO_PAGE &&
-                        block.link_to_page.type === "page_id") {
-                        blockContent = {
-                            url: `https://www.notion.so/${block.link_to_page.page_id}`,
-                        };
-                    }
-                    if (blockContent)
-                        return link(title, blockContent.url);
-                }
-                break;
-            case BLOCK_CHILD_PAGE: {
-                const pageTitle = block.child_page.title;
-                return heading2(pageTitle);
-            }
-            case BLOCK_CHILD_DATABASE: {
-                const pageTitle = block.child_database.title || `child_database`;
-                return heading2(pageTitle);
-            }
-            case BLOCK_TABLE: {
-                const { id, has_children } = block;
-                const tableArr = [];
-                if (has_children) {
-                    const tableRows = await GetBlockChildren(id, 100);
-                    const rowsPromise = tableRows?.map(async (row) => {
-                        const { type } = row;
-                        const cells = row[type]["cells"];
-                        /**
-                         * this is more like a hack since matching the type text was
-                         * difficult. So converting each cell to paragraph type to
-                         * reuse the BlockToMarkdown function
-                         */
-                        const cellStringPromise = cells.map(async (cell) => await this.BlockToMarkdown({
-                            type: BLOCK_PARAGRAPH,
-                            paragraph: { rich_text: cell },
-                        }));
-                        const cellStringArr = await Promise.all(cellStringPromise);
-                        tableArr.push(cellStringArr);
-                    });
-                    await Promise.all(rowsPromise || []);
-                }
-                return table(tableArr);
-            }
-            // Rest of the types:
-            //   "paragraph" "heading_1" "heading_2" "heading_3"
-            //   "bulleted_list_item" "numbered_list_item"
-            //   "quote" "to_do" "template" "synced_block"
-            //   "child_page" "child_database" "code" "callout" "breadcrumb"
-            //   "table_of_contents" "link_to_page" "audio" "unsupported"
-            default: {
-                // @ts-ignore
-                const blockContent = block[type].text || block[type].rich_text || [];
-                const bucket = [];
-                const code_range = [];
-                const bold_range = [];
-                const italic_range = [];
-                const underline_range = [];
-                const strikethrough_range = [];
-                const push_or_merge = (arr, idx) => {
-                    if (arr.length == 0) {
-                        return;
-                    }
-                    // @ts-ignore
-                    if (arr[arr.length - 1][1] === idx) {
-                        // @ts-ignore
-                        arr[arr.length - 1][1] += 1;
-                    }
-                    else {
-                        arr.push([idx, idx + 1]);
-                    }
-                };
-                for (let i = 0; i < blockContent.length; i++) {
-                    const content = blockContent[i];
-                    if (content.type === "equation") {
-                        bucket.push(inlineEquation(content.equation.expression));
-                        continue;
-                    }
-                    let plain_text = content.plain_text;
-                    if (content["href"])
-                        plain_text = link(plain_text, content["href"]);
-                    bucket.push(plain_text);
-                    const annotations = content.annotations;
-                    if (annotations.code)
-                        push_or_merge(code_range, i);
-                    if (annotations.bold)
-                        push_or_merge(bold_range, i);
-                    if (annotations.italic)
-                        push_or_merge(italic_range, i);
-                    if (annotations.underline)
-                        push_or_merge(underline_range, i);
-                    if (annotations.strikethrough)
-                        push_or_merge(strikethrough_range, i);
-                }
-                const annoed_bucket = [];
-                for (const range of code_range)
-                    annoed_bucket.push({ range: range, type: "code" });
-                for (const range of bold_range)
-                    annoed_bucket.push({ range: range, type: "bold" });
-                for (const range of italic_range)
-                    annoed_bucket.push({ range: range, type: "italic" });
-                for (const range of underline_range)
-                    annoed_bucket.push({ range: range, type: "underline" });
-                for (const range of strikethrough_range)
-                    annoed_bucket.push({ range: range, type: "strikethrough" });
-                annoed_bucket.sort(
-                // @ts-ignore
-                (a, b) => a.range[1] - a.range[0] - (b.range[1] - b.range[0]));
-                for (const annoed of annoed_bucket) {
-                    const type = annoed.type;
-                    const [from, to] = annoed.range;
-                    let panno, sanno = GetPrefixSuffix(type);
-                    // @ts-ignore
-                    bucket[from] = panno + bucket[from];
-                    // @ts-ignore
-                    bucket[to - 1] = bucket[to - 1] + sanno;
-                }
-                bucket.forEach((x) => (renderedData += x));
-            }
-        }
-        switch (type) {
-            case BLOCK_CODE:
-                renderedData = codeBlock(renderedData, block[type].language);
-                break;
-            case BLOCK_HEADING_1:
-                renderedData = heading1(renderedData);
-                break;
-            case BLOCK_HEADING_2:
-                renderedData = heading2(renderedData);
-                break;
-            case BLOCK_HEADING_3:
-                renderedData = heading3(renderedData);
-                break;
-            case BLOCK_QUOTE:
-                renderedData = quote(renderedData);
-                break;
-            case BLOCK_CALLOUT:
-                const { id, has_children } = block;
-                let callout_string = "";
-                if (!has_children) {
-                    return callout(renderedData, block.callout.icon);
-                }
-                const callout_children_object = await GetBlockChildren(id, 100);
-                const callout_children = await this.BlocksToMarkdown(callout_children_object);
-                callout_string += `${renderedData}\n`;
-                callout_string += (await this.FromBlocks(callout_children, true))
-                    .content;
-                renderedData = callout(callout_string.trim(), block.callout.icon);
-                break;
-            case BLOCK_BULLETED_LIST_ITEM:
-                renderedData = bullet(renderedData);
-                break;
-            case BLOCK_NUMBERED_LIST_ITEM:
-                renderedData = bullet(renderedData, block.numbered_list_item.number);
-                break;
-            case BLOCK_TO_DO:
-                renderedData = todo(renderedData, block.to_do.checked);
-                break;
-        }
-        return renderedData;
-    }
-    async AssembleAstroFrontmatter(page) {
-        let frontmatter = "";
-        // Default layout
-        const ischild = this.Posts.filter((post) => post.id === page.id).length > 0 ? "" : "../";
-        frontmatter += "layout: " + ischild + this.LayoutPath + "\n";
-        let title = "";
-        let description = "";
-        let tags = [];
-        let pubDate = "";
-        let archived = "";
-        Object.entries(page.properties).forEach(([key, property]) => {
-            switch (property.type) {
-                case "title": // Get title
-                    title = property.title
-                        ?.map((title) => title.plain_text)
-                        .reduce((a, b) => a + b, "");
-                    break;
-                case "multi_select": // Get tags
-                    tags = property.multi_select?.map((tag) => tag.name);
-                    break;
-                case "date": // Get date
-                    pubDate =
-                        property.date?.start ?? new Date().toISOString().split("T")[0];
-                    break;
-                default: // Customized properties from the template given in the Github repo
-                    switch (key) {
-                        case "archived": // Get archived
-                            archived =
-                                property.type === "checkbox" && property.checkbox
-                                    ? "true"
-                                    : "false";
-                            break;
-                        case "description": // Get description
-                            description =
-                                property.type === "rich_text"
-                                    ? property.rich_text
-                                        ?.map((text) => text.plain_text)
-                                        .reduce((a, b) => a + b, "")
-                                    : "";
-                            break;
-                    }
-            }
-        });
-        frontmatter += "title: " + JSON.stringify(title) + "\n";
-        frontmatter += "description: " + JSON.stringify(description) + "\n";
-        frontmatter += "tags: " + JSON.stringify(tags) + "\n";
-        frontmatter += "pubDate: " + JSON.stringify(pubDate) + "\n";
-        frontmatter += "archived: " + JSON.stringify(archived) + "\n";
-        return "---\n" + frontmatter + "---\n";
-    }
-}
-
-function getVersion() {
-    try {
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = dirname(__filename);
-        const packagePath = join(__dirname, "../../package.json");
-        const packageJson = JSON.parse(readFileSync(packagePath, "utf-8"));
-        return packageJson.version;
-    }
-    catch {
-        return "unknown";
-    }
-}
-function help() {
-    console.log(`
-noblog - Generate static blog content from Notion.so
-
-Usage: noblog [command] [options] [SAVE_PATH] [SUB_PATH]
-
-Options:
-  -v, --verbose    Print more messages for debugging
-  -h, --help       Show help message
-  --version        Show version information
-  --layout PATH    Custom layout path (default: ../../layouts/MarkdownPostLayout.astro)
-
-Commands:
-  help     Show this help message
-  version  Show version information
-  generate Generate blog content (default command)
+//#endregion
+//#region src/cli.ts
+await main();
+//#endregion
+export {};
 
-Options:
-  -v, --verbose    Print more messages for debugging
-  -h, --help       Show help message
-  --version        Show version information
-
-Arguments:
-  SAVE_PATH        Directory to save main posts (default: ./src/pages/posts/)
-  SUB_PATH         Subdirectory for nested content (default: nob_children/)
-
-Layout Options:
-  --layout PATH    Custom layout path relative to save directory (default: ../../layouts/MarkdownPostLayout.astro)
-
-Examples:
-  noblog help
-  noblog version
-  noblog generate
-  noblog -v
-  noblog src/pages/posts/ nob_children/
-  noblog --layout ../../layouts/BlogLayout.astro
-  noblog src/posts/ children/ --layout ../../../layouts/CustomLayout.astro -v
-
-Environment Variables:
-  NOTION_API_SECRET    Your Notion API secret
-  NOBLOG_DATABASE_ID   Your Notion database ID
-`);
-}
-function parseArgs(argv) {
-    const options = {
-        verbose: false,
-        help: false,
-        version: false,
-        savePath: "./src/pages/posts/",
-        subPath: "nob_children/",
-        layoutPath: "../../layouts/MarkdownPostLayout.astro",
-    };
-    const positionalArgs = [];
-    for (let i = 0; i < argv.length; i++) {
-        const arg = argv[i];
-        switch (arg) {
-            case "-v":
-            case "--verbose":
-                options.verbose = true;
-                break;
-            case "-h":
-            case "--help":
-            case "help":
-                options.help = true;
-                break;
-            case "--version":
-            case "version":
-                options.version = true;
-                break;
-            case "--layout":
-                if (i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
-                    options.layoutPath = argv[++i];
-                }
-                else {
-                    console.error("Error: --layout requires a path argument");
-                    help();
-                    process.exit(1);
-                }
-                break;
-            case "generate":
-                // Explicit generate command, skip it
-                break;
-            default:
-                if (arg.startsWith("-")) {
-                    console.error(`Unknown option: ${arg}`);
-                    help();
-                    process.exit(1);
-                }
-                positionalArgs.push(arg);
-                break;
-        }
-    }
-    // Handle positional arguments
-    if (positionalArgs.length > 0) {
-        options.savePath = positionalArgs[0];
-    }
-    if (positionalArgs.length > 1) {
-        options.subPath = positionalArgs[1];
-    }
-    if (positionalArgs.length > 2) {
-        console.error("Error: Too many arguments.");
-        help();
-        process.exit(1);
-    }
-    return options;
-}
-async function generateBlog(options) {
-    try {
-        if (options.verbose) {
-            console.log("Fetching posts from Notion...");
-        }
-        const pages = await ListPages();
-        if (options.verbose) {
-            console.log(`Found ${pages.length} pages`);
-            console.log(`Save path: ${options.savePath}`);
-            console.log(`Sub path: ${options.subPath}`);
-            console.log(`Layout path: ${options.layoutPath}`);
-        }
-        const nob = new Noblog(pages, options.savePath, options.subPath, options.layoutPath);
-        await nob.Collect(true);
-        console.log(`✅ Successfully generated blog content`);
-    }
-    catch (error) {
-        console.error(`❌ Error generating blog content:`);
-        if (error instanceof Error) {
-            console.error(`   ${error.message}`);
-            if (options.verbose) {
-                console.error(error.stack);
-            }
-        }
-        else {
-            console.error(`   An unknown error occurred`);
-        }
-        process.exit(1);
-    }
-}
-async function main() {
-    const argv = process.argv.slice(2);
-    if (argv.length === 0) {
-        // Default behavior: generate with default options
-        await generateBlog({
-            verbose: false,
-            help: false,
-            version: false,
-            savePath: "./src/pages/posts/",
-            subPath: "nob_children/",
-            layoutPath: "../../layouts/MarkdownPostLayout.astro",
-        });
-        return;
-    }
-    const options = parseArgs(argv);
-    if (options.help) {
-        help();
-        return;
-    }
-    if (options.version) {
-        console.log(`noblog v${getVersion()}`);
-        return;
-    }
-    await generateBlog(options);
-}
-main().catch((error) => {
-    console.error(`❌ Unexpected error:`, error);
-    process.exit(1);
-});
-//# sourceMappingURL=generate.js.map
+//# sourceMappingURL=generate.js.map